postdoc 0.1.2 → 0.2.0.beta4

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

@@ -0,0 +1,69 @@
+/**
+ * Copyright 2018 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 EventEmitter = require('events');
+
+class Pipe extends EventEmitter {
+  /**
+   * @param {!NodeJS.WritableStream} pipeWrite
+   * @param {!NodeJS.ReadableStream} pipeRead
+   */
+  constructor(pipeWrite, pipeRead) {
+    super();
+    this._pipeWrite = pipeWrite;
+    this._pendingMessage = '';
+    this._eventListeners = [
+      helper.addEventListener(pipeRead, 'data', buffer => this._dispatch(buffer))
+    ];
+  }
+
+  /**
+   * @param {string} message
+   */
+  send(message) {
+    this._pipeWrite.write(message);
+    this._pipeWrite.write('\n');
+  }
+
+  /**
+   * @param {!Buffer} buffer
+   */
+  _dispatch(buffer) {
+    let end = buffer.indexOf('\n');
+    if (end === -1) {
+      this._pendingMessage += buffer.toString();
+      return;
+    }
+    const message = this._pendingMessage + buffer.toString(undefined, 0, end);
+    this.emit('message', message);
+
+    let start = end + 1;
+    end = buffer.indexOf('\n', start);
+    while (end !== -1) {
+      this.emit('message', buffer.toString(undefined, start, end));
+      start = end + 1;
+      end = buffer.indexOf('\n', start);
+    }
+    this._pendingMessage = buffer.toString(undefined, start);
+  }
+
+  close() {
+    this._pipeWrite = null;
+    helper.removeEventListeners(this._eventListeners);
+  }
+}
+
+module.exports = Pipe;

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

@@ -0,0 +1,60 @@
+/**
+ * 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 Launcher = require('./Launcher');
+const BrowserFetcher = require('./BrowserFetcher');
+
+module.exports = class {
+  /**
+   * @param {!Object=} options
+   * @return {!Promise<!Puppeteer.Browser>}
+   */
+  static launch(options) {
+    return Launcher.launch(options);
+  }
+
+  /**
+   * @param {{browserWSEndpoint: string, ignoreHTTPSErrors: boolean}} options
+   * @return {!Promise<!Puppeteer.Browser>}
+   */
+  static connect(options) {
+    return Launcher.connect(options);
+  }
+
+  /**
+   * @return {string}
+   */
+  static executablePath() {
+    return Launcher.executablePath();
+  }
+
+  /**
+   * @return {!Array<string>}
+   */
+  static defaultArgs() {
+    return Launcher.defaultArgs();
+  }
+
+  /**
+   * @param {!Object=} options
+   * @return {!BrowserFetcher}
+   */
+  static createBrowserFetcher(options) {
+    return new BrowserFetcher(options);
+  }
+};
+
+helper.tracePublicAPI(module.exports, 'Puppeteer');

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

@@ -0,0 +1,114 @@
+const Page = require('./Page');
+const {helper} = require('./helper');
+
+class Target {
+  /**
+   * @param {!Puppeteer.TargetInfo} targetInfo
+   * @param {!Puppeteer.Browser} browser
+   * @param {!function():!Promise<!Puppeteer.CDPSession>} sessionFactory
+   * @param {boolean} ignoreHTTPSErrors
+   * @param {boolean} setDefaultViewport
+   * @param {!Puppeteer.TaskQueue} screenshotTaskQueue
+   */
+  constructor(targetInfo, browser, sessionFactory, ignoreHTTPSErrors, setDefaultViewport, screenshotTaskQueue) {
+    this._targetInfo = targetInfo;
+    this._browser = browser;
+    this._targetId = targetInfo.targetId;
+    this._sessionFactory = sessionFactory;
+    this._ignoreHTTPSErrors = ignoreHTTPSErrors;
+    this._setDefaultViewport = setDefaultViewport;
+    this._screenshotTaskQueue = screenshotTaskQueue;
+    /** @type {?Promise<!Puppeteer.Page>} */
+    this._pagePromise = null;
+    this._initializedPromise = new Promise(fulfill => this._initializedCallback = fulfill);
+    this._isClosedPromise = new Promise(fulfill => this._closedCallback = fulfill);
+    this._isInitialized = this._targetInfo.type !== 'page' || this._targetInfo.url !== '';
+    if (this._isInitialized)
+      this._initializedCallback(true);
+  }
+
+  /**
+   * @return {!Promise<!Puppeteer.CDPSession>}
+   */
+  createCDPSession() {
+    return this._sessionFactory();
+  }
+
+  /**
+   * @return {!Promise<?Page>}
+   */
+  /* async */ page() {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._targetInfo.type === 'page' && !this._pagePromise) {
+      this._pagePromise = this._sessionFactory()
+          .then(client => Page.create(client, this, this._ignoreHTTPSErrors, this._setDefaultViewport, this._screenshotTaskQueue));
+    }
+    return this._pagePromise;
+  });}
+
+  /**
+   * @return {string}
+   */
+  url() {
+    return this._targetInfo.url;
+  }
+
+  /**
+   * @return {"page"|"service_worker"|"other"|"browser"}
+   */
+  type() {
+    const type = this._targetInfo.type;
+    if (type === 'page' || type === 'service_worker' || type === 'browser')
+      return type;
+    return 'other';
+  }
+
+  /**
+   * @return {!Puppeteer.Browser}
+   */
+  browser() {
+    return this._browser;
+  }
+
+  /**
+   * @param {!Puppeteer.TargetInfo} targetInfo
+   */
+  _targetInfoChanged(targetInfo) {
+    this._targetInfo = targetInfo;
+
+    if (!this._isInitialized && (this._targetInfo.type !== 'page' || this._targetInfo.url !== '')) {
+      this._isInitialized = true;
+      this._initializedCallback(true);
+      return;
+    }
+  }
+}
+
+helper.tracePublicAPI(Target);
+
+module.exports = Target;

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

@@ -0,0 +1,17 @@
+class TaskQueue {
+  constructor() {
+    this._chain = Promise.resolve();
+  }
+
+  /**
+   * @param {function()} task
+   * @return {!Promise}
+   */
+  postTask(task) {
+    const result = this._chain.then(task);
+    this._chain = result.catch(() => {});
+    return result;
+  }
+}
+
+module.exports = TaskQueue;

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

@@ -0,0 +1,177 @@
+/**
+ * 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 fs = require('fs');
+
+const openAsync = helper.promisify(fs.open);
+const writeAsync = helper.promisify(fs.write);
+const closeAsync = helper.promisify(fs.close);
+
+class Tracing {
+  /**
+   * @param {!Puppeteer.CDPSession} client
+   */
+  constructor(client) {
+    this._client = client;
+    this._recording = false;
+    this._path = '';
+  }
+
+  /**
+   * @param {!Object} options
+   */
+  /* async */ start(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*(){
+    console.assert(!this._recording, 'Cannot start recording trace while already recording trace.');
+
+    const defaultCategories = [
+      '-*', 'devtools.timeline', 'v8.execute', 'disabled-by-default-devtools.timeline',
+      'disabled-by-default-devtools.timeline.frame', 'toplevel',
+      'blink.console', 'blink.user_timing', 'latencyInfo', 'disabled-by-default-devtools.timeline.stack',
+      'disabled-by-default-v8.cpu_profiler'
+    ];
+    const categoriesArray = options.categories || defaultCategories;
+
+    if (options.screenshots)
+      categoriesArray.push('disabled-by-default-devtools.screenshot');
+
+    this._path = options.path;
+    this._recording = true;
+    (yield this._client.send('Tracing.start', {
+      transferMode: 'ReturnAsStream',
+      categories: categoriesArray.join(',')
+    }));
+  });}
+
+  /* async */ stop() {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 fulfill;
+    const contentPromise = new Promise(x => fulfill = x);
+    this._client.once('Tracing.tracingComplete', event => {
+      this._readStream(event.stream, this._path).then(fulfill);
+    });
+    (yield this._client.send('Tracing.end'));
+    this._recording = false;
+    return contentPromise;
+  });}
+
+  /**
+   * @param {string} handle
+   * @param {string} path
+   */
+  /* async */ _readStream(handle, path) {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 eof = false;
+    let file;
+    if (path)
+      file = (yield openAsync(path, 'w'));
+    const bufs = [];
+    while (!eof) {
+      const response = (yield this._client.send('IO.read', {handle}));
+      eof = response.eof;
+      bufs.push(Buffer.from(response.data));
+      if (path)
+        (yield writeAsync(file, response.data));
+    }
+    if (path)
+      (yield closeAsync(file));
+    (yield this._client.send('IO.close', {handle}));
+    let resultBuffer = null;
+    try {
+      resultBuffer = Buffer.concat(bufs);
+    } finally {
+      return resultBuffer;
+    }
+  });}
+}
+helper.tracePublicAPI(Tracing);
+
+module.exports = Tracing;