postdoc 0.1.2 → 0.2.0.beta4

data/node_modules/puppeteer/lib/helper.js

@@ -0,0 +1,248 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const debugError = require('debug')(`puppeteer:error`);
+/** @type {?Map<string, boolean>} */
+let apiCoverage = null;
+let projectRoot = null;
+class Helper {
+  /**
+   * @param {Function|string} fun
+   * @param {!Array<*>} args
+   * @return {string}
+   */
+  static evaluationString(fun, ...args) {
+    if (Helper.isString(fun)) {
+      console.assert(args.length === 0, 'Cannot evaluate a string with arguments');
+      return /** @type {string} */ (fun);
+    }
+    return `(${fun})(${args.map(serializeArgument).join(',')})`;
+
+    /**
+     * @param {*} arg
+     * @return {string}
+     */
+    function serializeArgument(arg) {
+      if (Object.is(arg, undefined))
+        return 'undefined';
+      return JSON.stringify(arg);
+    }
+  }
+
+  /**
+   * @return {string}
+   */
+  static projectRoot() {
+    if (!projectRoot) {
+      // Project root will be different for node6-transpiled code.
+      projectRoot = fs.existsSync(path.join(__dirname, '..', 'package.json')) ? path.join(__dirname, '..') : path.join(__dirname, '..', '..');
+    }
+    return projectRoot;
+  }
+
+  /**
+   * @param {!Protocol.Runtime.ExceptionDetails} exceptionDetails
+   * @return {string}
+   */
+  static getExceptionMessage(exceptionDetails) {
+    if (exceptionDetails.exception)
+      return exceptionDetails.exception.description;
+    let message = exceptionDetails.text;
+    if (exceptionDetails.stackTrace) {
+      for (const callframe of exceptionDetails.stackTrace.callFrames) {
+        const location = callframe.url + ':' + callframe.lineNumber + ':' + callframe.columnNumber;
+        const functionName = callframe.functionName || '<anonymous>';
+        message += `\n    at ${functionName} (${location})`;
+      }
+    }
+    return message;
+  }
+
+  /**
+   * @param {!Protocol.Runtime.RemoteObject} remoteObject
+   * @return {*}
+   */
+  static valueFromRemoteObject(remoteObject) {
+    console.assert(!remoteObject.objectId, 'Cannot extract value when objectId is given');
+    if (remoteObject.unserializableValue) {
+      switch (remoteObject.unserializableValue) {
+        case '-0':
+          return -0;
+        case 'NaN':
+          return NaN;
+        case 'Infinity':
+          return Infinity;
+        case '-Infinity':
+          return -Infinity;
+        default:
+          throw new Error('Unsupported unserializable value: ' + remoteObject.unserializableValue);
+      }
+    }
+    return remoteObject.value;
+  }
+
+  /**
+   * @param {!Puppeteer.CDPSession} client
+   * @param {!Protocol.Runtime.RemoteObject} remoteObject
+   */
+  static async releaseObject(client, remoteObject) {
+    if (!remoteObject.objectId)
+      return;
+    await client.send('Runtime.releaseObject', {objectId: remoteObject.objectId}).catch(error => {
+      // Exceptions might happen in case of a page been navigated or closed.
+      // Swallow these since they are harmless and we don't leak anything in this case.
+      debugError(error);
+    });
+  }
+
+  /**
+   * @param {!Object} classType
+   * @param {string=} publicName
+   */
+  static tracePublicAPI(classType, publicName) {
+    let className = publicName || classType.prototype.constructor.name;
+    className = className.substring(0, 1).toLowerCase() + className.substring(1);
+    const debug = require('debug')(`puppeteer:${className}`);
+    if (!debug.enabled && !apiCoverage)
+      return;
+    for (const methodName of Reflect.ownKeys(classType.prototype)) {
+      const method = Reflect.get(classType.prototype, methodName);
+      if (methodName === 'constructor' || typeof methodName !== 'string' || methodName.startsWith('_') || typeof method !== 'function')
+        continue;
+      if (apiCoverage)
+        apiCoverage.set(`${className}.${methodName}`, false);
+      Reflect.set(classType.prototype, methodName, function(...args) {
+        const argsText = args.map(stringifyArgument).join(', ');
+        const callsite = `${className}.${methodName}(${argsText})`;
+        if (debug.enabled)
+          debug(callsite);
+        if (apiCoverage)
+          apiCoverage.set(`${className}.${methodName}`, true);
+        return method.call(this, ...args);
+      });
+    }
+
+    if (classType.Events) {
+      if (apiCoverage) {
+        for (const event of Object.values(classType.Events))
+          apiCoverage.set(`${className}.emit(${JSON.stringify(event)})`, false);
+      }
+      const method = Reflect.get(classType.prototype, 'emit');
+      Reflect.set(classType.prototype, 'emit', function(event, ...args) {
+        const argsText = [JSON.stringify(event)].concat(args.map(stringifyArgument)).join(', ');
+        if (debug.enabled && this.listenerCount(event))
+          debug(`${className}.emit(${argsText})`);
+        if (apiCoverage && this.listenerCount(event))
+          apiCoverage.set(`${className}.emit(${JSON.stringify(event)})`, true);
+        return method.call(this, event, ...args);
+      });
+    }
+
+    /**
+     * @param {!Object} arg
+     * @return {string}
+     */
+    function stringifyArgument(arg) {
+      if (Helper.isString(arg) || Helper.isNumber(arg) || !arg)
+        return JSON.stringify(arg);
+      if (typeof arg === 'function') {
+        let text = arg.toString().split('\n').map(line => line.trim()).join('');
+        if (text.length > 20)
+          text = text.substring(0, 20) + '…';
+        return `"${text}"`;
+      }
+      const state = {};
+      const keys = Object.keys(arg);
+      for (const key of keys) {
+        const value = arg[key];
+        if (Helper.isString(value) || Helper.isNumber(value))
+          state[key] = JSON.stringify(value);
+      }
+      const name = arg.constructor.name === 'Object' ? '' : arg.constructor.name;
+      return name + JSON.stringify(state);
+    }
+  }
+
+  /**
+   * @param {!NodeJS.EventEmitter} emitter
+   * @param {string} eventName
+   * @param {function(?)} handler
+   * @return {{emitter: !NodeJS.EventEmitter, eventName: string, handler: function(?)}}
+   */
+  static addEventListener(emitter, eventName, handler) {
+    emitter.on(eventName, handler);
+    return { emitter, eventName, handler };
+  }
+
+  /**
+   * @param {!Array<{emitter: !NodeJS.EventEmitter, eventName: string, handler: function(?)}>} listeners
+   */
+  static removeEventListeners(listeners) {
+    for (const listener of listeners)
+      listener.emitter.removeListener(listener.eventName, listener.handler);
+    listeners.splice(0, listeners.length);
+  }
+
+  /**
+   * @return {?Map<string, boolean>}
+   */
+  static publicAPICoverage() {
+    return apiCoverage;
+  }
+
+  static recordPublicAPICoverage() {
+    apiCoverage = new Map();
+  }
+
+  /**
+   * @param {!Object} obj
+   * @return {boolean}
+   */
+  static isString(obj) {
+    return typeof obj === 'string' || obj instanceof String;
+  }
+
+  /**
+   * @param {!Object} obj
+   * @return {boolean}
+   */
+  static isNumber(obj) {
+    return typeof obj === 'number' || obj instanceof Number;
+  }
+
+  static promisify(nodeFunction) {
+    function promisified(...args) {
+      return new Promise((resolve, reject) => {
+        function callback(err, ...result) {
+          if (err)
+            return reject(err);
+          if (result.length === 1)
+            return resolve(result[0]);
+          return resolve(result);
+        }
+        nodeFunction.call(null, ...args, callback);
+      });
+    }
+    return promisified;
+  }
+}
+
+module.exports = {
+  helper: Helper,
+  debugError
+};

data/node_modules/puppeteer/node6/lib/Browser.js

@@ -0,0 +1,394 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { helper } = require('./helper');
+const Target = require('./Target');
+const EventEmitter = require('events');
+const TaskQueue = require('./TaskQueue');
+
+class Browser extends EventEmitter {
+  /**
+   * @param {!Puppeteer.Connection} connection
+   * @param {!BrowserOptions=} options
+   * @param {?Puppeteer.ChildProcess} process
+   * @param {(function():Promise)=} closeCallback
+   */
+  constructor(connection, options = {}, process, closeCallback) {
+    super();
+    this._ignoreHTTPSErrors = !!options.ignoreHTTPSErrors;
+    this._appMode = !!options.appMode;
+    this._process = process;
+    this._screenshotTaskQueue = new TaskQueue();
+    this._connection = connection;
+    this._closeCallback = closeCallback || new Function();
+    /** @type {Map<string, Target>} */
+    this._targets = new Map();
+    this._connection.setClosedCallback(() => {
+      this.emit(Browser.Events.Disconnected);
+    });
+    this._connection.on('Target.targetCreated', this._targetCreated.bind(this));
+    this._connection.on('Target.targetDestroyed', this._targetDestroyed.bind(this));
+    this._connection.on('Target.targetInfoChanged', this._targetInfoChanged.bind(this));
+  }
+
+  /**
+   * @return {?Puppeteer.ChildProcess}
+   */
+  process() {
+    return this._process;
+  }
+
+  /**
+   * @param {!Puppeteer.Connection} connection
+   * @param {!BrowserOptions=} options
+   * @param {?Puppeteer.ChildProcess} process
+   * @param {function()=} closeCallback
+   */
+  static /* async */ create(connection, options, process, closeCallback) {return (fn => {
+  const gen = fn.call(this);
+  return new Promise((resolve, reject) => {
+    function step(key, arg) {
+      let info, value;
+      try {
+        info = gen[key](arg);
+        value = info.value;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        return Promise.resolve(value).then(
+            value => {
+              step('next', value);
+            },
+            err => {
+              step('throw', err);
+            });
+      }
+    }
+    return step('next');
+  });
+})(function*(){
+    const browser = new Browser(connection, options, process, closeCallback);
+    (yield connection.send('Target.setDiscoverTargets', {discover: true}));
+    return browser;
+  });}
+
+  /**
+   * @param {{targetInfo: !Puppeteer.TargetInfo}} event
+   */
+  /* async */ _targetCreated(event) {return (fn => {
+  const gen = fn.call(this);
+  return new Promise((resolve, reject) => {
+    function step(key, arg) {
+      let info, value;
+      try {
+        info = gen[key](arg);
+        value = info.value;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        return Promise.resolve(value).then(
+            value => {
+              step('next', value);
+            },
+            err => {
+              step('throw', err);
+            });
+      }
+    }
+    return step('next');
+  });
+})(function*(){
+    const targetInfo = event.targetInfo;
+    const target = new Target(targetInfo, this, () => this._connection.createSession(targetInfo.targetId), this._ignoreHTTPSErrors, !this._appMode, this._screenshotTaskQueue);
+    console.assert(!this._targets.has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
+    this._targets.set(event.targetInfo.targetId, target);
+
+    if ((yield target._initializedPromise))
+      this.emit(Browser.Events.TargetCreated, target);
+  });}
+
+  /**
+   * @param {{targetId: string}} event
+   */
+  /* async */ _targetDestroyed(event) {return (fn => {
+  const gen = fn.call(this);
+  return new Promise((resolve, reject) => {
+    function step(key, arg) {
+      let info, value;
+      try {
+        info = gen[key](arg);
+        value = info.value;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        return Promise.resolve(value).then(
+            value => {
+              step('next', value);
+            },
+            err => {
+              step('throw', err);
+            });
+      }
+    }
+    return step('next');
+  });
+})(function*(){
+    const target = this._targets.get(event.targetId);
+    target._initializedCallback(false);
+    this._targets.delete(event.targetId);
+    target._closedCallback();
+    if ((yield target._initializedPromise))
+      this.emit(Browser.Events.TargetDestroyed, target);
+  });}
+
+  /**
+   * @param {{targetInfo: !Puppeteer.TargetInfo}} event
+   */
+  _targetInfoChanged(event) {
+    const target = this._targets.get(event.targetInfo.targetId);
+    console.assert(target, 'target should exist before targetInfoChanged');
+    const previousURL = target.url();
+    const wasInitialized = target._isInitialized;
+    target._targetInfoChanged(event.targetInfo);
+    if (wasInitialized && previousURL !== target.url())
+      this.emit(Browser.Events.TargetChanged, target);
+  }
+
+  /**
+   * @return {string}
+   */
+  wsEndpoint() {
+    return this._connection.url();
+  }
+
+  /**
+   * @return {!Promise<!Puppeteer.Page>}
+   */
+  /* async */ newPage() {return (fn => {
+  const gen = fn.call(this);
+  return new Promise((resolve, reject) => {
+    function step(key, arg) {
+      let info, value;
+      try {
+        info = gen[key](arg);
+        value = info.value;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        return Promise.resolve(value).then(
+            value => {
+              step('next', value);
+            },
+            err => {
+              step('throw', err);
+            });
+      }
+    }
+    return step('next');
+  });
+})(function*(){
+    const {targetId} = (yield this._connection.send('Target.createTarget', {url: 'about:blank'}));
+    const target = (yield this._targets.get(targetId));
+    console.assert((yield target._initializedPromise), 'Failed to create target for page');
+    const page = (yield target.page());
+    return page;
+  });}
+
+  /**
+   * @return {!Array<!Target>}
+   */
+  targets() {
+    return Array.from(this._targets.values()).filter(target => target._isInitialized);
+  }
+
+  /**
+   * @return {!Promise<!Array<!Puppeteer.Page>>}
+   */
+  /* async */ pages() {return (fn => {
+  const gen = fn.call(this);
+  return new Promise((resolve, reject) => {
+    function step(key, arg) {
+      let info, value;
+      try {
+        info = gen[key](arg);
+        value = info.value;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        return Promise.resolve(value).then(
+            value => {
+              step('next', value);
+            },
+            err => {
+              step('throw', err);
+            });
+      }
+    }
+    return step('next');
+  });
+})(function*(){
+    const pages = (yield Promise.all(this.targets().map(target => target.page())));
+    return pages.filter(page => !!page);
+  });}
+
+  /**
+   * @return {!Promise<string>}
+   */
+  /* async */ version() {return (fn => {
+  const gen = fn.call(this);
+  return new Promise((resolve, reject) => {
+    function step(key, arg) {
+      let info, value;
+      try {
+        info = gen[key](arg);
+        value = info.value;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        return Promise.resolve(value).then(
+            value => {
+              step('next', value);
+            },
+            err => {
+              step('throw', err);
+            });
+      }
+    }
+    return step('next');
+  });
+})(function*(){
+    const version = (yield this._getVersion());
+    return version.product;
+  });}
+
+  /**
+   * @return {!Promise<string>}
+   */
+  /* async */ userAgent() {return (fn => {
+  const gen = fn.call(this);
+  return new Promise((resolve, reject) => {
+    function step(key, arg) {
+      let info, value;
+      try {
+        info = gen[key](arg);
+        value = info.value;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        return Promise.resolve(value).then(
+            value => {
+              step('next', value);
+            },
+            err => {
+              step('throw', err);
+            });
+      }
+    }
+    return step('next');
+  });
+})(function*(){
+    const version = (yield this._getVersion());
+    return version.userAgent;
+  });}
+
+  /* async */ close() {return (fn => {
+  const gen = fn.call(this);
+  return new Promise((resolve, reject) => {
+    function step(key, arg) {
+      let info, value;
+      try {
+        info = gen[key](arg);
+        value = info.value;
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        return Promise.resolve(value).then(
+            value => {
+              step('next', value);
+            },
+            err => {
+              step('throw', err);
+            });
+      }
+    }
+    return step('next');
+  });
+})(function*(){
+    (yield this._closeCallback.call(null));
+    this.disconnect();
+  });}
+
+  disconnect() {
+    this._connection.dispose();
+  }
+
+  /**
+   * @return {!Promise<!Object>}
+   */
+  _getVersion() {
+    return this._connection.send('Browser.getVersion');
+  }
+}
+
+/** @enum {string} */
+Browser.Events = {
+  TargetCreated: 'targetcreated',
+  TargetDestroyed: 'targetdestroyed',
+  TargetChanged: 'targetchanged',
+  Disconnected: 'disconnected'
+};
+
+helper.tracePublicAPI(Browser);
+
+module.exports = Browser;
+
+/**
+ * @typedef {Object} BrowserOptions
+ * @property {boolean=} appMode
+ * @property {boolean=} ignoreHTTPSErrors
+ */