projen 0.0.0

package/lib/javascript/typescript-config.d.ts

@@ -0,0 +1,424 @@
+import { NodeProject } from '.';
+import { JsonFile } from '../json';
+/**
+ * @experimental
+ */
+export interface TypescriptConfigOptions {
+    /**
+     * @default "tsconfig.json"
+     * @experimental
+     */
+    readonly fileName?: string;
+    /**
+     * (experimental) Specifies a list of glob patterns that match TypeScript files to be included in compilation.
+     *
+     * @default - all .ts files recursively
+     * @experimental
+     */
+    readonly include?: string[];
+    /**
+     * (experimental) Filters results from the "include" option.
+     *
+     * @default - node_modules is excluded by default
+     * @experimental
+     */
+    readonly exclude?: string[];
+    /**
+     * (experimental) Compiler options to use.
+     *
+     * @experimental
+     */
+    readonly compilerOptions: TypeScriptCompilerOptions;
+}
+/**
+ * (experimental) Determines how modules get resolved.
+ *
+ * @see https://www.typescriptlang.org/docs/handbook/module-resolution.html
+ * @experimental
+ */
+export declare enum TypeScriptModuleResolution {
+    /**
+     * (experimental) TypeScript's former default resolution strategy.
+     *
+     * @see https://www.typescriptlang.org/docs/handbook/module-resolution.html#classic
+     * @experimental
+     */
+    CLASSIC = "classic",
+    /**
+     * (experimental) Resolution strategy which attempts to mimic the Node.js module resolution strategy at runtime.
+     *
+     * @see https://www.typescriptlang.org/docs/handbook/module-resolution.html#node
+     * @experimental
+     */
+    NODE = "node"
+}
+/**
+ * (experimental) Determines how JSX should get transformed into valid JavaScript.
+ *
+ * @see https://www.typescriptlang.org/docs/handbook/jsx.html
+ * @experimental
+ */
+export declare enum TypeScriptJsxMode {
+    /**
+     * (experimental) Keeps the JSX as part of the output to be further consumed by another transform step (e.g. Babel).
+     *
+     * @experimental
+     */
+    PRESERVE = "preserve",
+    /**
+     * (experimental) Converts JSX syntax into React.createElement, does not need to go through a JSX transformation before use, and the output will have a .js file extension.
+     *
+     * @experimental
+     */
+    REACT = "react",
+    /**
+     * (experimental) Keeps all JSX like 'preserve' mode, but output will have a .js extension.
+     *
+     * @experimental
+     */
+    REACT_NATIVE = "react-native",
+    /**
+     * (experimental) Passes `key` separately from props and always passes `children` as props (since React 17).
+     *
+     * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-1.html#react-17-jsx-factories
+     * @experimental
+     */
+    REACT_JSX = "react-jsx",
+    /**
+     * (experimental) Same as `REACT_JSX` with additional debug data.
+     *
+     * @experimental
+     */
+    REACT_JSXDEV = "react-jsxdev"
+}
+/**
+ * @experimental
+ */
+export interface TypeScriptCompilerOptions {
+    /**
+     * (experimental) Allow JavaScript files to be compiled.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly allowJs?: boolean;
+    /**
+     * (experimental) Ensures that your files are parsed in the ECMAScript strict mode, and emit “use strict” for each source file.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly alwaysStrict?: boolean;
+    /**
+     * (experimental) Offers a way to configure the root directory for where declaration files are emitted.
+     *
+     * @experimental
+     */
+    readonly declarationDir?: string;
+    /**
+     * (experimental) To be specified along with the above.
+     *
+     * @experimental
+     */
+    readonly declaration?: boolean;
+    /**
+     * (experimental) Emit __importStar and __importDefault helpers for runtime babel ecosystem compatibility and enable --allowSyntheticDefaultImports for typesystem compatibility.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly esModuleInterop?: boolean;
+    /**
+     * (experimental) Enables experimental support for decorators, which is in stage 2 of the TC39 standardization process.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly experimentalDecorators?: boolean;
+    /**
+     * (experimental) Enables experimental support for decorators, which is in stage 2 of the TC39 standardization process.
+     *
+     * Decorators are a language feature which hasn’t yet been fully ratified into the JavaScript specification.
+     * This means that the implementation version in TypeScript may differ from the implementation in JavaScript when it it decided by TC39.
+     * You can find out more about decorator support in TypeScript in the handbook.
+     *
+     * @default undefined
+     * @see https://www.typescriptlang.org/docs/handbook/decorators.html
+     * @experimental
+     */
+    readonly emitDecoratorMetadata?: boolean;
+    /**
+     * (experimental) Disallow inconsistently-cased references to the same file.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly forceConsistentCasingInFileNames?: boolean;
+    /**
+     * (experimental) When set, instead of writing out a .js.map file to provide source maps, TypeScript will embed the source map content in the .js files.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly inlineSourceMap?: boolean;
+    /**
+     * (experimental) When set, TypeScript will include the original content of the .ts file as an embedded string in the source map. This is often useful in the same cases as inlineSourceMap.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly inlineSources?: boolean;
+    /**
+     * (experimental) Perform additional checks to ensure that separate compilation (such as with transpileModule or @babel/plugin-transform-typescript) would be safe.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly isolatedModules?: boolean;
+    /**
+     * (experimental) Support JSX in .tsx files: "react", "preserve", "react-native" etc.
+     *
+     * @default undefined
+     * @experimental
+     */
+    readonly jsx?: TypeScriptJsxMode;
+    /**
+     * (experimental) Reference for type definitions / libraries to use (eg.
+     *
+     * ES2016, ES5, ES2018).
+     *
+     * @default [ "es2018" ]
+     * @experimental
+     */
+    readonly lib?: string[];
+    /**
+     * (experimental) Sets the module system for the program.
+     *
+     * See https://www.typescriptlang.org/docs/handbook/modules.html#ambient-modules.
+     *
+     * @default "CommonJS"
+     * @experimental
+     */
+    readonly module?: string;
+    /**
+     * (experimental) Determine how modules get resolved.
+     *
+     * Either "Node" for Node.js/io.js style resolution, or "Classic".
+     *
+     * @default "node"
+     * @experimental
+     */
+    readonly moduleResolution?: TypeScriptModuleResolution;
+    /**
+     * (experimental) Do not emit outputs.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly noEmit?: boolean;
+    /**
+     * (experimental) Do not emit compiler output files like JavaScript source code, source-maps or declarations if any errors were reported.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noEmitOnError?: boolean;
+    /**
+     * (experimental) Report errors for fallthrough cases in switch statements.
+     *
+     * Ensures that any non-empty
+     * case inside a switch statement includes either break or return. This means you won’t
+     * accidentally ship a case fallthrough bug.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noFallthroughCasesInSwitch?: boolean;
+    /**
+     * (experimental) In some cases where no type annotations are present, TypeScript will fall back to a type of any for a variable when it cannot infer the type.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noImplicitAny?: boolean;
+    /**
+     * (experimental) When enabled, TypeScript will check all code paths in a function to ensure they return a value.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noImplicitReturns?: boolean;
+    /**
+     * (experimental) Raise error on ‘this’ expressions with an implied ‘any’ type.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noImplicitThis?: boolean;
+    /**
+     * (experimental) Raise error on use of the dot syntax to access fields which are not defined.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noPropertyAccessFromIndexSignature?: boolean;
+    /**
+     * (experimental) Raise error when accessing indexes on objects with unknown keys defined in index signatures.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noUncheckedIndexedAccess?: boolean;
+    /**
+     * (experimental) Report errors on unused local variables.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noUnusedLocals?: boolean;
+    /**
+     * (experimental) Report errors on unused parameters in functions.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly noUnusedParameters?: boolean;
+    /**
+     * (experimental) Allows importing modules with a ‘.json’ extension, which is a common practice in node projects. This includes generating a type for the import based on the static JSON shape.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly resolveJsonModule?: boolean;
+    /**
+     * (experimental) Skip type checking of all declaration files (*.d.ts).
+     *
+     * @default false
+     * @experimental
+     */
+    readonly skipLibCheck?: boolean;
+    /**
+     * (experimental) The strict flag enables a wide range of type checking behavior that results in stronger guarantees of program correctness.
+     *
+     * Turning this on is equivalent to enabling all of the strict mode family
+     * options, which are outlined below. You can then turn off individual strict mode family checks as
+     * needed.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly strict?: boolean;
+    /**
+     * (experimental) When strictNullChecks is false, null and undefined are effectively ignored by the language.
+     *
+     * This can lead to unexpected errors at runtime.
+     * When strictNullChecks is true, null and undefined have their own distinct types and you’ll
+     * get a type error if you try to use them where a concrete value is expected.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly strictNullChecks?: boolean;
+    /**
+     * (experimental) When set to true, TypeScript will raise an error when a class property was declared but not set in the constructor.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly strictPropertyInitialization?: boolean;
+    /**
+     * (experimental) Do not emit declarations for code that has an @internal annotation in it’s JSDoc comment.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly stripInternal?: boolean;
+    /**
+     * (experimental) Modern browsers support all ES6 features, so ES6 is a good choice.
+     *
+     * You might choose to set
+     * a lower target if your code is deployed to older environments, or a higher target if your
+     * code is guaranteed to run in newer environments.
+     *
+     * @default "ES2018"
+     * @experimental
+     */
+    readonly target?: string;
+    /**
+     * (experimental) Output directory for the compiled files.
+     *
+     * @experimental
+     */
+    readonly outDir?: string;
+    /**
+     * (experimental) Specifies the root directory of input files.
+     *
+     * Only use to control the output directory structure with `outDir`.
+     *
+     * @experimental
+     */
+    readonly rootDir?: string;
+    /**
+     * (experimental) Allow default imports from modules with no default export.
+     *
+     * This does not affect code emit, just typechecking.
+     *
+     * @experimental
+     */
+    readonly allowSyntheticDefaultImports?: boolean;
+    /**
+     * (experimental) Lets you set a base directory to resolve non-absolute module names.
+     *
+     * You can define a root folder where you can do absolute file resolution.
+     *
+     * @experimental
+     */
+    readonly baseUrl?: string;
+    /**
+     * (experimental) A series of entries which re-map imports to lookup locations relative to the baseUrl, there is a larger coverage of paths in the handbook.
+     *
+     * paths lets you declare how TypeScript should resolve an import in your require/imports.
+     *
+     * @experimental
+     */
+    readonly paths?: {
+        [key: string]: string[];
+    };
+}
+/**
+ * @experimental
+ */
+export declare class TypescriptConfig {
+    /**
+     * @experimental
+     */
+    readonly compilerOptions: TypeScriptCompilerOptions;
+    /**
+     * @experimental
+     */
+    readonly include: string[];
+    /**
+     * @experimental
+     */
+    readonly exclude: string[];
+    /**
+     * @experimental
+     */
+    readonly fileName: string;
+    /**
+     * @experimental
+     */
+    readonly file: JsonFile;
+    /**
+     * @experimental
+     */
+    constructor(project: NodeProject, options: TypescriptConfigOptions);
+    /**
+     * @experimental
+     */
+    addInclude(pattern: string): void;
+    /**
+     * @experimental
+     */
+    addExclude(pattern: string): void;
+}

package/lib/javascript/typescript-config.js

@@ -0,0 +1,71 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypescriptConfig = exports.TypeScriptJsxMode = exports.TypeScriptModuleResolution = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const json_1 = require("../json");
+/**
+ * (experimental) Determines how modules get resolved.
+ *
+ * @see https://www.typescriptlang.org/docs/handbook/module-resolution.html
+ * @experimental
+ */
+var TypeScriptModuleResolution;
+(function (TypeScriptModuleResolution) {
+    TypeScriptModuleResolution["CLASSIC"] = "classic";
+    TypeScriptModuleResolution["NODE"] = "node";
+})(TypeScriptModuleResolution = exports.TypeScriptModuleResolution || (exports.TypeScriptModuleResolution = {}));
+/**
+ * (experimental) Determines how JSX should get transformed into valid JavaScript.
+ *
+ * @see https://www.typescriptlang.org/docs/handbook/jsx.html
+ * @experimental
+ */
+var TypeScriptJsxMode;
+(function (TypeScriptJsxMode) {
+    TypeScriptJsxMode["PRESERVE"] = "preserve";
+    TypeScriptJsxMode["REACT"] = "react";
+    TypeScriptJsxMode["REACT_NATIVE"] = "react-native";
+    TypeScriptJsxMode["REACT_JSX"] = "react-jsx";
+    TypeScriptJsxMode["REACT_JSXDEV"] = "react-jsxdev";
+})(TypeScriptJsxMode = exports.TypeScriptJsxMode || (exports.TypeScriptJsxMode = {}));
+/**
+ * @experimental
+ */
+class TypescriptConfig {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        var _b, _c, _d, _e;
+        const fileName = (_b = options.fileName) !== null && _b !== void 0 ? _b : 'tsconfig.json';
+        this.include = (_c = options.include) !== null && _c !== void 0 ? _c : ['**/*.ts'];
+        this.exclude = (_d = options.exclude) !== null && _d !== void 0 ? _d : ['node_modules'];
+        this.fileName = fileName;
+        this.compilerOptions = options.compilerOptions;
+        this.file = new json_1.JsonFile(project, fileName, {
+            obj: {
+                compilerOptions: this.compilerOptions,
+                include: () => this.include,
+                exclude: () => this.exclude,
+            },
+        });
+        (_e = project.npmignore) === null || _e === void 0 ? void 0 : _e.exclude(`/${fileName}`);
+    }
+    /**
+     * @experimental
+     */
+    addInclude(pattern) {
+        this.include.push(pattern);
+    }
+    /**
+     * @experimental
+     */
+    addExclude(pattern) {
+        this.exclude.push(pattern);
+    }
+}
+exports.TypescriptConfig = TypescriptConfig;
+_a = JSII_RTTI_SYMBOL_1;
+TypescriptConfig[_a] = { fqn: "projen.javascript.TypescriptConfig", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript-config.js","sourceRoot":"","sources":["../../src/javascript/typescript-config.ts"],"names":[],"mappings":";;;;;AACA,kCAAmC;;;;;;;AAgBnC,IAAY,0BAMX;AAND,WAAY,0BAA0B;IAEpC,iDAAmB,CAAA;IAGnB,2CAAa,CAAA;AACf,CAAC,EANW,0BAA0B,GAA1B,kCAA0B,KAA1B,kCAA0B,QAMrC;;;;;;;AAGD,IAAY,iBAeX;AAfD,WAAY,iBAAiB;IAE3B,0CAAqB,CAAA;IAGrB,oCAAe,CAAA;IAGf,kDAA6B,CAAA;IAG7B,4CAAuB,CAAA;IAGvB,kDAA6B,CAAA;AAC/B,CAAC,EAfW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAe5B;;;;AAkHD,MAAa,gBAAgB;;;;IAO3B,YAAY,OAAoB,EAAE,OAAgC;;QAChE,MAAM,QAAQ,SAAG,OAAO,CAAC,QAAQ,mCAAI,eAAe,CAAC;QAErD,IAAI,CAAC,OAAO,SAAG,OAAO,CAAC,OAAO,mCAAI,CAAC,SAAS,CAAC,CAAC;QAC9C,IAAI,CAAC,OAAO,SAAG,OAAO,CAAC,OAAO,mCAAI,CAAC,cAAc,CAAC,CAAC;QACnD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAEzB,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;QAE/C,IAAI,CAAC,IAAI,GAAG,IAAI,eAAQ,CAAC,OAAO,EAAE,QAAQ,EAAE;YAC1C,GAAG,EAAE;gBACH,eAAe,EAAE,IAAI,CAAC,eAAe;gBACrC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO;gBAC3B,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO;aAC5B;SACF,CAAC,CAAC;QAEH,MAAA,OAAO,CAAC,SAAS,0CAAE,OAAO,CAAC,IAAI,QAAQ,EAAE,EAAE;IAC7C,CAAC;;;;IAEM,UAAU,CAAC,OAAe;QAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;;;;IAEM,UAAU,CAAC,OAAe;QAC/B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;;AAjCH,4CAkCC","sourcesContent":["import { NodeProject } from '.';\nimport { JsonFile } from '../json';\n\nexport interface TypescriptConfigOptions {\n                                         \n  readonly fileName?: string;\n                                                                                                                                                            \n  readonly include?: string[];\n\n                                                                                                                    \n  readonly exclude?: string[];\n\n                                         \n  readonly compilerOptions: TypeScriptCompilerOptions;\n}\n\n                                                                                                                              \nexport enum TypeScriptModuleResolution {\n                                                                                                                                                            \n  CLASSIC = 'classic',\n\n                                                                                                                                                                                                       \n  NODE = 'node'\n}\n\n                                                                                                                                            \nexport enum TypeScriptJsxMode {\n                                                                                                                   \n  PRESERVE = 'preserve',\n\n                                                                                                                                                                          \n  REACT = 'react',\n\n                                                                                          \n  REACT_NATIVE = 'react-native',\n\n                                                                                                                                                                                                                                \n  REACT_JSX = 'react-jsx',\n\n                                                                \n  REACT_JSXDEV = 'react-jsxdev',\n}\n\nexport interface TypeScriptCompilerOptions {\n                                                                                \n  readonly allowJs?: boolean;\n\n                                                                                                                                                           \n  readonly alwaysStrict?: boolean;\n\n                                                                                                           \n  readonly declarationDir?: string;\n\n                                                          \n  readonly declaration?: boolean;\n\n                                                                                                                                                                                                                   \n  readonly esModuleInterop?: boolean;\n\n                                                                                                                                              \n  readonly experimentalDecorators?: boolean;\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      \n  readonly emitDecoratorMetadata?: boolean;\n\n                                                                                                    \n  readonly forceConsistentCasingInFileNames?: boolean;\n\n                                                                                                                                                                                    \n  readonly inlineSourceMap?: boolean;\n\n                                                                                                                                                                                                                        \n  readonly inlineSources?: boolean;\n\n                                                                                                                                                                                                \n  readonly isolatedModules?: boolean;\n\n                                                                                                                 \n  readonly jsx?: TypeScriptJsxMode;\n\n                                                                                                                             \n  readonly lib?: string[];\n\n                                                                                                                                                                          \n  readonly module?: string;\n\n                                                                                                                                              \n  readonly moduleResolution?: TypeScriptModuleResolution;\n\n                                                              \n  readonly noEmit?: boolean;\n\n                                                                                                                                                                     \n  readonly noEmitOnError?: boolean;\n\n                                                                                                                                                                                                                                                                      \n  readonly noFallthroughCasesInSwitch?: boolean;\n\n                                                                                                                                                                                           \n  readonly noImplicitAny?: boolean;\n\n                                                                                                                                             \n  readonly noImplicitReturns?: boolean;\n                                                                                                      \n  readonly noImplicitThis?: boolean;\n\n                                                                                                                     \n  readonly noPropertyAccessFromIndexSignature?: boolean;\n\n                                                                                                                                     \n  readonly noUncheckedIndexedAccess?: boolean;\n\n                                                                                 \n  readonly noUnusedLocals?: boolean;\n\n                                                                                         \n  readonly noUnusedParameters?: boolean;\n\n                                                                                                                                                                                                                            \n  readonly resolveJsonModule?: boolean;\n\n                                                                                               \n  readonly skipLibCheck?: boolean;\n\n                                                                                                                                                                                                                                                                                                                                                                   \n  readonly strict?: boolean;\n\n                                                                                                                                                                                                                                                                                                                                                                         \n  readonly strictNullChecks?: boolean;\n\n                                                                                                                                                                 \n  readonly strictPropertyInitialization?: boolean;\n\n                                                                                                                                  \n  readonly stripInternal?: boolean;\n\n                                                                                                                                                                                                                                                                                            \n  readonly target?: string;\n\n                                                         \n  readonly outDir?: string;\n\n                                                                                                                                         \n  readonly rootDir?: string;\n\n                                                                                                                              \n  readonly allowSyntheticDefaultImports?: boolean;\n\n                                                                                                                                                                      \n  readonly baseUrl?: string;\n\n                                                                                                                                                                                                                                                            \n  readonly paths?: { [key: string]: string[] };\n}\n\nexport class TypescriptConfig {\n  public readonly compilerOptions: TypeScriptCompilerOptions;\n  public readonly include: string[];\n  public readonly exclude: string[];\n  public readonly fileName: string;\n  public readonly file: JsonFile;\n\n  constructor(project: NodeProject, options: TypescriptConfigOptions) {\n    const fileName = options.fileName ?? 'tsconfig.json';\n\n    this.include = options.include ?? ['**/*.ts'];\n    this.exclude = options.exclude ?? ['node_modules'];\n    this.fileName = fileName;\n\n    this.compilerOptions = options.compilerOptions;\n\n    this.file = new JsonFile(project, fileName, {\n      obj: {\n        compilerOptions: this.compilerOptions,\n        include: () => this.include,\n        exclude: () => this.exclude,\n      },\n    });\n\n    project.npmignore?.exclude(`/${fileName}`);\n  }\n\n  public addInclude(pattern: string) {\n    this.include.push(pattern);\n  }\n\n  public addExclude(pattern: string) {\n    this.exclude.push(pattern);\n  }\n}\n"]}