@itwin/build-tools 3.0.0-dev.72

package/scripts/extract-api.js

@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+"use strict";
+
+const { spawn, handleInterrupts } = require("./utils/simpleSpawn");
+const argv = require("yargs").argv;
+const fs = require("fs-extra");
+const path = require("path");
+const paths = require("./config/paths");
+
+if (argv.entry === undefined) {
+  console.log("No argument found");
+  return;
+}
+
+const isCI = (process.env.TF_BUILD);
+const entryPointFileName = argv.entry;
+const ignoreMissingTags = argv.ignoreMissingTags;
+
+// Resolves the root of the Rush repo
+const resolveRoot = relativePath => {
+  // recurse until you find the "rush.json"
+  const parts = paths.appSrc.split(path.sep).reverse();
+  while (parts.length > 0) {
+    const resolved = path.join(parts.slice().reverse().join(path.sep), "rush.json");
+    if (fs.existsSync(resolved))
+      return path.join(parts.slice().reverse().join(path.sep), relativePath);
+    parts.shift();
+  }
+  process.stderr.write("Root of the Rush repository not found.  Missing a rush.json file?");
+};
+const rushCommon = resolveRoot("common");
+
+const config = {
+  $schema: "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+  projectFolder: "../",
+  compiler: {
+    tsconfigFilePath: "<projectFolder>/tsconfig.json"
+  },
+  mainEntryPointFilePath: `${entryPointFileName}.d.ts`,
+  apiReport: {
+    enabled: true,
+    reportFolder: path.resolve(path.join(rushCommon, "/api")),
+    reportTempFolder: path.resolve(path.join(rushCommon, "/temp/api")),
+  },
+  docModel: {
+    enabled: false
+  },
+  dtsRollup: {
+    enabled: false
+  },
+  tsdocMetadata: {
+    enabled: false
+  },
+  messages: {
+    tsdocMessageReporting: {
+      default: {
+        logLevel: "none"
+      }
+    },
+    extractorMessageReporting: {
+      default: {
+        logLevel: "error",
+        addToApiReportFile: false
+      },
+      "ae-incompatible-release-tags": {
+        logLevel: "error",
+        addToApiReportFile: false
+      },
+      "ae-missing-release-tag": {
+        logLevel: ignoreMissingTags ? "none" : "error",
+        addToApiReportFile: false
+      },
+      "ae-internal-missing-underscore": {
+        logLevel: "none",
+        addToApiReportFile: false
+      },
+      "ae-forgotten-export": {
+        logLevel: "none",
+        addToApiReportFile: false
+      },
+      "ae-unresolved-inheritdoc-reference": {
+        logLevel: "error",
+        addToApiReportFile: true
+      },
+      "ae-unresolved-inheritdoc-base": {
+        logLevel: "error",
+        addToApiReportFile: true
+      }
+    }
+  }
+};
+
+if (!fs.existsSync("lib")) {
+  process.stderr.write("lib folder not found. Run `rush build` before extract-api");
+  process.exit(1);
+}
+
+const configFileName = `lib/${entryPointFileName}.json`;
+fs.writeFileSync(configFileName, JSON.stringify(config, null, 2));
+
+const args = [
+  "run",
+  "-c", configFileName
+];
+if (!isCI)
+  args.push("-l");
+
+spawn(require.resolve(".bin/api-extractor"), args).then((code) => {
+  if (fs.existsSync(configFileName))
+    fs.unlinkSync(configFileName);
+
+  // Only generate the extraction of the summary locally.
+  if (isCI)
+    process.exit(code);
+
+  const extractSummaryArgs = [
+    path.resolve(__dirname, "extract-api-summary.js"),
+    "--apiSignature", path.resolve(path.join(rushCommon, `/api/${entryPointFileName}.api.md`)),
+    "--outDir", path.resolve(path.join(rushCommon, "/api/summary")),
+  ];
+
+  spawn("node", extractSummaryArgs).then((code) => {
+    process.exit(code);
+  });
+
+  if (process.env.GENERATE_FULL_API_REPORT)
+    spawn("node", [...extractSummaryArgs, "--gatherFullReport"]).then((code) => {
+      process.exit(code);
+    });
+});
+handleInterrupts();

package/scripts/extract.js

@@ -0,0 +1,72 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+"use strict";
+
+const argv = require("yargs").argv;
+const path = require("path");
+const paths = require("./config/paths");
+const fs = require("fs-extra");
+const readDirectory = require("recursive-readdir");
+
+const __PUBLISH_EXTRACT_START__ = "__PUBLISH_EXTRACT_START__";
+const __PUBLISH_EXTRACT_END__ = "__PUBLISH_EXTRACT_END__";
+
+const extractDir = (argv.extractFrom === undefined) ? paths.appTest : argv.extractFrom;
+const outDir = (argv.out === undefined) ? paths.libExtract : argv.out;
+const fileExt = (argv.fileExt === undefined) ? ["test.ts"] : argv.fileExt.split(",");
+const recursive = (argv.recursive === undefined) ? false : true;
+
+const ignoreFunction = (file, stats) => {
+  if (stats.isDirectory())
+    return !recursive; // don't ignore subdirectories in recursive mode
+  return !fileExt.some((ext) => file.endsWith(ext)); // don't ignore files with desired extensions
+};
+
+readDirectory(extractDir, [ignoreFunction], (error, inputFileNames) => {
+  for (const inputFileName of inputFileNames) {
+    const inputFileContents = fs.readFileSync(inputFileName, "utf8");
+
+    // Skip the file if there are no occurences of the starting comment.
+    if (inputFileContents.indexOf(__PUBLISH_EXTRACT_START__) <= 0)
+      continue;
+
+    console.log("Processing: " + inputFileName);
+    const inputLines = inputFileContents.split("\n");
+    let outputFileName = undefined;
+    let outputLines = [];
+    let startIndent = 0;
+
+    for (const inputLine of inputLines) {
+      const startIndex = inputLine.indexOf(__PUBLISH_EXTRACT_START__);
+      if (startIndex > 0) {
+        startIndent = startIndex - 3;
+        if (outputFileName)
+          throw new Error("Nested " + __PUBLISH_EXTRACT_START__);
+
+        outputFileName = inputLine.substring(startIndex + __PUBLISH_EXTRACT_START__.length).trim();
+        if (0 === outputFileName.length)
+          throw new Error("Expected output file name after " + __PUBLISH_EXTRACT_START__);
+      } else if (inputLine.indexOf(__PUBLISH_EXTRACT_END__) > 0) {
+        if (!outputFileName)
+          throw new Error("Missing " + __PUBLISH_EXTRACT_START__);
+
+        if (!fs.existsSync(outDir))
+          fs.ensureDirSync(outDir);
+
+        const outputFilePath = path.join(outDir, outputFileName);
+        console.log("> Extracting into: " + outputFilePath);
+        fs.writeFileSync(outputFilePath, outputLines.join("\n"));
+
+        outputFileName = undefined;
+        outputLines = [];
+      } else if (outputFileName) {
+        outputLines.push(inputLine.substring(startIndent).replace(/\s+$/gm, ""));
+      }
+    }
+
+    if (outputFileName)
+      throw new Error("Missing " + __PUBLISH_EXTRACT_END__);
+  }
+});

package/scripts/pseudolocalize.js

@@ -0,0 +1,107 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+"use strict";
+
+/** Generates pseudo localization files from the en localization JSON files.
+*/
+
+function pseudoLocalizeObject(objIn) {
+  let objOut = {};
+  for (let prop in objIn) {
+    if (objIn.hasOwnProperty(prop)) {
+      if (typeof objIn[prop] === "string") {
+        objOut[prop] = pseudoLocalize(objIn[prop])
+      } else if (typeof objIn[prop] === "object") {
+        objOut[prop] = pseudoLocalizeObject(objIn[prop])
+      }
+    }
+  }
+  return objOut;
+}
+
+const replacements = {
+  A: "\u00C0\u00C1,\u00C2\u00C3,\u00C4\u00C5",
+  a: "\u00E0\u00E1\u00E2\u00E3\u00E4\u00E5",
+  B: "\u00DF",
+  c: "\u00A2\u00E7",
+  C: "\u00C7\u0028",
+  D: "\u00D0",
+  E: "\u00C8\u00C9\u00CA\u00CB",
+  e: "\u00E8\u00E9\u00EA\u00EB",
+  I: "\u00CC\u00CD\u00CE\u00CF",
+  i: "\u00EC\u00ED\u00EE\u00EF",
+  L: "\u00A3",
+  N: "\u00D1",
+  n: "\u00F1",
+  O: "\u00D2\u00D3\u00D4\u00D5\u00D6",
+  o: "\u00F2\u00F3\u00F4\u00F5\u00F6\u00F8",
+  S: "\u0024\u00A7",
+  U: "\u00D9\u00DA\u00DB\u00DC",
+  u: "\u00B5\u00F9\u00FA\u00FB\u00FC",
+  x: "\u00D7",
+  Y: "\u00DD\u00A5",
+  y: "\u00FD\u00FF",
+};
+
+/** PseudoLocalizes a single string */
+function pseudoLocalize(inputString) {
+  let inReplace = 0;
+  let outString = "";
+  let replaceIndex = 0; // Note: the pseudoLocalize algorithm would normally use random, but here we cycle through because Javascript doesn't allow setting of the seed for Math.random.
+  for (let iChar = 0; iChar < inputString.length; iChar++) {
+    let thisChar = inputString.charAt(iChar);
+    let nextChar = ((iChar + 1) < inputString.length) ? inputString.charAt(iChar + 1) : 0;
+
+    // handle the {{ and }} delimiters for placeholders - don't want to do anything to characters in between.
+    if (('{' === thisChar) && ('{' === nextChar)) {
+      inReplace++;
+      iChar++;
+      outString = outString.concat("{{");
+    } else if (('}' === thisChar) && ('}' === nextChar) && (inReplace > 0)) {
+      inReplace--;
+      iChar++;
+      outString = outString.concat("}}");
+    } else {
+      let replacementChar = thisChar;
+      if (0 === inReplace) {
+        let replacementsForChar = replacements[thisChar];
+        if (undefined !== replacementsForChar) {
+          replacementChar = replacementsForChar.charAt(replaceIndex++ % replacementsForChar.length);
+        }
+      }
+      outString = outString.concat(replacementChar);
+    }
+  }
+  return outString;
+}
+
+function isJsonFile(fileName) {
+  return fileName.endsWith(".json");
+}
+
+const argv = require("yargs").argv;
+const paths = require("./config/paths");
+const fs = require("fs-extra");
+const path = require("path");
+
+const englishDir = (argv.englishDir === undefined) ? paths.appLocalesEnglish : argv.englishDir;
+const inputFileNames = fs.readdirSync(englishDir).filter(isJsonFile);
+const outDir = (argv.out === undefined) ? paths.appLocalesPseudolocalize : argv.out;
+try {
+  fs.mkdirpSync(outDir);
+} catch (e) {
+  console.log(e);// do nothing
+}
+
+for (const inputFileName of inputFileNames) {
+  const inputFilePath = path.join(englishDir, inputFileName);
+  const outputFileName = path.join(outDir, inputFileName);
+
+  let jsonIn = fs.readFileSync(inputFilePath, { encoding: "utf8" });
+  let objIn = JSON.parse(jsonIn);
+
+  let objOut = pseudoLocalizeObject(objIn);
+  fs.writeFileSync(outputFileName, JSON.stringify(objOut, null, 2));
+}

package/scripts/rush/audit.js

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+const { logBuildError, logBuildWarning, failBuild, throwAfterTimeout } = require("./utils");
+
+const rushCommonDir = path.join(__dirname, "../../../../common/");
+
+(async () => {
+  const commonTempDir = path.join(rushCommonDir, "config/rush");
+
+  // Npm audit will occasionally take minutes to respond - we believe this is just the npm registry being terrible and slow.
+  // We don't want this to slow down our builds though - we'd rather fail fast and try again later.  So we'll just timeout after 30 seconds.
+  let jsonOut = {};
+  try {
+    console.time("Audit time");
+    jsonOut = await Promise.race([runPnpmAuditAsync(commonTempDir), throwAfterTimeout(180000, "Timed out contacting npm registry.")]);
+    console.timeEnd("Audit time");
+    console.log();
+  } catch (error) {
+    // We want to stop failing the build on transient failures and instead fail only on high/critical vulnerabilities.
+    logBuildWarning(error);
+    process.exit();
+  }
+
+  if (jsonOut.error) {
+    console.error(jsonOut.error.summary);
+    logBuildWarning("Rush audit failed. This may be caused by a problem with the npm audit server.");
+  }
+
+  // A list of temporary advisories excluded from the High and Critical list.
+  // Warning this should only be used as a temporary measure to avoid build failures
+  // for development dependencies only.
+  // All security issues should be addressed asap.
+  const excludedAdvisories = [
+    1700, // https://npmjs.com/advisories/1700
+    1754, // https://npmjs.com/advisories/1754. Waiting for fix, https://github.com/svg/svgo/pull/1485.
+    1755, // https://npmjs.com/advisories/1755. Waiting for fix, https://github.com/sindresorhus/normalize-url/issues/135
+    1779, // https://npmjs.com/advisories/1779. Waiting for fix in @bentley/react-scripts
+    1780, // https://npmjs.com/advisories/1780. Waiting for fix in @bentley/react-scripts
+    1781, // https://npmjs.com/advisories/1781. Waiting for fix in @bentley/react-scripts
+  ];
+
+  let shouldFailBuild = false;
+  for (const action of jsonOut.actions) {
+    for (const issue of action.resolves) {
+      const advisory = jsonOut.advisories[issue.id];
+
+      // TODO: This path no longer resolves to a specific package in the repo.  Need to figure out the best way to handle it
+      const mpath = issue.path; // .replace("@rush-temp", "@bentley");
+
+      const severity = advisory.severity.toUpperCase();
+      const message = `${severity} Security Vulnerability: ${advisory.title} in ${advisory.module_name} (from ${mpath}).  See ${advisory.url} for more info.`;
+
+      // For now, we'll only treat CRITICAL and HIGH vulnerabilities as errors in CI builds.
+      if (!excludedAdvisories.includes(advisory.id) && (severity === "HIGH" || severity === "CRITICAL")) {
+        logBuildError(message);
+        shouldFailBuild = true;
+      } else if (excludedAdvisories.includes(advisory.id) || severity === "MODERATE") // Only warn on MODERATE severity items
+        logBuildWarning(message);
+    }
+  }
+
+  // For some reason yarn audit can return the json without the vulnerabilities
+  if (undefined === jsonOut.metadata.vulnerabilities || shouldFailBuild)
+    failBuild();
+
+  process.exit();
+})();
+
+function runPnpmAuditAsync(cwd) {
+  return new Promise((resolve, reject) => {
+    // pnpm audit requires a package.json file so we temporarily create one and
+    // then delete it later
+    fs.writeFileSync(path.join(rushCommonDir, "config/rush/package.json"), JSON.stringify("{}", null, 2));
+
+    console.log("Running audit");
+    const pnpmPath = path.join(rushCommonDir, "temp/pnpm-local/node_modules/.bin/pnpm");
+    const child = spawn(pnpmPath, ["audit", "--json"], { cwd, shell: true });
+
+    let stdout = "";
+    child.stdout.on('data', (data) => {
+      stdout += data;
+    });
+
+    child.on('error', (data) => {
+      fs.unlinkSync(path.join(rushCommonDir, "config/rush/package.json"));
+      reject(data)
+    });
+    child.on('close', () => {
+      fs.unlinkSync(path.join(rushCommonDir, "config/rush/package.json"));
+      resolve(JSON.parse(stdout.trim()));
+    });
+  });
+}

package/scripts/rush/utils.js

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+function logBuildWarning(msg) {
+  if (process.env.TF_BUILD)
+    console.error("##vso[task.logissue type=warning;]%s", msg);
+  else
+    console.error("WARNING: %s", msg);
+}
+
+function logBuildError(msg) {
+  if (process.env.TF_BUILD)
+    console.error("##vso[task.logissue type=error;]%s", msg);
+  else
+    console.error("ERROR: %s", msg);
+}
+
+function failBuild() {
+  if (process.env.TF_BUILD) {
+    console.error("##vso[task.complete result=Failed;]DONE")
+    process.exit(0);
+  } else {
+    process.exit(1);
+  }
+}
+
+function throwAfterTimeout(timeout, message) {
+  return new Promise((_resolve, reject) => {
+    setTimeout(() => reject(message), timeout);
+  });
+}
+
+module.exports = {
+  logBuildWarning,
+  logBuildError,
+  failBuild,
+  throwAfterTimeout
+}

package/scripts/utils/simpleSpawn.js

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+const spawn = require("cross-spawn");
+const chalk = require("chalk");
+const kill = require("tree-kill");
+
+function simpleSpawn(cmd, args, cwd, env = {}) {
+  if (!cwd)
+    cwd = process.cwd();
+
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      cwd: cwd,
+      env: { FORCE_COLOR: "1", ...env, ...process.env },
+      stdio: "pipe"
+    });
+
+    child.stdout.on("data", (data) => {
+      process.stdout.write(data);
+    })
+    child.stderr.on("data", (data) => {
+      process.stderr.write(data);
+    })
+    child.on("error", function (data) { console.log(chalk.red(data)); });
+    child.on("close", (code) => resolve(code));
+    simpleSpawn.children.push(child);
+  });
+}
+
+function simpleSpawnSync(cmd, args, cwd, env = {}) {
+  if (!cwd)
+    cwd = process.cwd();
+
+  const child = spawn.sync(cmd, args, {
+    cwd: cwd,
+    env: { FORCE_COLOR: "1", ...env, ...process.env },
+    stdio: "inherit"
+  });
+
+  if (child.status !== 0) {
+    process.exit(child.status);
+  }
+}
+
+simpleSpawn.children = [];
+simpleSpawn.killAll = async function () {
+  const promises = [];
+  simpleSpawn.children.forEach((proc) => {
+    promises.push(new Promise((resolve) => {
+      kill(proc.pid, undefined, resolve);
+    }));
+  });
+  await Promise.all(promises);
+}
+
+function handleInterrupts(callback) {
+  if (!callback) {
+    callback = async () => {
+      await simpleSpawn.killAll();
+      process.exit();
+    };
+  }
+
+  if (process.platform === "win32") {
+    require("readline")
+      .createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+  }
+
+  ["SIGINT", "SIGTERM"].forEach(function (sig) {
+    process.on(sig, function () {
+      callback();
+    });
+  });
+}
+
+module.exports = {
+  spawn: simpleSpawn,
+  spawnSync: simpleSpawnSync,
+  handleInterrupts
+};

package/scripts/utils/validateTags.js

@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+
+const FS = require('fs-extra');
+const validTags = [
+  "see",
+  "note",
+  "throws",
+  "param",
+  "module",
+  "type",
+  "minimum",
+  "minlength",
+  "default",
+  "example",
+  "pattern",
+
+  // Following flags are added to support API-extractor (https://api-extractor.com/pages/tsdoc/syntax/#release-tags)
+  "alpha",
+  "beta",
+  "deprecated",
+  "internal",
+  "public",
+];
+
+function validateTags(path) {
+  return parseFile(path);
+}
+
+function parseFile(path) {
+  let allTags = {};
+
+  if (FS.existsSync(path) && FS.statSync(path).isFile()) {
+    const contents = FS.readFileSync(path, 'utf-8');
+    let jsonContents = JSON.parse(contents);
+
+    let tags = findValues(jsonContents, 'tags');
+
+    for (let j = 0; j < tags.length; j++) {
+      for (let i = 0; i < tags[j].length; i++)
+        allTags[tags[j][i]['tag']] = allTags[tags[j][i]['tag']] ? allTags[tags[j][i]['tag']] + 1 : 1;
+    }
+
+    let invalidTagObjects = [];
+    for (tag in allTags) {
+      if (!validTags.includes(tag))
+        invalidTagObjects.push(tag, findSource(jsonContents, 'tag', tag));
+    }
+    return invalidTagObjects;
+  }
+}
+
+function findValues(obj, key) {
+  return findValuesHelper(obj, key, []);
+}
+
+function findValuesHelper(obj, key, list) {
+  if (!obj) return list;
+  if (obj instanceof Array) {
+    for (var i in obj)
+      list = list.concat(findValuesHelper(obj[i], key, []));
+    return list;
+  }
+
+  if (obj[key]) list.push(obj[key]);
+
+  if ((typeof obj == "object") && (obj !== null)) {
+    const children = Object.keys(obj);
+    if (children.length > 0) {
+      for (i = 0; i < children.length; i++)
+        list = list.concat(findValuesHelper(obj[children[i]], key, []));
+    }
+  }
+  return list;
+}
+
+function findSource(obj, key, value) {
+  return findSourceHelper(obj, key, value, []);
+}
+
+function findSourceHelper(obj, key, value, list) {
+  if (!obj) return list;
+  if (obj instanceof Array) {
+    for (var i in obj)
+      list = list.concat(findSourceHelper(obj[i], key, value, []));
+    return list;
+  }
+
+  //Look for tag in signature or in comment
+  if (obj['signatures']) {
+    if (obj['signatures'][0] && obj['signatures'][0]['comment'] && obj['signatures'][0]['comment']['tags']) {
+      for (let tag in obj['signatures'][0]['comment']['tags']) {
+        if (obj['signatures'][0]['comment']['tags'][tag].tag === value && obj['sources'] && obj['sources'][0])
+          list.push(obj['sources'][0]);
+      }
+    }
+  }
+
+  if (obj['comment'] && obj['comment']['tags']) {
+    for (let tag in obj['comment']['tags']) {
+      if (obj['comment']['tags'][tag].tag === value && obj['sources'] && obj['sources'][0])
+        list.push(obj['sources'][0]);
+    }
+  }
+
+  if ((typeof obj == "object") && (obj !== null)) {
+    const children = Object.keys(obj);
+    if (children.length > 0) {
+      for (i = 0; i < children.length; i++)
+        list = list.concat(findSourceHelper(obj[children[i]], key, value, []));
+    }
+  }
+  return list;
+}
+
+module.exports = {
+  validateTags: validateTags,
+};

package/tsconfig-base.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "lib": [
+      // Required for async iterators/generators:
+      "esnext.asynciterable",
+      // These are the defaults for "target": "es2017", but they have to be explicitly specified if we want to add anything to "lib":
+      "es2017",
+      "dom",
+      "dom.iterable",
+      "scripthost"
+    ],
+    "module": "commonjs",
+    "stripInternal": false,
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": false,
+    "experimentalDecorators": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "declarationMap": true,
+    "jsx": "react",
+    "forceConsistentCasingInFileNames": true,
+    "incremental": true
+  }
+}