postdoc 0.1.2 → 0.2.0.beta4

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

@@ -0,0 +1,362 @@
+/**
+ * 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 os = require('os');
+const path = require('path');
+const removeFolder = require('rimraf');
+const childProcess = require('child_process');
+const BrowserFetcher = require('./BrowserFetcher');
+const {Connection} = require('./Connection');
+const Browser = require('./Browser');
+const readline = require('readline');
+const fs = require('fs');
+const {helper, debugError} = require('./helper');
+const ChromiumRevision = require(path.join(helper.projectRoot(), 'package.json')).puppeteer.chromium_revision;
+
+const mkdtempAsync = helper.promisify(fs.mkdtemp);
+const removeFolderAsync = helper.promisify(removeFolder);
+
+const CHROME_PROFILE_PATH = path.join(os.tmpdir(), 'puppeteer_dev_profile-');
+
+const DEFAULT_ARGS = [
+  '--disable-background-networking',
+  '--disable-background-timer-throttling',
+  '--disable-client-side-phishing-detection',
+  '--disable-default-apps',
+  '--disable-dev-shm-usage',
+  '--disable-extensions',
+  '--disable-hang-monitor',
+  '--disable-popup-blocking',
+  '--disable-prompt-on-repost',
+  '--disable-sync',
+  '--disable-translate',
+  '--metrics-recording-only',
+  '--no-first-run',
+  '--safebrowsing-disable-auto-update',
+];
+
+const AUTOMATION_ARGS = [
+  '--enable-automation',
+  '--password-store=basic',
+  '--use-mock-keychain',
+];
+
+class Launcher {
+  /**
+   * @param {!LaunchOptions=} options
+   * @return {!Promise<!Browser>}
+   */
+  static /* async */ launch(options) {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*(){
+    options = Object.assign({}, options || {});
+    console.assert(!options.ignoreDefaultArgs || !options.appMode, '`appMode` flag cannot be used together with `ignoreDefaultArgs`');
+    let temporaryUserDataDir = null;
+    const chromeArguments = [];
+    if (!options.ignoreDefaultArgs)
+      chromeArguments.push(...DEFAULT_ARGS);
+    if (options.appMode) {
+      options.headless = false;
+      options.pipe = true;
+    } else if (!options.ignoreDefaultArgs) {
+      chromeArguments.push(...AUTOMATION_ARGS);
+    }
+
+    if (!options.ignoreDefaultArgs || !chromeArguments.some(argument => argument.startsWith('--remote-debugging-')))
+      chromeArguments.push(options.pipe ? '--remote-debugging-pipe' : '--remote-debugging-port=0');
+
+    if (!options.args || !options.args.some(arg => arg.startsWith('--user-data-dir'))) {
+      if (!options.userDataDir)
+        temporaryUserDataDir = (yield mkdtempAsync(CHROME_PROFILE_PATH));
+
+      chromeArguments.push(`--user-data-dir=${options.userDataDir || temporaryUserDataDir}`);
+    }
+    if (options.devtools === true) {
+      chromeArguments.push('--auto-open-devtools-for-tabs');
+      options.headless = false;
+    }
+    if (typeof options.headless !== 'boolean' || options.headless) {
+      chromeArguments.push(
+          '--headless',
+          '--disable-gpu',
+          '--hide-scrollbars',
+          '--mute-audio'
+      );
+    }
+    let chromeExecutable = options.executablePath;
+    if (typeof chromeExecutable !== 'string') {
+      const browserFetcher = new BrowserFetcher();
+      const revisionInfo = browserFetcher.revisionInfo(ChromiumRevision);
+      console.assert(revisionInfo.local, `Chromium revision is not downloaded. Run "npm install" or "yarn install"`);
+      chromeExecutable = revisionInfo.executablePath;
+    }
+    if (Array.isArray(options.args))
+      chromeArguments.push(...options.args);
+
+
+    const usePipe = chromeArguments.includes('--remote-debugging-pipe');
+    const stdio = ['pipe', 'pipe', 'pipe'];
+    if (usePipe)
+      stdio.push('pipe', 'pipe');
+    const chromeProcess = childProcess.spawn(
+        chromeExecutable,
+        chromeArguments,
+        {
+          // On non-windows platforms, `detached: false` makes child process a leader of a new
+          // process group, making it possible to kill child process tree with `.kill(-pid)` command.
+          // @see https://nodejs.org/api/child_process.html#child_process_options_detached
+          detached: process.platform !== 'win32',
+          env: options.env || process.env,
+          stdio
+        }
+    );
+
+    if (options.dumpio) {
+      chromeProcess.stderr.pipe(process.stderr);
+      chromeProcess.stdout.pipe(process.stdout);
+    }
+
+    let chromeClosed = false;
+    const waitForChromeToClose = new Promise((fulfill, reject) => {
+      chromeProcess.once('close', () => {
+        chromeClosed = true;
+        // Cleanup as processes exit.
+        if (temporaryUserDataDir) {
+          removeFolderAsync(temporaryUserDataDir)
+              .then(() => fulfill())
+              .catch(err => console.error(err));
+        } else {
+          fulfill();
+        }
+      });
+    });
+
+    const listeners = [ helper.addEventListener(process, 'exit', killChrome) ];
+    if (options.handleSIGINT !== false)
+      listeners.push(helper.addEventListener(process, 'SIGINT', () => { killChrome(); process.exit(130); }));
+    if (options.handleSIGTERM !== false)
+      listeners.push(helper.addEventListener(process, 'SIGTERM', gracefullyCloseChrome));
+    if (options.handleSIGHUP !== false)
+      listeners.push(helper.addEventListener(process, 'SIGHUP', gracefullyCloseChrome));
+    /** @type {?Connection} */
+    let connection = null;
+    try {
+      const connectionDelay = options.slowMo || 0;
+      if (!usePipe) {
+        const timeout = helper.isNumber(options.timeout) ? options.timeout : 30000;
+        const browserWSEndpoint = (yield waitForWSEndpoint(chromeProcess, timeout));
+        connection = (yield Connection.createForWebSocket(browserWSEndpoint, connectionDelay));
+      } else {
+        connection = Connection.createForPipe(/** @type {!NodeJS.WritableStream} */(chromeProcess.stdio[3]), /** @type {!NodeJS.ReadableStream} */ (chromeProcess.stdio[4]), connectionDelay);
+      }
+      return Browser.create(connection, options, chromeProcess, gracefullyCloseChrome);
+    } catch (e) {
+      killChrome();
+      throw e;
+    }
+
+    /**
+     * @return {Promise}
+     */
+    function gracefullyCloseChrome() {
+      helper.removeEventListeners(listeners);
+      if (temporaryUserDataDir) {
+        killChrome();
+      } else if (connection) {
+        // Attempt to close chrome gracefully
+        connection.send('Browser.close').catch(error => {
+          debugError(error);
+          killChrome();
+        });
+      }
+      return waitForChromeToClose;
+    }
+
+    // This method has to be sync to be used as 'exit' event handler.
+    function killChrome() {
+      helper.removeEventListeners(listeners);
+      if (chromeProcess.pid && !chromeProcess.killed && !chromeClosed) {
+        // Force kill chrome.
+        try {
+          if (process.platform === 'win32')
+            childProcess.execSync(`taskkill /pid ${chromeProcess.pid} /T /F`);
+          else
+            process.kill(-chromeProcess.pid, 'SIGKILL');
+        } catch (e) {
+          // the process might have already stopped
+        }
+      }
+      // Attempt to remove temporary profile directory to avoid littering.
+      try {
+        removeFolder.sync(temporaryUserDataDir);
+      } catch (e) { }
+    }
+  });}
+
+  /**
+   * @return {!Array<string>}
+   */
+  static defaultArgs() {
+    return DEFAULT_ARGS.concat(AUTOMATION_ARGS);
+  }
+
+  /**
+   * @return {string}
+   */
+  static executablePath() {
+    const browserFetcher = new BrowserFetcher();
+    const revisionInfo = browserFetcher.revisionInfo(ChromiumRevision);
+    return revisionInfo.executablePath;
+  }
+
+  /**
+   * @param {!Object=} options
+   * @return {!Promise<!Browser>}
+   */
+  static /* async */ connect(options = {}) {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 connectionDelay = options.slowMo || 0;
+    const connection = (yield Connection.createForWebSocket(options.browserWSEndpoint, connectionDelay));
+    return Browser.create(connection, options, null, () => connection.send('Browser.close').catch(debugError));
+  });}
+}
+
+/**
+ * @param {!Puppeteer.ChildProcess} chromeProcess
+ * @param {number} timeout
+ * @return {!Promise<string>}
+ */
+function waitForWSEndpoint(chromeProcess, timeout) {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({ input: chromeProcess.stderr });
+    let stderr = '';
+    const listeners = [
+      helper.addEventListener(rl, 'line', onLine),
+      helper.addEventListener(rl, 'close', () => onClose()),
+      helper.addEventListener(chromeProcess, 'exit', () => onClose()),
+      helper.addEventListener(chromeProcess, 'error', error => onClose(error))
+    ];
+    const timeoutId = timeout ? setTimeout(onTimeout, timeout) : 0;
+
+    /**
+     * @param {!Error=} error
+     */
+    function onClose(error) {
+      cleanup();
+      reject(new Error([
+        'Failed to launch chrome!' + (error ? ' ' + error.message : ''),
+        stderr,
+        '',
+        'TROUBLESHOOTING: https://github.com/GoogleChrome/puppeteer/blob/master/docs/troubleshooting.md',
+        '',
+      ].join('\n')));
+    }
+
+    function onTimeout() {
+      cleanup();
+      reject(new Error(`Timed out after ${timeout} ms while trying to connect to Chrome! The only Chrome revision guaranteed to work is r${ChromiumRevision}`));
+    }
+
+    /**
+     * @param {string} line
+     */
+    function onLine(line) {
+      stderr += line + '\n';
+      const match = line.match(/^DevTools listening on (ws:\/\/.*)$/);
+      if (!match)
+        return;
+      cleanup();
+      resolve(match[1]);
+    }
+
+    function cleanup() {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+      helper.removeEventListeners(listeners);
+    }
+  });
+}
+
+/**
+ * @typedef {Object} LaunchOptions
+ * @property {boolean=} ignoreHTTPSErrors
+ * @property {boolean=} headless
+ * @property {string=} executablePath
+ * @property {number=} slowMo
+ * @property {!Array<string>=} args
+ * @property {boolean=} ignoreDefaultArgs
+ * @property {boolean=} handleSIGINT
+ * @property {boolean=} handleSIGTERM
+ * @property {boolean=} handleSIGHUP
+ * @property {number=} timeout
+ * @property {boolean=} dumpio
+ * @property {string=} userDataDir
+ * @property {!Object<string, string | undefined>=} env
+ * @property {boolean=} devtools
+ * @property {boolean=} pipe
+ * @property {boolean=} appMode
+ */
+
+
+module.exports = Launcher;

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

@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+
+class Multimap {
+  constructor() {
+    this._map = new Map();
+  }
+
+  set(key, value) {
+    let set = this._map.get(key);
+    if (!set) {
+      set = new Set();
+      this._map.set(key, set);
+    }
+    set.add(value);
+  }
+
+  get(key) {
+    let result = this._map.get(key);
+    if (!result)
+      result = new Set();
+    return result;
+  }
+
+  has(key) {
+    return this._map.has(key);
+  }
+
+  hasValue(key, value) {
+    const set = this._map.get(key);
+    if (!set)
+      return false;
+    return set.has(value);
+  }
+
+  /**
+   * @return {number}
+   */
+  get size() {
+    return this._map.size;
+  }
+
+  delete(key, value) {
+    const values = this.get(key);
+    const result = values.delete(value);
+    if (!values.size)
+      this._map.delete(key);
+    return result;
+  }
+
+  deleteAll(key) {
+    this._map.delete(key);
+  }
+
+  firstValue(key) {
+    const set = this._map.get(key);
+    if (!set)
+      return null;
+    return set.values().next().value;
+  }
+
+  firstKey() {
+    return this._map.keys().next().value;
+  }
+
+  valuesArray() {
+    const result = [];
+    for (const key of this._map.keys())
+      result.push(...Array.from(this._map.get(key).values()));
+    return result;
+  }
+
+  keysArray() {
+    return Array.from(this._map.keys());
+  }
+
+  clear() {
+    this._map.clear();
+  }
+}
+
+module.exports = Multimap;

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

@@ -0,0 +1,163 @@
+/**
+ * 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 {FrameManager} = require('./FrameManager');
+
+class NavigatorWatcher {
+  /**
+   * @param {!FrameManager} frameManager
+   * @param {!Puppeteer.Frame} frame
+   * @param {number} timeout
+   * @param {!Object=} options
+   */
+  constructor(frameManager, frame, timeout, options = {}) {
+    console.assert(options.networkIdleTimeout === undefined, 'ERROR: networkIdleTimeout option is no longer supported.');
+    console.assert(options.networkIdleInflight === undefined, 'ERROR: networkIdleInflight option is no longer supported.');
+    console.assert(options.waitUntil !== 'networkidle', 'ERROR: "networkidle" option is no longer supported. Use "networkidle2" instead');
+    let waitUntil = ['load'];
+    if (Array.isArray(options.waitUntil))
+      waitUntil = options.waitUntil.slice();
+    else if (typeof options.waitUntil === 'string')
+      waitUntil = [options.waitUntil];
+    this._expectedLifecycle = waitUntil.map(value => {
+      const protocolEvent = puppeteerToProtocolLifecycle[value];
+      console.assert(protocolEvent, 'Unknown value for options.waitUntil: ' + value);
+      return protocolEvent;
+    });
+
+    this._frameManager = frameManager;
+    this._frame = frame;
+    this._initialLoaderId = frame._loaderId;
+    this._timeout = timeout;
+    this._hasSameDocumentNavigation = false;
+    this._eventListeners = [
+      helper.addEventListener(this._frameManager, FrameManager.Events.LifecycleEvent, this._checkLifecycleComplete.bind(this)),
+      helper.addEventListener(this._frameManager, FrameManager.Events.FrameNavigatedWithinDocument, this._navigatedWithinDocument.bind(this)),
+      helper.addEventListener(this._frameManager, FrameManager.Events.FrameDetached, this._checkLifecycleComplete.bind(this))
+    ];
+
+    const lifecycleCompletePromise = new Promise(fulfill => {
+      this._lifecycleCompleteCallback = fulfill;
+    });
+    this._navigationPromise = Promise.race([
+      this._createTimeoutPromise(),
+      lifecycleCompletePromise
+    ]).then(error => {
+      this._cleanup();
+      return error;
+    });
+  }
+
+  /**
+   * @return {!Promise<?Error>}
+   */
+  _createTimeoutPromise() {
+    if (!this._timeout)
+      return new Promise(() => {});
+    const errorMessage = 'Navigation Timeout Exceeded: ' + this._timeout + 'ms exceeded';
+    return new Promise(fulfill => this._maximumTimer = setTimeout(fulfill, this._timeout))
+        .then(() => new Error(errorMessage));
+  }
+
+  /**
+   * @return {!Promise<?Error>}
+   */
+  /* async */ navigationPromise() {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*(){
+    return this._navigationPromise;
+  });}
+
+  /**
+   * @param {!Puppeteer.Frame} frame
+   */
+  _navigatedWithinDocument(frame) {
+    if (frame !== this._frame)
+      return;
+    this._hasSameDocumentNavigation = true;
+    this._checkLifecycleComplete();
+  }
+
+  _checkLifecycleComplete() {
+    // We expect navigation to commit.
+    if (this._frame._loaderId === this._initialLoaderId && !this._hasSameDocumentNavigation)
+      return;
+    if (!checkLifecycle(this._frame, this._expectedLifecycle))
+      return;
+    this._lifecycleCompleteCallback();
+
+    /**
+     * @param {!Puppeteer.Frame} frame
+     * @param {!Array<string>} expectedLifecycle
+     * @return {boolean}
+     */
+    function checkLifecycle(frame, expectedLifecycle) {
+      for (const event of expectedLifecycle) {
+        if (!frame._lifecycleEvents.has(event))
+          return false;
+      }
+      for (const child of frame.childFrames()) {
+        if (!checkLifecycle(child, expectedLifecycle))
+          return false;
+      }
+      return true;
+    }
+  }
+
+  cancel() {
+    this._cleanup();
+  }
+
+  _cleanup() {
+    helper.removeEventListeners(this._eventListeners);
+    this._lifecycleCompleteCallback(new Error('Navigation failed'));
+    clearTimeout(this._maximumTimer);
+  }
+}
+
+const puppeteerToProtocolLifecycle = {
+  'load': 'load',
+  'domcontentloaded': 'DOMContentLoaded',
+  'networkidle0': 'networkIdle',
+  'networkidle2': 'networkAlmostIdle',
+};
+
+module.exports = NavigatorWatcher;