postdoc 0.2.0.beta4 → 0.2.0

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

@@ -1,357 +0,0 @@
-/**
- * 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 fs = require('fs');
-const path = require('path');
-const extract = require('extract-zip');
-const util = require('util');
-const URL = require('url');
-const {helper} = require('./helper');
-const removeRecursive = require('rimraf');
-// @ts-ignore
-const ProxyAgent = require('https-proxy-agent');
-// @ts-ignore
-const getProxyForUrl = require('proxy-from-env').getProxyForUrl;
-
-const DEFAULT_DOWNLOAD_HOST = 'https://storage.googleapis.com';
-const downloadURLs = {
-  linux: '%s/chromium-browser-snapshots/Linux_x64/%d/chrome-linux.zip',
-  mac: '%s/chromium-browser-snapshots/Mac/%d/chrome-mac.zip',
-  win32: '%s/chromium-browser-snapshots/Win/%d/chrome-win32.zip',
-  win64: '%s/chromium-browser-snapshots/Win_x64/%d/chrome-win32.zip',
-};
-
-const readdirAsync = helper.promisify(fs.readdir.bind(fs));
-const mkdirAsync = helper.promisify(fs.mkdir.bind(fs));
-const unlinkAsync = helper.promisify(fs.unlink.bind(fs));
-const chmodAsync = helper.promisify(fs.chmod.bind(fs));
-
-function existsAsync(filePath) {
-  let fulfill = null;
-  const promise = new Promise(x => fulfill = x);
-  fs.access(filePath, err => fulfill(!err));
-  return promise;
-}
-
-class BrowserFetcher {
-  /**
-   * @param {!BrowserFetcher.Options=} options
-   */
-  constructor(options = {}) {
-    this._downloadsFolder = options.path || path.join(helper.projectRoot(), '.local-chromium');
-    this._downloadHost = options.host || DEFAULT_DOWNLOAD_HOST;
-    this._platform = options.platform || '';
-    if (!this._platform) {
-      const platform = os.platform();
-      if (platform === 'darwin')
-        this._platform = 'mac';
-      else if (platform === 'linux')
-        this._platform = 'linux';
-      else if (platform === 'win32')
-        this._platform = os.arch() === 'x64' ? 'win64' : 'win32';
-      console.assert(this._platform, 'Unsupported platform: ' + os.platform());
-    }
-    const supportedPlatforms = ['mac', 'linux', 'win32', 'win64'];
-    console.assert(supportedPlatforms.includes(this._platform), 'Unsupported platform: ' + this._platform);
-  }
-
-  /**
-   * @return {string}
-   */
-  platform() {
-    return this._platform;
-  }
-
-  /**
-   * @param {string} revision
-   * @return {!Promise<boolean>}
-   */
-  canDownload(revision) {
-    const url = util.format(downloadURLs[this._platform], this._downloadHost, revision);
-
-    let resolve;
-    const promise = new Promise(x => resolve = x);
-    const request = httpRequest(url, 'HEAD', response => {
-      resolve(response.statusCode === 200);
-    });
-    request.on('error', error => {
-      console.error(error);
-      resolve(false);
-    });
-    return promise;
-  }
-
-  /**
-   * @param {string} revision
-   * @param {?function(number, number)} progressCallback
-   * @return {!Promise<!BrowserFetcher.RevisionInfo>}
-   */
-  /* async */ download(revision, progressCallback) {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*(){
-    let url = downloadURLs[this._platform];
-    url = util.format(url, this._downloadHost, revision);
-    const zipPath = path.join(this._downloadsFolder, `download-${this._platform}-${revision}.zip`);
-    const folderPath = this._getFolderPath(revision);
-    if ((yield existsAsync(folderPath)))
-      return this.revisionInfo(revision);
-    if (!((yield existsAsync(this._downloadsFolder))))
-      (yield mkdirAsync(this._downloadsFolder));
-    try {
-      (yield downloadFile(url, zipPath, progressCallback));
-      (yield extractZip(zipPath, folderPath));
-    } finally {
-      if ((yield existsAsync(zipPath)))
-        (yield unlinkAsync(zipPath));
-    }
-    const revisionInfo = this.revisionInfo(revision);
-    if (revisionInfo)
-      (yield chmodAsync(revisionInfo.executablePath, 0o755));
-    return revisionInfo;
-  });}
-
-  /**
-   * @return {!Promise<!Array<string>>}
-   */
-  /* async */ localRevisions() {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*(){
-    if (!(yield existsAsync(this._downloadsFolder)))
-      return [];
-    const fileNames = (yield readdirAsync(this._downloadsFolder));
-    return fileNames.map(fileName => parseFolderPath(fileName)).filter(entry => entry && entry.platform === this._platform).map(entry => entry.revision);
-  });}
-
-  /**
-   * @param {string} revision
-   * @return {!Promise}
-   */
-  /* async */ remove(revision) {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 folderPath = this._getFolderPath(revision);
-    console.assert((yield existsAsync(folderPath)), `Failed to remove: revision ${revision} is not downloaded`);
-    (yield new Promise(fulfill => removeRecursive(folderPath, fulfill)));
-  });}
-
-  /**
-   * @param {string} revision
-   * @return {!BrowserFetcher.RevisionInfo}
-   */
-  revisionInfo(revision) {
-    const folderPath = this._getFolderPath(revision);
-    let executablePath = '';
-    if (this._platform === 'mac')
-      executablePath = path.join(folderPath, 'chrome-mac', 'Chromium.app', 'Contents', 'MacOS', 'Chromium');
-    else if (this._platform === 'linux')
-      executablePath = path.join(folderPath, 'chrome-linux', 'chrome');
-    else if (this._platform === 'win32' || this._platform === 'win64')
-      executablePath = path.join(folderPath, 'chrome-win32', 'chrome.exe');
-    else
-      throw 'Unsupported platform: ' + this._platform;
-    let url = downloadURLs[this._platform];
-    url = util.format(url, this._downloadHost, revision);
-    const local = fs.existsSync(folderPath);
-    return {revision, executablePath, folderPath, local, url};
-  }
-
-  /**
-   * @param {string} revision
-   * @return {string}
-   */
-  _getFolderPath(revision) {
-    return path.join(this._downloadsFolder, this._platform + '-' + revision);
-  }
-}
-
-module.exports = BrowserFetcher;
-
-/**
- * @param {string} folderPath
- * @return {?{platform: string, revision: string}}
- */
-function parseFolderPath(folderPath) {
-  const name = path.basename(folderPath);
-  const splits = name.split('-');
-  if (splits.length !== 2)
-    return null;
-  const [platform, revision] = splits;
-  if (!downloadURLs[platform])
-    return null;
-  return {platform, revision};
-}
-
-/**
- * @param {string} url
- * @param {string} destinationPath
- * @param {?function(number, number)} progressCallback
- * @return {!Promise}
- */
-function downloadFile(url, destinationPath, progressCallback) {
-  let fulfill, reject;
-  let downloadedBytes = 0;
-  let totalBytes = 0;
-
-  const promise = new Promise((x, y) => { fulfill = x; reject = y; });
-
-  const request = httpRequest(url, 'GET', response => {
-    if (response.statusCode !== 200) {
-      const error = new Error(`Download failed: server returned code ${response.statusCode}. URL: ${url}`);
-      // consume response data to free up memory
-      response.resume();
-      reject(error);
-      return;
-    }
-    const file = fs.createWriteStream(destinationPath);
-    file.on('finish', () => fulfill());
-    file.on('error', error => reject(error));
-    response.pipe(file);
-    totalBytes = parseInt(/** @type {string} */ (response.headers['content-length']), 10);
-    if (progressCallback)
-      response.on('data', onData);
-  });
-  request.on('error', error => reject(error));
-  return promise;
-
-  function onData(chunk) {
-    downloadedBytes += chunk.length;
-    progressCallback(downloadedBytes, totalBytes);
-  }
-}
-
-/**
- * @param {string} zipPath
- * @param {string} folderPath
- * @return {!Promise<?Error>}
- */
-function extractZip(zipPath, folderPath) {
-  return new Promise(fulfill => extract(zipPath, {dir: folderPath}, fulfill));
-}
-
-function httpRequest(url, method, response) {
-  /** @type {Object} */
-  const options = URL.parse(url);
-  options.method = method;
-
-  const proxyURL = getProxyForUrl(url);
-  if (proxyURL) {
-    /** @type {Object} */
-    const parsedProxyURL = URL.parse(proxyURL);
-    parsedProxyURL.secureProxy = parsedProxyURL.protocol === 'https:';
-
-    options.agent = new ProxyAgent(parsedProxyURL);
-    options.rejectUnauthorized = false;
-  }
-
-  const driver = options.protocol === 'https:' ? 'https' : 'http';
-  const request = require(driver).request(options, res => {
-    if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location)
-      httpRequest(res.headers.location, method, response);
-    else
-      response(res);
-  });
-  request.end();
-  return request;
-}
-
-/**
- * @typedef {Object} BrowserFetcher.Options
- * @property {string=} platform
- * @property {string=} path
- * @property {string=} host
- */
-
-/**
- * @typedef {Object} BrowserFetcher.RevisionInfo
- * @property {string} folderPath
- * @property {string} executablePath
- * @property {string} url
- * @property {boolean} local
- * @property {string} revision
- */

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

@@ -1,350 +0,0 @@
-/**
- * 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 debugProtocol = require('debug')('puppeteer:protocol');
-const debugSession = require('debug')('puppeteer:session');
-
-const EventEmitter = require('events');
-const WebSocket = require('ws');
-const Pipe = require('./Pipe');
-
-class Connection extends EventEmitter {
-  /**
-   * @param {string} url
-   * @param {number=} delay
-   * @return {!Promise<!Connection>}
-   */
-  static /* async */ createForWebSocket(url, delay = 0) {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 new Promise((resolve, reject) => {
-      const ws = new WebSocket(url, { perMessageDeflate: false });
-      ws.on('open', () => resolve(new Connection(url, ws, delay)));
-      ws.on('error', reject);
-    });
-  });}
-
-  /**
-   * @param {!NodeJS.WritableStream} pipeWrite
-   * @param {!NodeJS.ReadableStream} pipeRead
-   * @param {number=} delay
-   * @return {!Connection}
-   */
-  static createForPipe(pipeWrite, pipeRead, delay = 0) {
-    return new Connection('', new Pipe(pipeWrite, pipeRead), delay);
-  }
-
-  /**
-   * @param {string} url
-   * @param {!Puppeteer.ConnectionTransport} transport
-   * @param {number=} delay
-   */
-  constructor(url, transport, delay = 0) {
-    super();
-    this._url = url;
-    this._lastId = 0;
-    /** @type {!Map<number, {resolve: function, reject: function, error: !Error, method: string}>}*/
-    this._callbacks = new Map();
-    this._delay = delay;
-
-    this._transport = transport;
-    this._transport.on('message', this._onMessage.bind(this));
-    this._transport.on('close', this._onClose.bind(this));
-    /** @type {!Map<string, !CDPSession>}*/
-    this._sessions = new Map();
-  }
-
-  /**
-   * @return {string}
-   */
-  url() {
-    return this._url;
-  }
-
-  /**
-   * @param {string} method
-   * @param {!Object=} params
-   * @return {!Promise<?Object>}
-   */
-  send(method, params = {}) {
-    const id = ++this._lastId;
-    const message = JSON.stringify({id, method, params});
-    debugProtocol('SEND ► ' + message);
-    this._transport.send(message);
-    return new Promise((resolve, reject) => {
-      this._callbacks.set(id, {resolve, reject, error: new Error(), method});
-    });
-  }
-
-  /**
-   * @param {function()} callback
-   */
-  setClosedCallback(callback) {
-    this._closeCallback = callback;
-  }
-
-  /**
-   * @param {string} message
-   */
-  /* async */ _onMessage(message) {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*(){
-    if (this._delay)
-      (yield new Promise(f => setTimeout(f, this._delay)));
-    debugProtocol('◀ RECV ' + message);
-    const object = JSON.parse(message);
-    if (object.id) {
-      const callback = this._callbacks.get(object.id);
-      // Callbacks could be all rejected if someone has called `.dispose()`.
-      if (callback) {
-        this._callbacks.delete(object.id);
-        if (object.error)
-          callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): ${object.error.message} ${object.error.data}`));
-        else
-          callback.resolve(object.result);
-      }
-    } else {
-      if (object.method === 'Target.receivedMessageFromTarget') {
-        const session = this._sessions.get(object.params.sessionId);
-        if (session)
-          session._onMessage(object.params.message);
-      } else if (object.method === 'Target.detachedFromTarget') {
-        const session = this._sessions.get(object.params.sessionId);
-        if (session)
-          session._onClosed();
-        this._sessions.delete(object.params.sessionId);
-      } else {
-        this.emit(object.method, object.params);
-      }
-    }
-  });}
-
-  _onClose() {
-    if (this._closeCallback) {
-      this._closeCallback();
-      this._closeCallback = null;
-    }
-    this._transport.removeAllListeners();
-    // If transport throws any error at this point of time, we don't care and should swallow it.
-    this._transport.on('error', () => {});
-    for (const callback of this._callbacks.values())
-      callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): Target closed.`));
-    this._callbacks.clear();
-    for (const session of this._sessions.values())
-      session._onClosed();
-    this._sessions.clear();
-  }
-
-  dispose() {
-    this._onClose();
-    this._transport.close();
-  }
-
-  /**
-   * @param {string} targetId
-   * @return {!Promise<!CDPSession>}
-   */
-  /* async */ createSession(targetId) {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 {sessionId} = (yield this.send('Target.attachToTarget', {targetId}));
-    const session = new CDPSession(this, targetId, sessionId);
-    this._sessions.set(sessionId, session);
-    return session;
-  });}
-}
-
-class CDPSession extends EventEmitter {
-  /**
-   * @param {!Connection} connection
-   * @param {string} targetId
-   * @param {string} sessionId
-   */
-  constructor(connection, targetId, sessionId) {
-    super();
-    this._lastId = 0;
-    /** @type {!Map<number, {resolve: function, reject: function, error: !Error, method: string}>}*/
-    this._callbacks = new Map();
-    this._connection = connection;
-    this._targetId = targetId;
-    this._sessionId = sessionId;
-  }
-
-  /**
-   * @param {string} method
-   * @param {!Object=} params
-   * @return {!Promise<?Object>}
-   */
-  send(method, params = {}) {
-    if (!this._connection)
-      return Promise.reject(new Error(`Protocol error (${method}): Session closed. Most likely the page has been closed.`));
-    const id = ++this._lastId;
-    const message = JSON.stringify({id, method, params});
-    debugSession('SEND ► ' + message);
-    this._connection.send('Target.sendMessageToTarget', {sessionId: this._sessionId, message}).catch(e => {
-      // The response from target might have been already dispatched.
-      if (!this._callbacks.has(id))
-        return;
-      const callback = this._callbacks.get(id);
-      this._callbacks.delete(id);
-      callback.reject(rewriteError(callback.error, e && e.message));
-    });
-    return new Promise((resolve, reject) => {
-      this._callbacks.set(id, {resolve, reject, error: new Error(), method});
-    });
-  }
-
-  /**
-   * @param {string} message
-   */
-  _onMessage(message) {
-    debugSession('◀ RECV ' + message);
-    const object = JSON.parse(message);
-    if (object.id && this._callbacks.has(object.id)) {
-      const callback = this._callbacks.get(object.id);
-      this._callbacks.delete(object.id);
-      if (object.error)
-        callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): ${object.error.message} ${object.error.data}`));
-      else
-        callback.resolve(object.result);
-    } else {
-      console.assert(!object.id);
-      this.emit(object.method, object.params);
-    }
-  }
-
-  /* async */ detach() {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._connection.send('Target.detachFromTarget',  {sessionId: this._sessionId}));
-  });}
-
-  _onClosed() {
-    for (const callback of this._callbacks.values())
-      callback.reject(rewriteError(callback.error, `Protocol error (${callback.method}): Target closed.`));
-    this._callbacks.clear();
-    this._connection = null;
-  }
-}
-helper.tracePublicAPI(CDPSession);
-
-/**
- * @param {!Error} error
- * @param {string} message
- * @return {!Error}
- */
-function rewriteError(error, message) {
-  error.message = message;
-  return error;
-}
-
-module.exports = {Connection, CDPSession};