postdoc 0.1.2 → 0.2.0.beta4

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

@@ -0,0 +1,357 @@
+/**
+ * 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

@@ -0,0 +1,350 @@
+/**
+ * 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};