parallel-park 0.0.0 → 0.1.0

package/.node-version

@@ -0,0 +1 @@
+v16.14.0

package/.npm-version

@@ -0,0 +1 @@
+8.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License Copyright (c) 2022 Lily Scott
+
+Permission is hereby granted, free of
+charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice
+(including the next paragraph) shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,183 @@
+# parallel-park
+
+Parallel/concurrent async work, optionally using multiple processes
+
+## Usage
+
+`parallel-park` exports two functions: `runJobs` and `inChildProcess`.
+
+### `runJobs`
+
+`runJobs` is kinda like `Promise.all`, but instead of running everything at once, it'll only run a few Promises at a time (you can choose how many to run at once). It's inspired by [Bluebird's Promise.map function](http://bluebirdjs.com/docs/api/promise.map.html).
+
+To use it, you pass in an array of inputs and a mapper function that transforms each input into a Promise. You can also optionally specify the maximum number of Promises to wait on at a time by passing an object with a `concurrency` property, which is a number. The concurrency defaults to 8.
+
+```ts
+import { runJobs } from "parallel-park";
+
+const inputs = ["alice", "bob", "carl", "dorsey", "edith"];
+const results = await runJobs(
+  inputs,
+  async (name, index, inputsCount) => {
+    // Do whatever async work you want inside this mapper function.
+    // In this case, we use a hypothetical "getUser" function to
+    // retrieve data about a user from some web API.
+    console.log(`Getting fullName for ${name}...`);
+    const user = await getUser(name);
+    return user.fullName;
+  },
+  // This options object with concurrency is an optional argument.
+  // If unspecified, it defaults to { concurrency: 8 }
+  {
+    // This number specifies how many times to call the mapper
+    // function before waiting for one of the returned Promises
+    // to resolve. Ie. "How many promises to have in-flight concurrently"
+    concurrency: 2,
+  }
+);
+// Logs these two immediately:
+//
+// Getting fullName for alice...
+// Getting fullName for bob...
+//
+// But, it doesn't log anything else yet, because we told it to only run two things at a time.
+// Then, after one of those Promises has finished, it logs:
+//
+// Getting fullName for carl...
+//
+// And so forth, until all of them are done.
+
+// `results` is an Array of the resolved value you returned from your mapper function.
+// The indices in the array correspond to the indices of your inputs.
+console.log(results);
+// Logs:
+// [
+//   "Alice Smith",
+//   "Bob Eriksson",
+//   "Carl Martinez",
+//   "Dorsey Toth",
+//   "Edith Skalla"
+// ]
+```
+
+### `inChildProcess`
+
+`inChildProcess` is a function that you pass a function into, and it spawns a separate node process to run your function in. Once your function has completed, its return/resolved value will be sent back to the node process you called `inChildProcess` from.
+
+```ts
+import { inChildProcess } from "parallel-park";
+
+const result = await inChildProcess(() => {
+  return 2 + 2;
+});
+
+console.log(result); // 4
+```
+
+Your function can also return a Promise:
+
+```ts
+// Either by returning a Promise directly...
+await inChildProcess(() => {
+  return Promise.resolve(2 + 2);
+});
+
+// Or by using an async function, which returns a Promise that resolves to the function's return value
+await inChildProcess(async () => {
+  return 2 + 2;
+});
+```
+
+> ⚠️ NOTE: The return value of your function must be JSON-serializable, or else it won't make it across the gap between the parent node process and the child one.
+
+The function you pass into `inChildProcess` will be executed in a separate node process; as such, it won't be able to access variables defined in the file calling `inChildProcess`:
+
+```ts
+const myName = "Lily";
+
+await inChildProcess(() => {
+  // Throws an error: myName is not defined
+  return myName + "!";
+});
+```
+
+To work around this, you can pass an object into `inChildProcess` as its first argument, before the function. When called this way, the function will receive that object:
+
+```ts
+await inChildProcess({ myName: "Lily" }, (data) => {
+  const myName = data.myName;
+
+  // No longer throws an error
+  return myName + "!";
+});
+```
+
+It's common to use object shorthand and destructuring syntax when passing values in:
+
+```ts
+const myName = "Lily";
+
+await inChildProcess({ myName }, ({ myName }) => {
+  return myName + "!";
+});
+```
+
+> ⚠️ NOTE: The values in your input object must be JSON-serializable, or else they won't make it across the gap between the parent node process and the child one.
+
+Because the inputs have to be JSON-serializable, you may run into an issue if trying to use an external module within the child process:
+
+```ts
+const util = require("util");
+
+await inChildProcess({ util }, ({ util }) => {
+  const someData = { something: true };
+  // Throws an error: util.inspect is not a function
+  return util.inspect(someData);
+});
+```
+
+To work around this, call `require` inside the child process function:
+
+```ts
+await inChildProcess(() => {
+  const util = require("util"); // the require is inside the function now
+
+  const someData = { something: true };
+
+  // No longer throws an error
+  return util.inspect(someData);
+});
+```
+
+If you want to use the external module both inside of the child process and outside of it, `require` it in both places:
+
+```ts
+const util = require("util");
+
+await inChildProcess(() => {
+  const util = require("util");
+
+  const someData = { something: true };
+
+  // No longer throws an error
+  return util.inspect(someData);
+});
+```
+
+The `require` inside of the child process can also be used to load stuff from your own code into the child process:
+
+```ts
+const file = "/home/lily/hello.txt";
+
+await inChildProcess({ file }, async ({ file }) => {
+  const processFile = require("./process-file");
+
+  const results = await processFile(file);
+  console.log(results);
+  return results;
+});
+```
+
+## License
+
+MIT

package/dist/child-process-worker.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const vm_1 = __importDefault(require("vm"));
+const make_module_env_1 = __importDefault(require("make-module-env"));
+const comms = fs_1.default.createWriteStream(
+// @ts-ignore
+null, { fd: 3 });
+const [inputsString, fnString, callingFile] = process.argv.slice(2);
+function onSuccess(data) {
+    comms.write(JSON.stringify({ type: "success", data }));
+}
+function onError(error) {
+    comms.write(JSON.stringify({
+        type: "error",
+        error: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        },
+    }));
+}
+try {
+    const wrapperFn = vm_1.default.runInThisContext(`(function moduleWrapper(exports, require, module, __filename, __dirname) {
+return ${fnString};})`);
+    const inputs = JSON.parse(inputsString);
+    const env = (0, make_module_env_1.default)(callingFile);
+    const fn = wrapperFn(env.exports, env.require, env.module, env.__filename, env.__dirname);
+    const result = fn(inputs);
+    if (typeof result === "object" &&
+        result != null &&
+        typeof result.then === "function") {
+        result.then(onSuccess, onError);
+    }
+    else {
+        onSuccess(result);
+    }
+}
+catch (err) {
+    onError(err);
+}

package/dist/in-child-process.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inChildProcess = void 0;
+const child_process_1 = __importDefault(require("child_process"));
+const runnerPath = require.resolve("../dist/child-process-worker");
+const inChildProcess = (...args) => {
+    const inputs = typeof args[0] === "function" ? {} : args[0];
+    const functionToRun = typeof args[0] === "function" ? args[0] : args[1];
+    if (typeof inputs !== "object") {
+        throw new Error("The first argument to inChildProcess should be an object of input data to pass to the child process.");
+    }
+    if (typeof functionToRun !== "function") {
+        throw new Error("The second argument to inChildProcess should be a function to run in the child process.");
+    }
+    const here = new Error("in inChildProcess");
+    const callingFileLine = here.stack.split("\n").slice(2)[0];
+    const matches = callingFileLine.match(/\(([^\)]+):\d+:\d+\)/);
+    const [_, callingFile] = matches;
+    const child = child_process_1.default.spawn(process.argv[0], [runnerPath, JSON.stringify(inputs), functionToRun.toString(), callingFile], {
+        stdio: ["inherit", "inherit", "inherit", "pipe"],
+    });
+    return new Promise((resolve, reject) => {
+        child.on("error", reject);
+        let receivedData = "";
+        const comms = child.stdio && child.stdio[3];
+        if (!comms) {
+            reject(new Error("Failed to establish communication pipe with child process"));
+        }
+        comms.on("data", (chunk) => {
+            receivedData += chunk.toString();
+        });
+        child.on("close", (code, signal) => {
+            if (code !== 0) {
+                reject(new Error(`Child process exited with nonzero status code: ${JSON.stringify({
+                    code,
+                    signal,
+                })}`));
+            }
+            else {
+                const result = JSON.parse(receivedData);
+                switch (result.type) {
+                    case "success": {
+                        resolve(result.data);
+                        break;
+                    }
+                    case "error": {
+                        const error = new Error(result.error.message);
+                        Object.defineProperty(error, "name", { value: result.error.name });
+                        Object.defineProperty(error, "stack", {
+                            value: result.error.name +
+                                ": " +
+                                result.error.message +
+                                "\n" +
+                                result.error.stack
+                                    .split("\n")
+                                    .slice(1)
+                                    .filter((line) => !/node:internal|node:events/.test(line))
+                                    .map((line) => {
+                                    if (/evalmachine/.test(line)) {
+                                        const lineWithoutEvalMachine = line.replace(/evalmachine(\.<anonymous>)?/, "<function passed into inChildProcess>");
+                                        const matches = line.match(/:(\d+):(\d+)\)?$/);
+                                        if (!matches) {
+                                            return lineWithoutEvalMachine;
+                                        }
+                                        else {
+                                            let [_, row, col] = matches;
+                                            // subtract 1 from row to skip the module wrapper function line
+                                            row = row - 1;
+                                            // subtract the length of the `return ` keywords in front of the function
+                                            if (row === 1) {
+                                                col = col - `return `.length;
+                                            }
+                                            const hadParen = /\)$/.test(lineWithoutEvalMachine);
+                                            return lineWithoutEvalMachine.replace(/:\d+:\d+\)?$/, `:${row}:${col - 1}${hadParen ? ")" : ""}`);
+                                        }
+                                    }
+                                    else {
+                                        return line;
+                                    }
+                                })
+                                    .join("\n") +
+                                "\n" +
+                                error
+                                    .stack.split("\n")
+                                    .slice(1)
+                                    .filter((line) => !/node:internal|node:events/.test(line))
+                                    .join("\n") +
+                                "\n" +
+                                here
+                                    .stack.split("\n")
+                                    .slice(2)
+                                    .filter((line) => !/node:internal|node:events/.test(line))
+                                    .join("\n"),
+                        });
+                        reject(error);
+                        break;
+                    }
+                    default: {
+                        reject(new Error(`Internal parallel-park error: unhandled result type: ${result.type}`));
+                    }
+                }
+            }
+        });
+    });
+};
+exports.inChildProcess = inChildProcess;

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inChildProcess = exports.runJobs = void 0;
+const run_jobs_1 = require("./run-jobs");
+Object.defineProperty(exports, "runJobs", { enumerable: true, get: function () { return run_jobs_1.runJobs; } });
+const in_child_process_1 = require("./in-child-process");
+Object.defineProperty(exports, "inChildProcess", { enumerable: true, get: function () { return in_child_process_1.inChildProcess; } });

package/dist/run-jobs.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJobs = void 0;
+async function runJobs(inputs, mapper, { 
+/**
+ * How many jobs are allowed to run at once.
+ */
+concurrency = 8, } = {}) {
+    if (concurrency < 1) {
+        throw new Error("Concurrency can't be less than one; that doesn't make any sense.");
+    }
+    if (inputs.length === 0) {
+        return Promise.resolve([]);
+    }
+    concurrency = Math.min(concurrency, inputs.length);
+    let unstartedIndex = 0;
+    const results = new Array(inputs.length);
+    const runningPromises = new Set();
+    let error = null;
+    function takeInput() {
+        const inputIndex = unstartedIndex;
+        unstartedIndex++;
+        const input = inputs[inputIndex];
+        const promise = mapper(input, inputIndex, inputs.length);
+        if (typeof promise !== "object" ||
+            promise == null ||
+            typeof promise.then !== "function") {
+            throw new Error("Mapper function passed into runJobs didn't return a Promise. The mapper function should always return a Promise. The easiest way to ensure this is the case is to make your mapper function an async function.");
+        }
+        const promiseWithMore = promise.then((result) => {
+            results[inputIndex] = result;
+            runningPromises.delete(promiseWithMore);
+        }, (err) => {
+            runningPromises.delete(promiseWithMore);
+            error = err;
+        });
+        runningPromises.add(promiseWithMore);
+    }
+    function proceed() {
+        if (unstartedIndex < inputs.length) {
+            while (runningPromises.size < concurrency) {
+                takeInput();
+            }
+        }
+    }
+    proceed();
+    while (runningPromises.size > 0 && !error) {
+        await Promise.race(runningPromises.values());
+        if (error) {
+            throw error;
+        }
+        proceed();
+    }
+    if (error) {
+        throw error;
+    }
+    return results;
+}
+exports.runJobs = runJobs;

package/package.json

@@ -1,5 +1,43 @@
 {
   "name": "parallel-park",
-  "version": "0.0.0",
-  "main": "index.js"
+  "version": "0.1.0",
+  "description": "Parallel/concurrent async work, optionally using multiple processes",
+  "main": "dist/index.js",
+  "types": "src/index.ts",
+  "scripts": {
+    "test": "jest",
+    "build": "tsc"
+  },
+  "keywords": [
+    "parallel",
+    "concurrent",
+    "thread",
+    "multithread",
+    "worker",
+    "process",
+    "child",
+    "concurrency",
+    "co-operative",
+    "promise",
+    "map"
+  ],
+  "author": "Lily Scott <me@suchipi.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/suchipi/parallel-park.git"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.17.5",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/preset-typescript": "^7.16.7",
+    "@types/jest": "^27.4.0",
+    "@types/node": "^17.0.18",
+    "babel-jest": "^27.5.1",
+    "jest": "^27.5.1",
+    "typescript": "^4.5.5"
+  },
+  "dependencies": {
+    "make-module-env": "^1.0.1"
+  }
 }

package/src/child-process-worker.ts

@@ -0,0 +1,58 @@
+import fs from "fs";
+import vm from "vm";
+import makeModuleEnv from "make-module-env";
+
+const comms = fs.createWriteStream(
+  // @ts-ignore
+  null,
+  { fd: 3 }
+);
+
+const [inputsString, fnString, callingFile] = process.argv.slice(2);
+
+function onSuccess(data: any) {
+  comms.write(JSON.stringify({ type: "success", data }));
+}
+
+function onError(error: Error) {
+  comms.write(
+    JSON.stringify({
+      type: "error",
+      error: {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+      },
+    })
+  );
+}
+
+try {
+  const wrapperFn = vm.runInThisContext(
+    `(function moduleWrapper(exports, require, module, __filename, __dirname) {
+return ${fnString};})`
+  );
+  const inputs = JSON.parse(inputsString);
+
+  const env = makeModuleEnv(callingFile);
+  const fn = wrapperFn(
+    env.exports,
+    env.require,
+    env.module,
+    env.__filename,
+    env.__dirname
+  );
+  const result = fn(inputs);
+
+  if (
+    typeof result === "object" &&
+    result != null &&
+    typeof result.then === "function"
+  ) {
+    result.then(onSuccess, onError);
+  } else {
+    onSuccess(result);
+  }
+} catch (err) {
+  onError(err as Error);
+}

package/src/in-child-process.ts

@@ -0,0 +1,148 @@
+import child_process from "child_process";
+
+const runnerPath = require.resolve("../dist/child-process-worker");
+
+type InChildProcess = {
+  <Inputs extends { [key: string]: any }, Result>(
+    inputs: Inputs,
+    functionToRun: (inputs: Inputs) => Result | Promise<Result>
+  ): Promise<Result>;
+
+  <Result>(functionToRun: () => Result | Promise<Result>): Promise<Result>;
+};
+
+export const inChildProcess: InChildProcess = (...args) => {
+  const inputs = typeof args[0] === "function" ? {} : args[0];
+  const functionToRun = typeof args[0] === "function" ? args[0] : args[1];
+
+  if (typeof inputs !== "object") {
+    throw new Error(
+      "The first argument to inChildProcess should be an object of input data to pass to the child process."
+    );
+  }
+
+  if (typeof functionToRun !== "function") {
+    throw new Error(
+      "The second argument to inChildProcess should be a function to run in the child process."
+    );
+  }
+
+  const here = new Error("in inChildProcess");
+
+  const callingFileLine = here.stack!.split("\n").slice(2)[0];
+  const matches = callingFileLine.match(/\(([^\)]+):\d+:\d+\)/);
+  const [_, callingFile] = matches!;
+
+  const child = child_process.spawn(
+    process.argv[0],
+    [runnerPath, JSON.stringify(inputs), functionToRun.toString(), callingFile],
+    {
+      stdio: ["inherit", "inherit", "inherit", "pipe"],
+    }
+  );
+
+  return new Promise((resolve, reject) => {
+    child.on("error", reject);
+
+    let receivedData = "";
+    const comms = child.stdio && child.stdio[3];
+    if (!comms) {
+      reject(
+        new Error("Failed to establish communication pipe with child process")
+      );
+    }
+
+    comms!.on("data", (chunk) => {
+      receivedData += chunk.toString();
+    });
+
+    child.on("close", (code, signal) => {
+      if (code !== 0) {
+        reject(
+          new Error(
+            `Child process exited with nonzero status code: ${JSON.stringify({
+              code,
+              signal,
+            })}`
+          )
+        );
+      } else {
+        const result = JSON.parse(receivedData);
+        switch (result.type) {
+          case "success": {
+            resolve(result.data);
+            break;
+          }
+          case "error": {
+            const error = new Error(result.error.message);
+            Object.defineProperty(error, "name", { value: result.error.name });
+            Object.defineProperty(error, "stack", {
+              value:
+                result.error.name +
+                ": " +
+                result.error.message +
+                "\n" +
+                result.error.stack
+                  .split("\n")
+                  .slice(1)
+                  .filter((line) => !/node:internal|node:events/.test(line))
+                  .map((line) => {
+                    if (/evalmachine/.test(line)) {
+                      const lineWithoutEvalMachine = line.replace(
+                        /evalmachine(\.<anonymous>)?/,
+                        "<function passed into inChildProcess>"
+                      );
+
+                      const matches = line.match(/:(\d+):(\d+)\)?$/);
+                      if (!matches) {
+                        return lineWithoutEvalMachine;
+                      } else {
+                        let [_, row, col] = matches;
+                        // subtract 1 from row to skip the module wrapper function line
+                        row = row - 1;
+
+                        // subtract the length of the `return ` keywords in front of the function
+                        if (row === 1) {
+                          col = col - `return `.length;
+                        }
+
+                        const hadParen = /\)$/.test(lineWithoutEvalMachine);
+
+                        return lineWithoutEvalMachine.replace(
+                          /:\d+:\d+\)?$/,
+                          `:${row}:${col - 1}${hadParen ? ")" : ""}`
+                        );
+                      }
+                    } else {
+                      return line;
+                    }
+                  })
+                  .join("\n") +
+                "\n" +
+                error
+                  .stack!.split("\n")
+                  .slice(1)
+                  .filter((line) => !/node:internal|node:events/.test(line))
+                  .join("\n") +
+                "\n" +
+                here
+                  .stack!.split("\n")
+                  .slice(2)
+                  .filter((line) => !/node:internal|node:events/.test(line))
+                  .join("\n"),
+            });
+            reject(error);
+            break;
+          }
+          default: {
+            reject(
+              new Error(
+                `Internal parallel-park error: unhandled result type: ${result.type}`
+              )
+            );
+          }
+        }
+      }
+    });
+  });
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+import { runJobs } from "./run-jobs";
+import { inChildProcess } from "./in-child-process";
+
+export { runJobs, inChildProcess };

package/src/run-jobs.ts

@@ -0,0 +1,86 @@
+export async function runJobs<T, U>(
+  inputs: Array<T>,
+  mapper: (input: T, index: number, length: number) => Promise<U>,
+  {
+    /**
+     * How many jobs are allowed to run at once.
+     */
+    concurrency = 8,
+  }: {
+    /**
+     * How many jobs are allowed to run at once.
+     */
+    concurrency?: number;
+  } = {}
+): Promise<Array<U>> {
+  if (concurrency < 1) {
+    throw new Error(
+      "Concurrency can't be less than one; that doesn't make any sense."
+    );
+  }
+
+  if (inputs.length === 0) {
+    return Promise.resolve([]);
+  }
+
+  concurrency = Math.min(concurrency, inputs.length);
+
+  let unstartedIndex = 0;
+
+  const results = new Array(inputs.length);
+  const runningPromises = new Set();
+  let error: Error | null = null;
+
+  function takeInput() {
+    const inputIndex = unstartedIndex;
+    unstartedIndex++;
+
+    const input = inputs[inputIndex];
+    const promise = mapper(input, inputIndex, inputs.length);
+
+    if (
+      typeof promise !== "object" ||
+      promise == null ||
+      typeof promise.then !== "function"
+    ) {
+      throw new Error(
+        "Mapper function passed into runJobs didn't return a Promise. The mapper function should always return a Promise. The easiest way to ensure this is the case is to make your mapper function an async function."
+      );
+    }
+
+    const promiseWithMore = promise.then(
+      (result) => {
+        results[inputIndex] = result;
+        runningPromises.delete(promiseWithMore);
+      },
+      (err) => {
+        runningPromises.delete(promiseWithMore);
+        error = err;
+      }
+    );
+    runningPromises.add(promiseWithMore);
+  }
+
+  function proceed() {
+    if (unstartedIndex < inputs.length) {
+      while (runningPromises.size < concurrency) {
+        takeInput();
+      }
+    }
+  }
+
+  proceed();
+  while (runningPromises.size > 0 && !error) {
+    await Promise.race(runningPromises.values());
+    if (error) {
+      throw error;
+    }
+    proceed();
+  }
+
+  if (error) {
+    throw error;
+  }
+
+  return results;
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./**/*.test.ts"],
+
+  "compilerOptions": {
+    "lib": ["es2019", "dom"],
+    "target": "es2018",
+    "module": "CommonJS",
+    "outDir": "./dist",
+
+    "strict": true,
+    "noImplicitAny": false,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "downlevelIteration": true,
+
+    "moduleResolution": "node",
+    "esModuleInterop": true
+  }
+}