@aws/lsp-codewhisperer 0.0.5 → 0.0.9

package/node_modules/@aws/lsp-fqn/node_modules/workerpool/src/requireFoolWebpack.js

@@ -0,0 +1,8 @@
+// source of inspiration: https://github.com/sindresorhus/require-fool-webpack
+var requireFoolWebpack = eval(
+    'typeof require !== \'undefined\' ' +
+    '? require ' +
+    ': function (module) { throw new Error(\'Module " + module + " not found.\') }'
+);
+
+module.exports = requireFoolWebpack;

package/node_modules/@aws/lsp-fqn/node_modules/workerpool/src/transfer.js

@@ -0,0 +1,12 @@
+/**
+ * The helper class for transferring data from the worker to the main thread.
+ *
+ * @param {Object} message The object to deliver to the main thread.
+ * @param {Object[]} transfer An array of transferable Objects to transfer ownership of.
+ */
+function Transfer(message, transfer) {
+  this.message = message;
+  this.transfer = transfer;
+}
+
+module.exports = Transfer;

package/node_modules/@aws/lsp-fqn/node_modules/workerpool/src/types.js

@@ -0,0 +1,46 @@
+/**
+ * @typedef {Object} WorkerArg
+ * @property {string[]} [forkArgs] The `forkArgs` option of this pool
+ * @property {import('child_process').ForkOptions} [forkOpts] The `forkOpts` option of this pool
+ * @property {WorkerOptions} [workerOpts] The `workerOpts` option of this pool
+ * @property {import('worker_threads').WorkerOptions} [workerThreadOpts] The `workerThreadOpts` option of this pool
+ * @property {string} [script] The `script` option of this pool
+ */
+
+/**
+ * @typedef {Object} WorkerPoolOptions
+ * @property {number | 'max'} [minWorkers] The minimum number of workers that must be initialized and kept available. Setting this to `'max'` will create `maxWorkers` default workers
+ * @property {number} [maxWorkers]  The default number of maxWorkers is the number of CPU's minus one. When the number of CPU's could not be determined (for example in older browsers), `maxWorkers` is set to 3.
+ * @property {number} [maxQueueSize] The maximum number of tasks allowed to be queued. Can be used to prevent running out of memory. If the maximum is exceeded, adding a new task will throw an error. The default value is `Infinity`.
+ * @property {'auto' | 'web' | 'process' | 'thread'} [workerType]
+ *   - In case of `'auto'` (default), workerpool will automatically pick a suitable type of worker: when in a browser environment, `'web'` will be used. When in a node.js environment, `worker_threads` will be used if available (Node.js >= 11.7.0), else `child_process` will be used.
+ *   - In case of `'web'`, a Web Worker will be used. Only available in a browser environment.
+ *   - In case of `'process'`, `child_process` will be used. Only available in a node.js environment.
+ *   - In case of `'thread'`, `worker_threads` will be used. If `worker_threads` are not available, an error is thrown. Only available in a node.js environment.
+ * @property {number} [workerTerminateTimeout] The timeout in milliseconds to wait for a worker to clean up it's resources on termination before stopping it forcefully. Default value is `1000`.
+ * @property {string[]} [forkArgs] For `process` worker type. An array passed as `args` to [child_process.fork](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options)
+ * @property {import('child_process').ForkOptions} [forkOpts] For `process` worker type. An object passed as `options` to [child_process.fork](https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options).
+ * @property {WorkerOptions} [workerOpts] For `web` worker type. An object passed to the [constructor of the web worker](https://html.spec.whatwg.org/multipage/workers.html#dom-worker). See [WorkerOptions specification](https://html.spec.whatwg.org/multipage/workers.html#workeroptions) for available options.
+ * @property {import('worker_threads').WorkerOptions} [workerThreadOpts] Object`. For `worker` worker type. An object passed to [worker_threads.options](https://nodejs.org/api/worker_threads.html#new-workerfilename-options).
+ * @property {boolean} [emitStdStreams] Capture stdout and stderr from the worker and emit them via the `stdout` and `stderr` events. Not supported by the `web` worker type.
+ * @property { (arg: WorkerArg) => WorkerArg | undefined } [onCreateWorker] A callback that is called whenever a worker is being created. It can be used to allocate resources for each worker for example. Optionally, this callback can return an object containing one or more of the `WorkerArg` properties. The provided properties will be used to override the Pool properties for the worker being created.
+ * @property { (arg: WorkerArg) => void } [onTerminateWorker] A callback that is called whenever a worker is being terminated. It can be used to release resources that might have been allocated for this specific worker. The callback is passed as argument an object as described for `onCreateWorker`, with each property sets with the value for the worker being terminated.
+ */
+
+/**
+ * @typedef {Object} ExecOptions
+ * @property {(payload: any) => unknown} [on] An event listener, to handle events sent by the worker for this execution.
+ * @property {Object[]} [transfer] A list of transferable objects to send to the worker. Not supported by `process` worker type. See ./examples/transferableObjects.js for usage.
+ */
+
+/**
+ * @typedef {Object} WorkerRegisterOptions
+ * @property {(code: number | undefined) => PromiseLike<void> | void} [onTerminate] A callback that is called whenever a worker is being terminated. It can be used to release resources that might have been allocated for this specific worker. The difference with pool's `onTerminateWorker` is that this callback runs in the worker context, while onTerminateWorker is executed on the main thread.
+ */
+
+/**
+ * @template { { [k: string]: (...args: any[]) => any } } T
+ * @typedef {{ [M in keyof T]: (...args: Parameters<T[M]>) => import('./Promise.js').Promise<ReturnType<T[M]>>; }} Proxy<T>
+ */
+
+module.exports = {}

package/node_modules/@aws/lsp-fqn/node_modules/workerpool/src/validateOptions.js

@@ -0,0 +1,51 @@
+/**
+ * Validate that the object only contains known option names
+ * - Throws an error when unknown options are detected
+ * - Throws an error when some of the allowed options are attached
+ * @param {Object | undefined} options
+ * @param {string[]} allowedOptionNames
+ * @param {string} objectName
+ * @retrun {Object} Returns the original options
+ */
+exports.validateOptions = function validateOptions(options, allowedOptionNames, objectName) {
+  if (!options) {
+    return
+  }
+
+  var optionNames = options ?  Object.keys(options) : []
+
+  // check for unknown properties
+  var unknownOptionName = optionNames.find(optionName => !allowedOptionNames.includes(optionName))
+  if (unknownOptionName) {
+    throw new Error('Object "' + objectName + '" contains an unknown option "' + unknownOptionName + '"')
+  }
+
+  // check for inherited properties which are not present on the object itself
+  var illegalOptionName = allowedOptionNames.find(allowedOptionName => {
+    return Object.prototype[allowedOptionName] && !optionNames.includes(allowedOptionName)
+  })
+  if (illegalOptionName) {
+    throw new Error('Object "' + objectName + '" contains an inherited option "' + illegalOptionName + '" which is ' +
+      'not defined in the object itself but in its prototype. Only plain objects are allowed. ' +
+      'Please remove the option from the prototype or override it with a value "undefined".')
+  }
+
+  return options
+}
+
+// source: https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker
+exports.workerOptsNames = [
+  'credentials', 'name', 'type' ]
+
+// source: https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options
+exports.forkOptsNames = [
+  'cwd', 'detached', 'env', 'execPath', 'execArgv', 'gid', 'serialization',
+  'signal', 'killSignal', 'silent', 'stdio', 'uid', 'windowsVerbatimArguments',
+  'timeout'
+]
+
+// source: https://nodejs.org/api/worker_threads.html#new-workerfilename-options
+exports.workerThreadOptsNames = [
+  'argv', 'env', 'eval', 'execArgv', 'stdin', 'stdout', 'stderr', 'workerData',
+  'trackUnmanagedFds', 'transferList', 'resourceLimits', 'name'
+]

package/node_modules/@aws/lsp-fqn/node_modules/workerpool/src/worker.js

@@ -0,0 +1,256 @@
+/**
+ * worker must be started as a child process or a web worker.
+ * It listens for RPC messages from the parent process.
+ */
+var Transfer = require('./transfer');
+
+/**
+ * Special message sent by parent which causes the worker to terminate itself.
+ * Not a "message object"; this string is the entire message.
+ */
+var TERMINATE_METHOD_ID = '__workerpool-terminate__';
+
+// var nodeOSPlatform = require('./environment').nodeOSPlatform;
+
+// create a worker API for sending and receiving messages which works both on
+// node.js and in the browser
+var worker = {
+  exit: function() {}
+};
+if (typeof self !== 'undefined' && typeof postMessage === 'function' && typeof addEventListener === 'function') {
+  // worker in the browser
+  worker.on = function (event, callback) {
+    addEventListener(event, function (message) {
+      callback(message.data);
+    })
+  };
+  worker.send = function (message) {
+    postMessage(message);
+  };
+}
+else if (typeof process !== 'undefined') {
+  // node.js
+
+  var WorkerThreads;
+  try {
+    WorkerThreads = require('worker_threads');
+  } catch(error) {
+    if (typeof error === 'object' && error !== null && error.code === 'MODULE_NOT_FOUND') {
+      // no worker_threads, fallback to sub-process based workers
+    } else {
+      throw error;
+    }
+  }
+
+  if (WorkerThreads &&
+    /* if there is a parentPort, we are in a WorkerThread */
+    WorkerThreads.parentPort !== null) {
+    var parentPort  = WorkerThreads.parentPort;
+    worker.send = parentPort.postMessage.bind(parentPort);
+    worker.on = parentPort.on.bind(parentPort);
+    worker.exit = process.exit.bind(process);
+  } else {
+    worker.on = process.on.bind(process);
+    // ignore transfer argument since it is not supported by process
+    worker.send = function (message) {
+      process.send(message);
+    };
+    // register disconnect handler only for subprocess worker to exit when parent is killed unexpectedly
+    worker.on('disconnect', function () {
+      process.exit(1);
+    });
+    worker.exit = process.exit.bind(process);
+  }
+}
+else {
+  throw new Error('Script must be executed as a worker');
+}
+
+function convertError(error) {
+  return Object.getOwnPropertyNames(error).reduce(function(product, name) {
+    return Object.defineProperty(product, name, {
+	value: error[name],
+	enumerable: true
+    });
+  }, {});
+}
+
+/**
+ * Test whether a value is a Promise via duck typing.
+ * @param {*} value
+ * @returns {boolean} Returns true when given value is an object
+ *                    having functions `then` and `catch`.
+ */
+function isPromise(value) {
+  return value && (typeof value.then === 'function') && (typeof value.catch === 'function');
+}
+
+// functions available externally
+worker.methods = {};
+
+/**
+ * Execute a function with provided arguments
+ * @param {String} fn     Stringified function
+ * @param {Array} [args]  Function arguments
+ * @returns {*}
+ */
+worker.methods.run = function run(fn, args) {
+  var f = new Function('return (' + fn + ').apply(null, arguments);');
+  return f.apply(f, args);
+};
+
+/**
+ * Get a list with methods available on this worker
+ * @return {String[]} methods
+ */
+worker.methods.methods = function methods() {
+  return Object.keys(worker.methods);
+};
+
+/**
+ * Custom handler for when the worker is terminated.
+ */
+worker.terminationHandler = undefined;
+
+/**
+ * Cleanup and exit the worker.
+ * @param {Number} code 
+ * @returns 
+ */
+worker.cleanupAndExit = function(code) {
+  var _exit = function() {
+    worker.exit(code);
+  }
+
+  if(!worker.terminationHandler) {
+    return _exit();
+  }
+
+  var result = worker.terminationHandler(code);
+  if (isPromise(result)) {
+    result.then(_exit, _exit);
+  } else {
+    _exit();
+  }
+}
+
+var currentRequestId = null;
+
+worker.on('message', function (request) {
+  if (request === TERMINATE_METHOD_ID) {
+    return worker.cleanupAndExit(0);
+  }
+  try {
+    var method = worker.methods[request.method];
+
+    if (method) {
+      currentRequestId = request.id;
+      
+      // execute the function
+      var result = method.apply(method, request.params);
+
+      if (isPromise(result)) {
+        // promise returned, resolve this and then return
+        result
+            .then(function (result) {
+              if (result instanceof Transfer) {
+                worker.send({
+                  id: request.id,
+                  result: result.message,
+                  error: null
+                }, result.transfer);
+              } else {
+                worker.send({
+                  id: request.id,
+                  result: result,
+                  error: null
+                });
+              }
+              currentRequestId = null;
+            })
+            .catch(function (err) {
+              worker.send({
+                id: request.id,
+                result: null,
+                error: convertError(err)
+              });
+              currentRequestId = null;
+            });
+      }
+      else {
+        // immediate result
+        if (result instanceof Transfer) {
+          worker.send({
+            id: request.id,
+            result: result.message,
+            error: null
+          }, result.transfer);
+        } else {
+          worker.send({
+            id: request.id,
+            result: result,
+            error: null
+          });
+        }
+
+        currentRequestId = null;
+      }
+    }
+    else {
+      throw new Error('Unknown method "' + request.method + '"');
+    }
+  }
+  catch (err) {
+    worker.send({
+      id: request.id,
+      result: null,
+      error: convertError(err)
+    });
+  }
+});
+
+/**
+ * Register methods to the worker
+ * @param {Object} [methods]
+ * @param {import('./types.js').WorkerRegisterOptions} [options]
+ */
+worker.register = function (methods, options) {
+
+  if (methods) {
+    for (var name in methods) {
+      if (methods.hasOwnProperty(name)) {
+        worker.methods[name] = methods[name];
+      }
+    }
+  }
+
+  if (options) {
+    worker.terminationHandler = options.onTerminate;
+  }
+
+  worker.send('ready');
+};
+
+worker.emit = function (payload) {
+  if (currentRequestId) {
+    if (payload instanceof Transfer) {
+      worker.send({
+        id: currentRequestId,
+        isEvent: true,
+        payload: payload.message
+      }, payload.transfer);
+      return;
+    }
+
+    worker.send({
+      id: currentRequestId,
+      isEvent: true,
+      payload
+    });
+  }
+};
+
+if (typeof exports !== 'undefined') {
+  exports.add = worker.register;
+  exports.emit = worker.emit;
+}

package/node_modules/@aws/lsp-fqn/node_modules/workerpool/types/Pool.d.ts

@@ -0,0 +1,130 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export = Pool;
+/**
+ * A pool to manage workers, which can be created using the function workerpool.pool.
+ *
+ * @param {String} [script]   Optional worker script
+ * @param {import('./types.js').WorkerPoolOptions} [options]  See docs
+ * @constructor
+ */
+declare function Pool(script?: string | undefined, options?: import("./types.js").WorkerPoolOptions | undefined): void;
+declare class Pool {
+    /**
+     * A pool to manage workers, which can be created using the function workerpool.pool.
+     *
+     * @param {String} [script]   Optional worker script
+     * @param {import('./types.js').WorkerPoolOptions} [options]  See docs
+     * @constructor
+     */
+    constructor(script?: string | undefined, options?: import("./types.js").WorkerPoolOptions | undefined);
+    /** @readonly */
+    readonly script: string | null;
+    /** @private */
+    private workers;
+    /** @private */
+    private tasks;
+    /** @readonly */
+    readonly forkArgs: readonly string[];
+    /** @readonly */
+    readonly forkOpts: Readonly<import("child_process").ForkOptions>;
+    /** @readonly */
+    readonly workerOpts: Readonly<WorkerOptions>;
+    /** @readonly */
+    readonly workerThreadOpts: Readonly<import("worker_threads").WorkerOptions>;
+    /** @private */
+    private debugPortStart;
+    /** @readonly @deprecated */
+    readonly nodeWorker: any;
+    /** @readonly
+     * @type {'auto' | 'web' | 'process' | 'thread'}
+     */
+    readonly workerType: 'auto' | 'web' | 'process' | 'thread';
+    /** @readonly */
+    readonly maxQueueSize: number;
+    /** @readonly */
+    readonly workerTerminateTimeout: number;
+    /** @readonly */
+    readonly onCreateWorker: ((arg: import("./types.js").WorkerArg) => import("./types.js").WorkerArg | undefined) | (() => null);
+    /** @readonly */
+    readonly onTerminateWorker: (arg: import("./types.js").WorkerArg) => void;
+    /** @readonly */
+    readonly emitStdStreams: boolean;
+    /** @readonly */
+    readonly maxWorkers: number | undefined;
+    /** @readonly */
+    readonly minWorkers: number | undefined;
+    /** @private */
+    private _boundNext;
+    /**
+     * Execute a function on a worker.
+     *
+     * Example usage:
+     *
+     *   var pool = new Pool()
+     *
+     *   // call a function available on the worker
+     *   pool.exec('fibonacci', [6])
+     *
+     *   // offload a function
+     *   function add(a, b) {
+     *     return a + b
+     *   };
+     *   pool.exec(add, [2, 4])
+     *       .then(function (result) {
+     *         console.log(result); // outputs 6
+     *       })
+     *       .catch(function(error) {
+     *         console.log(error);
+     *       });
+     * @template { (...args: any[]) => any } T
+     * @param {String | T} method  Function name or function.
+     *                                    If `method` is a string, the corresponding
+     *                                    method on the worker will be executed
+     *                                    If `method` is a Function, the function
+     *                                    will be stringified and executed via the
+     *                                    workers built-in function `run(fn, args)`.
+     * @param {Parameters<T> | null} [params]  Function arguments applied when calling the function
+     * @param {import('./types.js').ExecOptions} [options]  Options
+     * @return {Promise<ReturnType<T>>}
+     */
+    exec<T extends (...args: any[]) => any>(method: string | T, params?: Parameters<T> | null | undefined, options?: import("./types.js").ExecOptions | undefined): Promise<ReturnType<T>, Error>;
+    /**
+     * Create a proxy for current worker. Returns an object containing all
+     * methods available on the worker. All methods return promises resolving the methods result.
+     * @template { { [k: string]: (...args: any[]) => any } } T
+     * @return {Promise<import('./types.js').Proxy<T>, Error>} Returns a promise which resolves with a proxy object
+     */
+    proxy<T_1 extends {
+        [k: string]: (...args: any[]) => any;
+    }>(...args: any[]): Promise<import("./types.js").Proxy<T_1>, Error>;
+    private _next;
+    private _getWorker;
+    private _removeWorker;
+    private _removeWorkerFromList;
+    /**
+     * Close all active workers. Tasks currently being executed will be finished first.
+     * @param {boolean} [force=false]   If false (default), the workers are terminated
+     *                                  after finishing all tasks currently in
+     *                                  progress. If true, the workers will be
+     *                                  terminated immediately.
+     * @param {number} [timeout]        If provided and non-zero, worker termination promise will be rejected
+     *                                  after timeout if worker process has not been terminated.
+     * @return {Promise.<void, Error>}
+     */
+    terminate(force?: boolean | undefined, timeout?: number | undefined): Promise<void, Error>;
+    /**
+     * Retrieve statistics on tasks and workers.
+     * @return {{totalWorkers: number, busyWorkers: number, idleWorkers: number, pendingTasks: number, activeTasks: number}} Returns an object with statistics
+     */
+    stats(): {
+        totalWorkers: number;
+        busyWorkers: number;
+        idleWorkers: number;
+        pendingTasks: number;
+        activeTasks: number;
+    };
+    private _ensureMinWorkers;
+    private _createWorkerHandler;
+}
+import { Promise } from "./Promise";

package/node_modules/@aws/lsp-fqn/node_modules/workerpool/types/Promise.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Promise
+ *
+ * Inspired by https://gist.github.com/RubaXa/8501359 from RubaXa <trash@rubaxa.org>
+ * @template T
+ * @template [E=Error]
+ * @param {Function} handler   Called as handler(resolve: Function, reject: Function)
+ * @param {Promise} [parent]   Parent promise for propagation of cancel and timeout
+ */
+export function Promise<T, E = Error>(handler: Function, parent?: Promise<any, Error> | undefined): void;
+export class Promise<T, E = Error> {
+    /**
+     * Promise
+     *
+     * Inspired by https://gist.github.com/RubaXa/8501359 from RubaXa <trash@rubaxa.org>
+     * @template T
+     * @template [E=Error]
+     * @param {Function} handler   Called as handler(resolve: Function, reject: Function)
+     * @param {Promise} [parent]   Parent promise for propagation of cancel and timeout
+     */
+    constructor(handler: Function, parent?: Promise<any, Error> | undefined);
+    /**
+     * @readonly
+     */
+    readonly resolved: boolean;
+    /**
+     * @readonly
+     */
+    readonly rejected: boolean;
+    /**
+     * @readonly
+     */
+    readonly pending: boolean;
+    /**
+     * Add an onSuccess callback and optionally an onFail callback to the Promise
+     * @template TT
+     * @template [TE=never]
+     * @param {(r: T) => TT | PromiseLike<TT>} onSuccess
+     * @param {(r: E) => TE | PromiseLike<TE>} [onFail]
+     * @returns {Promise<TT | TE, any>} promise
+     */
+    then: <TT, TE = never>(onSuccess: (r: T) => TT | PromiseLike<TT>, onFail?: ((r: E) => TE | PromiseLike<TE>) | undefined) => Promise<TT | TE, any>;
+    /**
+     * Cancel the promise. This will reject the promise with a CancellationError
+     * @returns {this} self
+     */
+    cancel: () => this;
+    /**
+     * Set a timeout for the promise. If the promise is not resolved within
+     * the time, the promise will be cancelled and a TimeoutError is thrown.
+     * If the promise is resolved in time, the timeout is removed.
+     * @param {number} delay     Delay in milliseconds
+     * @returns {this} self
+     */
+    timeout: (delay: number) => this;
+    /**
+     * Add an onFail callback to the Promise
+     * @template TT
+     * @param {(error: E) => TT | PromiseLike<TT>} onFail
+     * @returns {Promise<T | TT>} promise
+     */
+    catch<TT_1>(onFail: (error: E) => TT_1 | PromiseLike<TT_1>): Promise<T | TT_1, Error>;
+    /**
+     * Execute given callback when the promise either resolves or rejects.
+     * @template TT
+     * @param {() => Promise<TT>} fn
+     * @returns {Promise<TT>} promise
+     */
+    always<TT_2>(fn: () => Promise<TT_2, Error>): Promise<TT_2, Error>;
+}
+export namespace Promise {
+    /**
+     * Create a promise which resolves when all provided promises are resolved,
+     * and fails when any of the promises resolves.
+     * @param {Promise[]} promises
+     * @returns {Promise<any[], any>} promise
+     */
+    export function all(promises: Promise<any, Error>[]): Promise<any[], any>;
+    /**
+     * Create a promise resolver
+     * @returns {{promise: Promise, resolve: Function, reject: Function}} resolver
+     */
+    export function defer(): {
+        promise: Promise<any, Error>;
+        resolve: Function;
+        reject: Function;
+    };
+    export { CancellationError };
+    export { TimeoutError };
+}
+/**
+ * Create a cancellation error
+ * @param {String} [message]
+ * @extends Error
+ */
+declare function CancellationError(message?: string | undefined): void;
+declare class CancellationError {
+    /**
+     * Create a cancellation error
+     * @param {String} [message]
+     * @extends Error
+     */
+    constructor(message?: string | undefined);
+    message: string;
+    stack: string | undefined;
+    name: string;
+}
+/**
+ * Create a timeout error
+ * @param {String} [message]
+ * @extends Error
+ */
+declare function TimeoutError(message?: string | undefined): void;
+declare class TimeoutError {
+    /**
+     * Create a timeout error
+     * @param {String} [message]
+     * @extends Error
+     */
+    constructor(message?: string | undefined);
+    message: string;
+    stack: string | undefined;
+    name: string;
+}
+export {};