function create(args, config) {
return new Promise(resolve => resolve(new _phantom2.default(args, config)));
}...
## Super easy to use
```js
const phantom = require('phantom');
(async function() {
const instance = await phantom.create();
const page = await instance.createPage();
await page.on("onResourceRequested", function(requestData) {
console.info('Requesting', requestData.url)
});
const status = await page.open('https://stackoverflow.com/');
console.log(status);
...class Command {
constructor(target, name, params = []) {
this.id = NEXT_ID++;
this.target = target;
this.name = name;
this.params = params;
this.deferred = null;
}
}...
* @param [config] configuration object
* @param [config.phantomPath] path to phantomjs executable
* @param [config.logger] object containing functions used for logging
* @param [config.logLevel] log level to apply on the logger (if unset or default)
* @returns {Promise}
*/
function create(args, config) {
return new Promise(resolve => resolve(new _phantom2.default(args, config)));
}
exports.default = { create };
module.exports.create = create;
...function create(args, config) {
return new Promise(resolve => resolve(new _phantom2.default(args, config)));
}...
## Super easy to use
```js
const phantom = require('phantom');
(async function() {
const instance = await phantom.create();
const page = await instance.createPage();
await page.on("onResourceRequested", function(requestData) {
console.info('Requesting', requestData.url)
});
const status = await page.open('https://stackoverflow.com/');
console.log(status);
...class OutObject {
constructor(phantom) {
this._phantom = phantom;
this.target = 'OutObject$' + _crypto2.default.randomBytes(16).toString('hex');
}
property(name) {
return this._phantom.execute(this.target, 'property', [name]);
}
}...
* @param [config] configuration object
* @param [config.phantomPath] path to phantomjs executable
* @param [config.logger] object containing functions used for logging
* @param [config.logLevel] log level to apply on the logger (if unset or default)
* @returns {Promise}
*/
function create(args, config) {
return new Promise(resolve => resolve(new _phantom2.default(args, config)));
}
exports.default = { create };
module.exports.create = create;
...class Page {
constructor(phantom, pageId) {
this.target = 'page$' + pageId;
this.phantom = phantom;
}
/**
* Add an event listener to the page on phantom
*
* @param event The name of the event (Ej. onResourceLoaded)
* @param [runOnPhantom=false] Indicate if the event must run on the phantom runtime or not
* @param listener The event listener. When runOnPhantom=true, this listener code would be run on phantom, and thus,
* all the closure info wont work
* @returns {*}
*/
on(event, runOnPhantom, listener) {
let mustRunOnPhantom;
let callback;
let args;
if (typeof runOnPhantom === 'function') {
args = [].slice.call(arguments, 2);
mustRunOnPhantom = false;
callback = runOnPhantom.bind(this);
} else {
args = [].slice.call(arguments, 3);
mustRunOnPhantom = runOnPhantom;
callback = mustRunOnPhantom ? listener : listener.bind(this);
}
return this.phantom.on(event, this.target, mustRunOnPhantom, callback, args);
}
/**
* Removes an event listener
*
* @param event the event name
* @returns {*}
*/
off(event) {
return this.phantom.off(event, this.target);
}
/**
* Invokes an asynchronous method
*/
invokeAsyncMethod() {
return this.phantom.execute(this.target, 'invokeAsyncMethod', [].slice.call(arguments));
}
/**
* Invokes a method
*/
invokeMethod() {
return this.phantom.execute(this.target, 'invokeMethod', [].slice.call(arguments));
}
/**
* Defines a method
*/
defineMethod(name, definition) {
return this.phantom.execute(this.target, 'defineMethod', [name, definition]);
}
/**
* Gets or sets a property
*/
property() {
return this.phantom.execute(this.target, 'property', [].slice.call(arguments));
}
/**
* Gets or sets a setting
*/
setting() {
return this.phantom.execute(this.target, 'setting', [].slice.call(arguments));
}
}...
* @param [config] configuration object
* @param [config.phantomPath] path to phantomjs executable
* @param [config.logger] object containing functions used for logging
* @param [config.logLevel] log level to apply on the logger (if unset or default)
* @returns {Promise}
*/
function create(args, config) {
return new Promise(resolve => resolve(new _phantom2.default(args, config)));
}
exports.default = { create };
module.exports.create = create;
...class Phantom {
/**
* Creates a new instance of Phantom
*
* @param args command args to pass to phantom process
* @param [phantomPath] path to phantomjs executable
* @param [logger] object containing functions used for logging
* @param [logLevel] log level to apply on the logger (if unset or default)
*/
constructor(args = [], { phantomPath = _phantomjsPrebuilt2.default.path, logger = defaultLogger, logLevel = defaultLogLevel } = {
phantomPath: _phantomjsPrebuilt2.default.path,
logger: defaultLogger,
logLevel: defaultLogLevel
}) {
if (!Array.isArray(args)) {
throw new Error('Unexpected type of parameters. Expecting args to be array.');
}
if (typeof phantomPath !== 'string') {
throw new Error('PhantomJS binary was not found. ' + 'This generally means something went wrong when installing phantomjs
-prebuilt. Exiting.');
}
if (typeof logger !== 'object') {
throw new Error('logger must be ba valid object.');
}
logger.debug = logger.debug || (() => undefined);
logger.info = logger.info || (() => undefined);
logger.warn = logger.warn || (() => undefined);
logger.error = logger.error || (() => undefined);
this.logger = logger;
if (logLevel !== defaultLogLevel) {
this.logger = createLogger();
this.logger.transports.console.level = logLevel;
}
const pathToShim = _path2.default.normalize(__dirname + '/shim/index.js');
this.logger.debug(`Starting ${phantomPath} ${args.concat([pathToShim]).join(' ')}`);
this.process = (0, _child_process.spawn)(phantomPath, args.concat([pathToShim]), { env: process.env });
this.process.stdin.setDefaultEncoding('utf-8');
this.commands = new Map();
this.events = new Map();
this.process.stdout.pipe((0, _split2.default)()).on('data', data => {
const message = data.toString('utf8');
if (message[0] === '>') {
// Server end has finished NOOP, lets allow NOOP again..
if (message === '>' + NOOP) {
this.logger.debug('Received NOOP command.');
this.isNoOpInProgress = false;
return;
}
const json = message.substr(1);
this.logger.debug('Parsing: %s', json);
const parsedJson = JSON.parse(json);
const command = this.commands.get(parsedJson.id);
if (command != null) {
const deferred = command.deferred;
if (deferred != null) {
if (parsedJson.error === undefined) {
deferred.resolve(parsedJson.response);
} else {
deferred.reject(new Error(parsedJson.error));
}
} else {
this.logger.error('deferred object not found for command.id: ' + parsedJson.id);
}
this.commands.delete(command.id);
} else {
this.logger.error('command not found for command.id: ' + parsedJson.id);
}
} else if (message.indexOf('<event>') === 0) {
const json = message.substr(7);
this.logger.debug('Parsing: %s', json);
const event = JSON.parse(json);
const emitter = this.events.get(event.target);
if (emitter) {
emitter.emit.apply(emitter, [event.type].concat(event.args));
}
} else if (message && message.length > 0) {
this.logger.info(message);
}
});
this.process.stderr.on('data', data => this.logger.error(data.toString('utf8')));
this.process.on('exit', code => {
this.logger.debug(`Child exited with code {${code}}`);
this._rejectAllComman ......
* @param [config] configuration object
* @param [config.phantomPath] path to phantomjs executable
* @param [config.logger] object containing functions used for logging
* @param [config.logLevel] log level to apply on the logger (if unset or default)
* @returns {Promise}
*/
function create(args, config) {
return new Promise(resolve => resolve(new _phantom2.default(args, config)));
}
exports.default = { create };
module.exports.create = create;
...