gen-api-types 1.0.0

package/README.en.md

@@ -0,0 +1,36 @@
+# get-api-types
+
+#### Description
+一个自动生成请求接口返回类型的cli工具
+
+#### Software Architecture
+Software architecture description
+
+#### Installation
+
+1.  xxxx
+2.  xxxx
+3.  xxxx
+
+#### Instructions
+
+1.  xxxx
+2.  xxxx
+3.  xxxx
+
+#### Contribution
+
+1.  Fork the repository
+2.  Create Feat_xxx branch
+3.  Commit your code
+4.  Create Pull Request
+
+
+#### Gitee Feature
+
+1.  You can use Readme\_XXX.md to support different languages, such as Readme\_en.md, Readme\_zh.md
+2.  Gitee blog [blog.gitee.com](https://blog.gitee.com)
+3.  Explore open source project [https://gitee.com/explore](https://gitee.com/explore)
+4.  The most valuable open source project [GVP](https://gitee.com/gvp)
+5.  The manual of Gitee [https://gitee.com/help](https://gitee.com/help)
+6.  The most popular members  [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)

package/README.md

@@ -0,0 +1,109 @@
+# gen-api-types
+
+#### 介绍
+
+🚀 一个自动生成请求接口返回类型的 cli 工具
+
+在 ts 项目中，经常需要编写接口返回类型。但是每次都要查看接口文档，手动编写非常麻烦。如果遇到一些第三方接口或者接口文档不全的情况，还需要先调试接口后，再编写接口返回类型，很令人头疼
+
+借助这个工具，我们可以通过 ts 装饰器来标记请求接口的类和方法，然后动态调用这些接口，并将接口返回的数据转换成 ts 类型文件，这样我们就可以在项目中直接使用了
+
+> 注意：
+> 该工具需要动态执行 ts 代码（调用项目中的接口模块），必须依赖 `tsx` 执行工具，请务必先全局安装 `tsx`，确保`tsx`命令可用。
+
+#### 安装教程
+
+1.npm 安装
+
+```shell
+npm install tsx -g
+npm install gen-api-types -D
+
+```
+
+#### 使用说明
+
+##### 1. 标记接口类名和方法
+
+```ts
+import { gen_type_c, gen_type_m } from 'gen-api-types'
+
+@gen_type_c()
+export class TestApi {
+	@gen_type_m({ args: [100], typeName: 'XXX' })
+	static async getList(id: number): Promise<XXX> {
+		return asleep(1000).then(() => {
+			return { name: 'zs', id }
+		})
+	}
+
+	@gen_type_m()
+	static getWeather(): Promise<Res_TestApi_getWeather> {
+		return fetch('http://t.weather.sojson.com/api/weather/city/101030100').then(r => r.json())
+	}
+}
+```
+
+如上面代码所示:
+
+- `@gen_type_c`装饰器函数，用来标记接口类。因为工具会动态分析指定目录下的所有 ts 文件，标记接口类，可以帮助我们快速定位接口类
+- `@gen_type_m`装饰器函数标记需要转换的请求方法。它可以接收一个配置对象，包含两个字段。
+  1.  `typeName: string` 接口返回类型名称，若不指定该字段，默认生成名称为： `Response_${类名}_${方法名}`
+  2.  `args：any[] ` 方法参数列表,工具调用请求方法时，会将参数列表传入
+
+##### 2. 执行命令
+
+```shell
+npx gen-api-types  -o output_dir -O output_file_name ./api_dir1 ./api_dir2
+```
+
+参数说明：
+
+```shell
+ Usage: npx gen-api-types [options] [api_dirs...]
+
+Options:
+  -h, --help                  输出帮助信息
+  -r, --project_root <path>   项目根目录
+  -o, --output_file <path>    输出文件,默认index.d.ts
+  -d, --output_dir <path>     输出目录,默认当前根目录
+  -t, --ts_config_path <path> tsconfig.json 文件路径
+```
+
+当然，也可以通过配置 package.json 中的 scripts 来使用
+
+```json
+{
+	"scripts": {
+		"gen_types": "gen-api-types -o output_dir -O output_file_name ./api_dir1 ./api_dir2"
+	}
+}
+```
+
+命令输出：
+
+```shell
+🚀 开始生成API类型...
+sourceFilesGlob [ 'src\\**\\*.ts' ]
+📋 处理 UserApi.getList ...
+📋 处理 UserApi.getWeather ...
+请求结果：
+  ┌────────────────┬──────────────────────────────────────┐
+  │ (index)        │ Values                               │
+  ├────────────────┼──────────────────────────────────────┤
+  │ ✔️ successList │ 'UserApi.getList UserApi.getWeather' │
+  │ ❌ errorList   │ ''                                   │
+  └────────────────┴──────────────────────────────────────┘
+✅ API 类型生成完成
+```
+
+##### 3. 使用类型
+
+默认生成类型文件 index.d.ts,且没有导出
+
+```ts
+type XXX = { name: string };
+type Response_UserApi_getWeather = {...}
+```
+
+可在`tsconfig.json`中配置`include`引用文件,或者直接在接口模块文件顶部通过`/// <reference path="./index.d.ts" />`引用

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "gen-api-types",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./src/index.ts",
+  "bin": {
+    "gen-api-types-2": "src/cli/index.ts"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "webpack",
+    "publish:patch": "npm version patch  && npm publish"
+  },
+  "keywords": [],
+  "files": [
+    "src",
+    "tsconfig.json",
+    "package.json"
+  ],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.7.1",
+  "dependencies": {
+    "reflect-metadata": "^0.2.2",
+    "ts-morph": "^27.0.0",
+    "tsx": "^4.20.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.1",
+    "ts-loader": "^9.5.4",
+    "webpack": "^5.101.0",
+    "webpack-cli": "^6.0.1"
+  }
+}

package/src/argv/index.ts

@@ -0,0 +1,70 @@
+import path from "path";
+import { parseArgs } from "util";
+
+
+// 1. 配置
+const PROJECT_ROOT = path.resolve();
+const OUTPUT_FILE = 'index.d.ts';
+const OUTPUT_DIR = PROJECT_ROOT
+const TS_CONFIG_PATH = path.join(PROJECT_ROOT, 'tsconfig.json');
+
+
+
+const _arg = parseArgs({
+  allowPositionals: true,
+  args: process.argv.slice(2),
+  options: {
+    output_dir: {
+      type: 'string',
+      short: 'o',
+      default: OUTPUT_DIR,
+    },
+    output_file: {
+      type: 'string',
+      short: 'O',
+      default: OUTPUT_FILE,
+    },
+    project_root: {
+      type: 'string',
+      short: 'r',
+      default: PROJECT_ROOT,
+    },
+    ts_config_path: {
+      type: 'string',
+      short: 't',
+      default: TS_CONFIG_PATH,
+    },
+    help: {
+      type: 'boolean',
+      short: 'h'
+    }
+  }
+})
+
+
+export const { positionals, values: { project_root, output_file, output_dir, ts_config_path, help } } = _arg
+
+if (help) {
+  console.log(`
+  Usage: tsx cli.js [options] [positionals]
+
+  Options:
+    -h, --help                  输出帮助信息
+    -r, --project_root <path>   项目根目录
+    -o, --output_file <path>    输出文件
+    -d, --output_dir <path>     输出目录
+    -t, --ts_config_path <path> tsconfig.json 文件路径
+    `
+  )
+  process.exit(0)
+}
+
+
+
+
+
+if (positionals.length == 0) {
+  console.error('❌ 错误: 必须指定 API 目录');
+  console.log('💡 用法示例: node cli.js ./api-directory');
+  process.exit(1)
+}

package/src/cli/index.ts

@@ -0,0 +1,175 @@
+#!/usr/bin/env tsx
+
+
+// scripts/generate-api-types.ts
+import * as path from 'path';
+import { Decorator, Project } from 'ts-morph';
+import { pathToFileURL } from 'url';
+import { output_dir, output_file, positionals } from '../argv';
+import { C_DECO_NAME, M_DECO_NAME } from '../constant';
+import { GenTypeOptions } from '../decotators';
+import { TypeTransformer } from '../transformer';
+
+
+
+const sourceFilesGlob = positionals.map(dir => path.normalize(`${dir}/**/*.ts`))
+
+// console.log('arg', _arg)
+// console.log('sourceFilesGlob', sourceFilesGlob)
+// debugger
+
+type ApiMethodInfo = {
+  className: string,
+  methodName: string,
+  fullMethodName: string,
+  modulePath: string,
+  args: any[],
+  typeName: string,
+}
+
+function parserDecoArgs(deco: Decorator): GenTypeOptions {
+  const errMsg = `装饰器参数错误`
+  try {
+    const optionStr = deco.getArguments()[0]?.getText()
+    if (!optionStr) return {}
+    const option = eval(`(()=>(${optionStr}))()`)
+    if (typeof option === 'object') return option
+    else throw new Error(errMsg)
+  } catch (error) {
+    console.warn('parserDecoArgs error', error)
+    return {}
+  }
+
+}
+function getApiMethodsInfo() {
+  console.log('sourceFilesGlob', sourceFilesGlob)
+  const apiMethodsInfo: ApiMethodInfo[] = []
+  // 2. 使用ts-morph创建项目，便于解析源码
+  // const project = new Project({ tsConfigFilePath: ts_config_path });
+  const project = new Project({});
+
+  project.addSourceFilesAtPaths(sourceFilesGlob);
+  // debugger
+  // 3. 遍历所有源文件
+  for (const sourceFile of project.getSourceFiles()) {
+
+    const classes = sourceFile.getClasses();
+    for (const classDeclaration of classes) {
+      const c_deco = classDeclaration.getDecorator(C_DECO_NAME)
+      if (!c_deco) continue
+      const methods = classDeclaration.getMethods();
+      for (const method of methods) {
+
+        const className = classDeclaration.getName()!;
+        const methodName = method.getName();
+        const fullMethodName = `${className}.${methodName}`;
+
+        if (!method.isStatic()) {
+          console.warn(`⚠️  ${fullMethodName} is not static method,only static method can be transformed`)
+          continue
+        }
+        // 4. 检查方法是否被我们的装饰器标记
+        const m_deco = method.getDecorator(M_DECO_NAME)
+        if (!m_deco) continue
+
+        const { args = [], typeName = `Response_${className}_${methodName}` } = parserDecoArgs(m_deco)
+        apiMethodsInfo.push({
+          className, methodName, fullMethodName, modulePath: sourceFile.getFilePath(),
+          typeName, args
+        })
+
+      }
+    }
+  }
+  return apiMethodsInfo
+}
+
+type ExcuteApiMethodsResult = {
+  successList: { data: any, typeName: string, fullMethodName: string }[],
+  errorList: { fullMethodName: string, error: any }[]
+}
+async function excuteApiMethods(apiMethodsInfo: ApiMethodInfo[]): Promise<ExcuteApiMethodsResult> {
+  const apiModuleMap = new Map<string, any>();
+  const taskList = apiMethodsInfo.map(async (apiMethodInfo) => {
+    const { className, methodName, fullMethodName, modulePath, args, typeName } = apiMethodInfo
+    console.log(`📋 处理 ${fullMethodName} ...`);
+    let apiModule = null
+    if (apiModuleMap.has(modulePath)) apiModule = apiModuleMap.get(modulePath)
+    else {
+      // apiModule = await import(modulePath)
+      // debugger
+      // console.log('modulePath', modulePath)
+      // console.log('pathToFileURL(modulePath).href', pathToFileURL(modulePath).href)
+
+      try {
+        apiModule = await import(pathToFileURL(modulePath).href)
+        console.log('apiMethod', apiModule)
+        if (apiModule) apiModuleMap.set(modulePath, apiModule)
+      } catch (error) {
+        console.log('import modulePath error', error)
+      }
+
+    }
+    const apiMethod = apiModule?.[className]?.[methodName]
+    if (apiMethod && typeof apiMethod === 'function') {
+      try {
+        console.log(`🔍 Calling ${fullMethodName} with args:`, args);
+        const result = apiMethod.apply(apiModule, args)
+        if (result instanceof Promise) {
+          const data = await result
+          // console.log(`${fullMethodName} result`)
+          return { data, typeName, fullMethodName }
+        }
+        return { error: 'not Promise method', fullMethodName }
+      } catch (error) {
+        console.error(`❌ ${fullMethodName} execute error:`, error)
+        return { error, fullMethodName }
+      }
+    } else {
+      console.error(`❌ 无法获取 ${fullMethodName}或 非 可调用方法 `)
+      return {
+        error: `method error`, fullMethodName
+      }
+    }
+  })
+
+  const resultList = await Promise.all(taskList)
+  return {
+    successList: resultList.filter(item => !item.error) as ExcuteApiMethodsResult['successList'],
+    errorList: resultList.filter(item => item.error) as ExcuteApiMethodsResult['errorList'],
+  }
+}
+
+function createDeclarationFile(successList: ExcuteApiMethodsResult['successList']) {
+  const out_put_target = path.resolve(output_dir, output_file)
+  // console.log('out_put_target', out_put_target)
+  const ttf = new TypeTransformer({ filePath: out_put_target })
+  const tasks = successList.map(item => ttf.transform(item.data, item.typeName))
+  return Promise.all(tasks)
+}
+
+async function main() {
+  try {
+    console.log('🚀 开始生成API类型...');
+    const apiMethodsInfo = getApiMethodsInfo();
+    const { successList, errorList } = await excuteApiMethods(apiMethodsInfo);
+
+    console.group('请求结果：')
+    console.table({
+      "✔️  successList": successList.map(item => item.fullMethodName).join(' '),
+      "❌ errorList": errorList.map(item => item.fullMethodName).join(' ')
+    })
+    console.groupEnd()
+    await createDeclarationFile(successList)
+
+    console.log('✅ API 类型生成完成');
+
+
+
+  } catch (error) {
+    console.error('❌ 出错了', error)
+  }
+
+}
+
+main()

package/src/constant/index.ts

@@ -0,0 +1,3 @@
+export const GEN_TYPE_METADATA_KEY = Symbol('gen:type:metadata');
+export const M_DECO_NAME = 'gen_type_m';
+export const C_DECO_NAME = 'gen_type_c';

package/src/decotators/index.ts

@@ -0,0 +1,28 @@
+// import 'reflect-metadata';
+
+// 定义一个唯一的metadata key
+
+
+export interface GenTypeOptions {
+  args?: any[];
+  typeName?: string;
+}
+
+export function gen_type_m({ args = [], typeName }: GenTypeOptions = {}) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    // 只存储元数据，不执行任何逻辑
+    // Reflect.defineMetadata(
+    //   GEN_TYPE_METADATA_KEY,
+    //   { args, typeName },
+    //   target,
+    //   propertyKey
+    // );
+  };
+}
+
+
+
+export function gen_type_c() {
+  return function <T>(target: T) {
+  };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './decotators';
+

package/src/transformer/index.ts

@@ -0,0 +1,58 @@
+import { Project, SourceFile } from "ts-morph";
+
+function inferType(value: any): string {
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "any[]";
+    // 取第一个元素类型，假设数组元素类型一致
+    return `${inferType(value[0])}[]`;
+  } else if (typeof value === "object" && value !== null) {
+    const props = Object.entries(value).map(([k, v]) => `${k}: ${inferType(v)}`).join("; ");
+    return `{ ${props} }`;
+  } else if (typeof value === "string") {
+    return "string";
+  } else if (typeof value === "number") {
+    return "number";
+  } else if (typeof value === "boolean") {
+    return "boolean";
+  } else if (!value) {
+    return "null";
+  } else {
+    return "any";
+  }
+}
+
+
+export class TypeTransformer {
+  project: Project;
+  sourceFile: SourceFile;
+  constructor({ projectOptions = {}, filePath = "types.d.ts" } = {}) {
+    this.project = new Project(projectOptions);
+    this.sourceFile = this.createSourceFile(filePath);
+  }
+
+  createSourceFile(filePath: string) {
+    // try {
+    //   return project.addSourceFileAtPath(filePath);
+    // } catch (error) {
+    //   return project.createSourceFile(filePath);
+    // }
+    return this.project.createSourceFile(filePath, '', { overwrite: true });
+  }
+
+  // 根据运行时对象生成类型定义
+
+  generateTypeFromObject(val: any, typeName: string) {
+    // 4. 添加类型别名
+    this.sourceFile.addTypeAlias({
+      name: typeName,
+      // isExported: true,
+      type: inferType(val)
+    });
+  }
+  transform(res: any, typeName: string, isAsync = true) {
+
+    this.generateTypeFromObject(res, typeName)
+    return this.sourceFile.save();
+  }
+
+}

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+
+export function testHello() {
+  if (Math.random() > 0.5) throw new Error('test error')
+
+  return { hello: 'hello' };
+}
+
+let val = Array(10).fill(testHello())
+console.log('val', val)
+
+
+console.log('999', 123) 

package/tsconfig.json

@@ -0,0 +1,115 @@
+{
+	"exclude": [],
+	"include": ["src", "test", "test2/"],
+	"compilerOptions": {
+		/* Visit https://aka.ms/tsconfig to read more about this file */
+
+		/* Projects */
+		// "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+		// "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+		// "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+		// "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+		// "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+		// "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+		/* Language and Environment */
+		"target": "es2022" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+		// "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+		// "jsx": "preserve",                                /* Specify what JSX code is generated. */
+		// "libReplacement": true,                           /* Enable lib replacement. */
+		"experimentalDecorators": true /* Enable experimental support for legacy experimental decorators. */,
+		"emitDecoratorMetadata": true /* Emit design-type metadata for decorated declarations in source files. */,
+		// "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+		// "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+		// "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+		// "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+		// "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+		// "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+		// "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+		/* Modules */
+		"module": "esnext" /* Specify what module code is generated. */,
+		// "rootDir": "./",                                  /* Specify the root folder within your source files. */
+		"moduleResolution": "node" /* Specify how TypeScript looks up a file from a given module specifier. */,
+		// "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+		// "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+		// "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+		// "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+		// "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+		// "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+		// "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+		// "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+		// "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+		// "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+		// "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+		// "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+		// "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
+		// "resolveJsonModule": true,                        /* Enable importing .json files. */
+		// "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+		// "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+		/* JavaScript Support */
+		// "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+		// "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+		// "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+		/* Emit */
+		// "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+		// "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+		// "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+		// "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+		// "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+		// "noEmit": true,                                   /* Disable emitting files from a compilation. */
+		// "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+		// "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+		// "removeComments": true,                           /* Disable emitting comments. */
+		// "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+		// "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+		// "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+		// "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+		// "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+		// "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+		// "newLine": "crlf",                                /* Set the newline character for emitting files. */
+		// "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+		// "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+		// "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+		// "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+		// "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+		/* Interop Constraints */
+		// "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+		// "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+		// "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+		// "erasableSyntaxOnly": true,                       /* Do not allow runtime constructs that are not part of ECMAScript. */
+		// "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+		"esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+		// "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+		"forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+		/* Type Checking */
+		"strict": true /* Enable all strict type-checking options. */,
+		// "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+		// "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+		// "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+		// "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+		// "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+		// "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+		// "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+		// "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+		// "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+		// "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+		// "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+		// "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+		// "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+		// "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+		// "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+		// "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+		// "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+		// "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+		// "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+		/* Completeness */
+		// "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+		"skipLibCheck": true /* Skip type checking all .d.ts files. */
+	}
+}