projen 0.0.0

package/lib/typescript/typescript.js

@@ -0,0 +1,287 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeTsconfigOptions = exports.TypeScriptLibraryProject = exports.TypeScriptAppProject = exports.TypeScriptProject = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const semver = require("semver");
+const common_1 = require("../common");
+const component_1 = require("../component");
+const javascript_1 = require("../javascript");
+const sample_file_1 = require("../sample-file");
+const textfile_1 = require("../textfile");
+const typescript_1 = require("../typescript");
+/**
+ * (experimental) TypeScript project.
+ *
+ * @experimental
+ * @pjid typescript
+ */
+class TypeScriptProject extends javascript_1.NodeProject {
+    /**
+     * @experimental
+     */
+    constructor(options) {
+        var _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+        super({
+            ...options,
+            // disable .projenrc.js if typescript is enabled
+            projenrcJs: options.projenrcTs ? false : options.projenrcJs,
+            jestOptions: {
+                ...options.jestOptions,
+                jestConfig: {
+                    ...(_d = options.jestOptions) === null || _d === void 0 ? void 0 : _d.jestConfig,
+                    testMatch: [],
+                },
+            },
+        });
+        this.srcdir = (_e = options.srcdir) !== null && _e !== void 0 ? _e : 'src';
+        this.libdir = (_f = options.libdir) !== null && _f !== void 0 ? _f : 'lib';
+        this.docgen = options.docgen;
+        this.docsDirectory = (_g = options.docsDirectory) !== null && _g !== void 0 ? _g : 'docs/';
+        this.compileTask.exec('tsc --build');
+        this.watchTask = this.addTask('watch', {
+            description: 'Watch & compile in the background',
+            exec: 'tsc --build -w',
+        });
+        this.testdir = (_h = options.testdir) !== null && _h !== void 0 ? _h : 'test';
+        this.gitignore.include(`/${this.testdir}/`);
+        (_j = this.npmignore) === null || _j === void 0 ? void 0 : _j.exclude(`/${this.testdir}/`);
+        // if the test directory is under `src/`, then we will run our tests against
+        // the javascript files and not let jest compile it for us.
+        const compiledTests = this.testdir.startsWith(this.srcdir + path.posix.sep);
+        if (options.entrypointTypes || this.entrypoint !== '') {
+            const entrypointTypes = (_k = options.entrypointTypes) !== null && _k !== void 0 ? _k : `${path.join(path.dirname(this.entrypoint), path.basename(this.entrypoint, '.js')).replace(/\\/g, '/')}.d.ts`;
+            this.package.addField('types', entrypointTypes);
+        }
+        const compilerOptionDefaults = {
+            alwaysStrict: true,
+            declaration: true,
+            esModuleInterop: true,
+            experimentalDecorators: true,
+            inlineSourceMap: true,
+            inlineSources: true,
+            lib: ['es2019'],
+            module: 'CommonJS',
+            noEmitOnError: false,
+            noFallthroughCasesInSwitch: true,
+            noImplicitAny: true,
+            noImplicitReturns: true,
+            noImplicitThis: true,
+            noUnusedLocals: true,
+            noUnusedParameters: true,
+            resolveJsonModule: true,
+            strict: true,
+            strictNullChecks: true,
+            strictPropertyInitialization: true,
+            stripInternal: true,
+            target: 'ES2019',
+        };
+        if (!options.disableTsconfig) {
+            this.tsconfig = new javascript_1.TypescriptConfig(this, mergeTsconfigOptions({
+                include: [`${this.srcdir}/**/*.ts`],
+                // exclude: ['node_modules'], // TODO: shouldn't we exclude node_modules?
+                compilerOptions: {
+                    rootDir: this.srcdir,
+                    outDir: this.libdir,
+                    ...compilerOptionDefaults,
+                },
+            }, options.tsconfig));
+        }
+        const tsconfigDevFile = (_l = options.tsconfigDevFile) !== null && _l !== void 0 ? _l : 'tsconfig.dev.json';
+        this.tsconfigDev = new javascript_1.TypescriptConfig(this, mergeTsconfigOptions({
+            fileName: tsconfigDevFile,
+            include: [
+                common_1.PROJEN_RC,
+                `${this.srcdir}/**/*.ts`,
+                `${this.testdir}/**/*.ts`,
+            ],
+            exclude: ['node_modules'],
+            compilerOptions: compilerOptionDefaults,
+        }, options.tsconfig, options.tsconfigDev));
+        this.gitignore.include(`/${this.srcdir}/`);
+        (_m = this.npmignore) === null || _m === void 0 ? void 0 : _m.exclude(`/${this.srcdir}/`);
+        if (this.srcdir !== this.libdir) {
+            // separated, can ignore the entire libdir
+            this.gitignore.exclude(`/${this.libdir}`);
+        }
+        else {
+            // collocated, can only ignore the compiled output
+            this.gitignore.exclude(`/${this.libdir}/**/*.js`);
+            this.gitignore.exclude(`/${this.libdir}/**/*.d.ts`);
+        }
+        (_o = this.npmignore) === null || _o === void 0 ? void 0 : _o.include(`/${this.libdir}/`);
+        (_p = this.npmignore) === null || _p === void 0 ? void 0 : _p.include(`/${this.libdir}/**/*.js`);
+        (_q = this.npmignore) === null || _q === void 0 ? void 0 : _q.include(`/${this.libdir}/**/*.d.ts`);
+        this.gitignore.exclude('/dist/');
+        (_r = this.npmignore) === null || _r === void 0 ? void 0 : _r.exclude('dist'); // jsii-pacmak expects this to be "dist" and not "/dist". otherwise it will tamper with it
+        (_s = this.npmignore) === null || _s === void 0 ? void 0 : _s.exclude('/tsconfig.json');
+        (_t = this.npmignore) === null || _t === void 0 ? void 0 : _t.exclude('/.github/');
+        (_u = this.npmignore) === null || _u === void 0 ? void 0 : _u.exclude('/.vscode/');
+        (_v = this.npmignore) === null || _v === void 0 ? void 0 : _v.exclude('/.idea/');
+        (_w = this.npmignore) === null || _w === void 0 ? void 0 : _w.exclude('/.projenrc.js');
+        (_x = this.npmignore) === null || _x === void 0 ? void 0 : _x.exclude('tsconfig.tsbuildinfo');
+        // tests are compiled to `lib/TESTDIR`, so we don't need jest to compile them for us.
+        // just run them directly from javascript.
+        if (this.jest && compiledTests) {
+            this.addDevDeps('@types/jest');
+            const testout = path.posix.relative(this.srcdir, this.testdir);
+            const libtest = path.posix.join(this.libdir, testout);
+            const srctest = this.testdir;
+            (_y = this.npmignore) === null || _y === void 0 ? void 0 : _y.exclude(`/${libtest}/`);
+            this.jest.addTestMatch(`**/${libtest}/**/?(*.)+(spec|test).js?(x)`);
+            this.jest.addWatchIgnorePattern(`/${this.srcdir}/`);
+            const resolveSnapshotPath = (test, ext) => {
+                const fullpath = test.replace(libtest, srctest);
+                return path.join(path.dirname(fullpath), '__snapshots__', path.basename(fullpath, '.js') + '.ts' + ext);
+            };
+            const resolveTestPath = (snap, ext) => {
+                const filename = path.basename(snap, '.ts' + ext) + '.js';
+                const dir = path.dirname(path.dirname(snap)).replace(srctest, libtest);
+                return path.join(dir, filename);
+            };
+            const resolver = new textfile_1.TextFile(this, path.posix.join(common_1.PROJEN_DIR, 'jest-snapshot-resolver.js'));
+            resolver.addLine(`// ${textfile_1.TextFile.PROJEN_MARKER}`);
+            resolver.addLine('const path = require("path");');
+            resolver.addLine(`const libtest = "${libtest}";`);
+            resolver.addLine(`const srctest= "${srctest}";`);
+            resolver.addLine('module.exports = {');
+            resolver.addLine(`  resolveSnapshotPath: ${resolveSnapshotPath.toString()},`);
+            resolver.addLine(`  resolveTestPath: ${resolveTestPath.toString()},`);
+            resolver.addLine('  testPathForConsistencyCheck: path.join(\'some\', \'__tests__\', \'example.test.js\')');
+            resolver.addLine('};');
+            this.jest.addSnapshotResolver(`./${resolver.path}`);
+        }
+        if (this.jest && !compiledTests) {
+            this.jest.addTestMatch('**\/__tests__/**\/*.ts?(x)');
+            this.jest.addTestMatch('**\/?(*.)+(spec|test).ts?(x)');
+            // create a tsconfig for jest that does NOT include outDir and rootDir and
+            // includes both "src" and "test" as inputs.
+            this.jest.addTypeScriptSupport(this.tsconfigDev);
+        }
+        if ((_z = options.eslint) !== null && _z !== void 0 ? _z : true) {
+            this.eslint = new javascript_1.Eslint(this, {
+                tsconfigPath: `./${this.tsconfigDev.fileName}`,
+                dirs: [this.srcdir],
+                devdirs: [this.testdir, 'build-tools'],
+                fileExtensions: ['.ts', '.tsx'],
+                ...options.eslintOptions,
+            });
+            this.tsconfigEslint = this.tsconfigDev;
+        }
+        const tsver = options.typescriptVersion ? `@${options.typescriptVersion}` : '';
+        this.addDevDeps(`typescript${tsver}`, 
+        // @types/node versions numbers match the node runtime versions' major.minor, however, new
+        // releases are only created when API changes are included in a node release... We might for
+        // example have dependencies that require `node >= 12.22`, but as 12.21 and 12.22 did not
+        // include API changes, `@types/node@12.20.x` is the "correct" version to use. As it is not
+        // possible to easily determine the correct version to use, we pick up the latest version.
+        //
+        // Additionally, we default to tracking the 12.x line, as the current earliest LTS release of
+        // node is 12.x, so this is what corresponds to the broadest compatibility with supported node
+        // runtimes.
+        `@types/node@^${semver.major((_0 = this.package.minNodeVersion) !== null && _0 !== void 0 ? _0 : '12.0.0')}`);
+        // generate sample code in `src` and `lib` if these directories are empty or non-existent.
+        if ((_1 = options.sampleCode) !== null && _1 !== void 0 ? _1 : true) {
+            new SampleCode(this);
+        }
+        if (this.docgen) {
+            new typescript_1.TypedocDocgen(this);
+        }
+        const projenrcTypeScript = (_2 = options.projenrcTs) !== null && _2 !== void 0 ? _2 : false;
+        if (projenrcTypeScript) {
+            new typescript_1.Projenrc(this, options.projenrcTsOptions);
+        }
+    }
+}
+exports.TypeScriptProject = TypeScriptProject;
+_a = JSII_RTTI_SYMBOL_1;
+TypeScriptProject[_a] = { fqn: "projen.typescript.TypeScriptProject", version: "0.46.8" };
+class SampleCode extends component_1.Component {
+    constructor(project) {
+        super(project);
+        const srcCode = [
+            'export class Hello {',
+            '  public sayHello() {',
+            '    return \'hello, world!\';',
+            '  }',
+            '}',
+        ].join('\n');
+        const testCode = [
+            "import { Hello } from '../src';",
+            '',
+            "test('hello', () => {",
+            "  expect(new Hello().sayHello()).toBe('hello, world!');",
+            '});',
+        ].join('\n');
+        new sample_file_1.SampleDir(project, project.srcdir, {
+            files: {
+                'index.ts': srcCode,
+            },
+        });
+        new sample_file_1.SampleDir(project, project.testdir, {
+            files: {
+                'hello.test.ts': testCode,
+            },
+        });
+    }
+}
+/**
+ * (experimental) TypeScript app.
+ *
+ * @experimental
+ * @pjid typescript-app
+ */
+class TypeScriptAppProject extends TypeScriptProject {
+    /**
+     * @experimental
+     */
+    constructor(options) {
+        super({
+            allowLibraryDependencies: false,
+            releaseWorkflow: false,
+            entrypoint: '',
+            package: false,
+            ...options,
+        });
+    }
+}
+exports.TypeScriptAppProject = TypeScriptAppProject;
+_b = JSII_RTTI_SYMBOL_1;
+TypeScriptAppProject[_b] = { fqn: "projen.typescript.TypeScriptAppProject", version: "0.46.8" };
+/**
+ * @deprecated use `TypeScriptProject`
+ */
+class TypeScriptLibraryProject extends TypeScriptProject {
+}
+exports.TypeScriptLibraryProject = TypeScriptLibraryProject;
+_c = JSII_RTTI_SYMBOL_1;
+TypeScriptLibraryProject[_c] = { fqn: "projen.typescript.TypeScriptLibraryProject", version: "0.46.8" };
+;
+/**
+ * @internal
+ */
+function mergeTsconfigOptions(...options) {
+    const definedOptions = options.filter(Boolean);
+    return definedOptions.reduce((previous, current) => {
+        var _d, _e, _f, _g;
+        return ({
+            ...previous,
+            ...current,
+            include: [
+                ...(_d = previous.include) !== null && _d !== void 0 ? _d : [],
+                ...(_e = current.include) !== null && _e !== void 0 ? _e : [],
+            ],
+            exclude: [
+                ...(_f = previous.exclude) !== null && _f !== void 0 ? _f : [],
+                ...(_g = current.exclude) !== null && _g !== void 0 ? _g : [],
+            ],
+            compilerOptions: {
+                ...previous.compilerOptions,
+                ...current.compilerOptions,
+            },
+        });
+    }, { compilerOptions: {} });
+}
+exports.mergeTsconfigOptions = mergeTsconfigOptions;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript.js","sourceRoot":"","sources":["../../src/typescript/typescript.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as semver from 'semver';\nimport { PROJEN_DIR, PROJEN_RC } from '../common';\nimport { Component } from '../component';\nimport { Eslint, EslintOptions, NodeProject, NodeProjectOptions, TypeScriptCompilerOptions, TypescriptConfig, TypescriptConfigOptions } from '../javascript';\nimport { SampleDir } from '../sample-file';\nimport { Task } from '../task';\nimport { TextFile } from '../textfile';\nimport { Projenrc as ProjenrcTs, ProjenrcOptions as ProjenrcTsOptions, TypedocDocgen } from '../typescript';\n\nexport interface TypeScriptProjectOptions extends NodeProjectOptions {\n                                                                                \n  readonly libdir?: string;\n\n                                                                       \n  readonly srcdir?: string;\n\n                                                                                                                                                                                                                                                                                                                                                                                         \n  readonly testdir?: string;\n\n                                                      \n  readonly eslint?: boolean;\n\n                                                                           \n  readonly eslintOptions?: EslintOptions;\n\n                                                                                                                                                                                                                                  \n  readonly typescriptVersion?: string;\n\n                                                           \n  readonly docgen?: boolean;\n\n                                                         \n  readonly docsDirectory?: string;\n\n                                                                \n  readonly tsconfig?: TypescriptConfigOptions;\n\n                                                                                                                                                       \n  readonly tsconfigDev?: TypescriptConfigOptions;\n\n                                                                                                       \n  readonly tsconfigDevFile?: string;\n\n                                                                                                                                                                    \n  readonly disableTsconfig?: boolean;\n\n                                                                                                               \n  readonly sampleCode?: boolean;\n\n                                                                                                                                                                              \n  readonly entrypointTypes?: string;\n\n                                                                                                 \n  readonly projenrcTs?: boolean;\n\n                                         \n  readonly projenrcTsOptions?: ProjenrcTsOptions;\n}\n\n                                                 \nexport class TypeScriptProject extends NodeProject {\n  public readonly docgen?: boolean;\n  public readonly docsDirectory: string;\n  public readonly eslint?: Eslint;\n  public readonly tsconfigEslint?: TypescriptConfig;\n  public readonly tsconfig?: TypescriptConfig;\n\n                                                                                                 \n  public readonly tsconfigDev: TypescriptConfig;\n\n                                                               \n  public readonly srcdir: string;\n\n                                                                  \n  public readonly libdir: string;\n\n                                                     \n  public readonly testdir: string;\n\n                                  \n  public readonly watchTask: Task;\n\n  constructor(options: TypeScriptProjectOptions) {\n    super({\n      ...options,\n\n      // disable .projenrc.js if typescript is enabled\n      projenrcJs: options.projenrcTs ? false : options.projenrcJs,\n\n      jestOptions: {\n        ...options.jestOptions,\n        jestConfig: {\n          ...options.jestOptions?.jestConfig,\n          testMatch: [],\n        },\n      },\n    });\n\n    this.srcdir = options.srcdir ?? 'src';\n    this.libdir = options.libdir ?? 'lib';\n\n    this.docgen = options.docgen;\n    this.docsDirectory = options.docsDirectory ?? 'docs/';\n\n    this.compileTask.exec('tsc --build');\n\n    this.watchTask = this.addTask('watch', {\n      description: 'Watch & compile in the background',\n      exec: 'tsc --build -w',\n    });\n\n    this.testdir = options.testdir ?? 'test';\n    this.gitignore.include(`/${this.testdir}/`);\n    this.npmignore?.exclude(`/${this.testdir}/`);\n\n    // if the test directory is under `src/`, then we will run our tests against\n    // the javascript files and not let jest compile it for us.\n    const compiledTests = this.testdir.startsWith(this.srcdir + path.posix.sep);\n\n\n    if (options.entrypointTypes || this.entrypoint !== '') {\n      const entrypointTypes = options.entrypointTypes ?? `${path.join(path.dirname(this.entrypoint), path.basename(this.entrypoint, '.js')).replace(/\\\\/g, '/')}.d.ts`;\n      this.package.addField('types', entrypointTypes);\n    }\n\n    const compilerOptionDefaults: TypeScriptCompilerOptions = {\n      alwaysStrict: true,\n      declaration: true,\n      esModuleInterop: true,\n      experimentalDecorators: true,\n      inlineSourceMap: true,\n      inlineSources: true,\n      lib: ['es2019'],\n      module: 'CommonJS',\n      noEmitOnError: false,\n      noFallthroughCasesInSwitch: true,\n      noImplicitAny: true,\n      noImplicitReturns: true,\n      noImplicitThis: true,\n      noUnusedLocals: true,\n      noUnusedParameters: true,\n      resolveJsonModule: true,\n      strict: true,\n      strictNullChecks: true,\n      strictPropertyInitialization: true,\n      stripInternal: true,\n      target: 'ES2019',\n    };\n\n    if (!options.disableTsconfig) {\n      this.tsconfig = new TypescriptConfig(this, mergeTsconfigOptions({\n        include: [`${this.srcdir}/**/*.ts`],\n        // exclude: ['node_modules'], // TODO: shouldn't we exclude node_modules?\n        compilerOptions: {\n          rootDir: this.srcdir,\n          outDir: this.libdir,\n          ...compilerOptionDefaults,\n        },\n      }, options.tsconfig));\n    }\n\n    const tsconfigDevFile = options.tsconfigDevFile ?? 'tsconfig.dev.json';\n    this.tsconfigDev = new TypescriptConfig(this, mergeTsconfigOptions({\n      fileName: tsconfigDevFile,\n      include: [\n        PROJEN_RC,\n        `${this.srcdir}/**/*.ts`,\n        `${this.testdir}/**/*.ts`,\n      ],\n      exclude: ['node_modules'],\n      compilerOptions: compilerOptionDefaults,\n    }, options.tsconfig, options.tsconfigDev));\n\n    this.gitignore.include(`/${this.srcdir}/`);\n    this.npmignore?.exclude(`/${this.srcdir}/`);\n\n    if (this.srcdir !== this.libdir) {\n      // separated, can ignore the entire libdir\n      this.gitignore.exclude(`/${this.libdir}`);\n    } else {\n      // collocated, can only ignore the compiled output\n      this.gitignore.exclude(`/${this.libdir}/**/*.js`);\n      this.gitignore.exclude(`/${this.libdir}/**/*.d.ts`);\n    }\n\n    this.npmignore?.include(`/${this.libdir}/`);\n\n    this.npmignore?.include(`/${this.libdir}/**/*.js`);\n    this.npmignore?.include(`/${this.libdir}/**/*.d.ts`);\n\n    this.gitignore.exclude('/dist/');\n    this.npmignore?.exclude('dist'); // jsii-pacmak expects this to be \"dist\" and not \"/dist\". otherwise it will tamper with it\n\n    this.npmignore?.exclude('/tsconfig.json');\n    this.npmignore?.exclude('/.github/');\n    this.npmignore?.exclude('/.vscode/');\n    this.npmignore?.exclude('/.idea/');\n    this.npmignore?.exclude('/.projenrc.js');\n    this.npmignore?.exclude('tsconfig.tsbuildinfo');\n\n    // tests are compiled to `lib/TESTDIR`, so we don't need jest to compile them for us.\n    // just run them directly from javascript.\n    if (this.jest && compiledTests) {\n      this.addDevDeps('@types/jest');\n\n      const testout = path.posix.relative(this.srcdir, this.testdir);\n      const libtest = path.posix.join(this.libdir, testout);\n      const srctest = this.testdir;\n\n      this.npmignore?.exclude(`/${libtest}/`);\n      this.jest.addTestMatch(`**/${libtest}/**/?(*.)+(spec|test).js?(x)`);\n      this.jest.addWatchIgnorePattern(`/${this.srcdir}/`);\n\n      const resolveSnapshotPath = (test: string, ext: string) => {\n        const fullpath = test.replace(libtest, srctest);\n        return path.join(path.dirname(fullpath), '__snapshots__', path.basename(fullpath, '.js') + '.ts' + ext);\n      };\n\n      const resolveTestPath = (snap: string, ext: string) => {\n        const filename = path.basename(snap, '.ts' + ext) + '.js';\n        const dir = path.dirname(path.dirname(snap)).replace(srctest, libtest);\n        return path.join(dir, filename);\n      };\n\n      const resolver = new TextFile(this, path.posix.join(PROJEN_DIR, 'jest-snapshot-resolver.js'));\n      resolver.addLine(`// ${TextFile.PROJEN_MARKER}`);\n      resolver.addLine('const path = require(\"path\");');\n      resolver.addLine(`const libtest = \"${libtest}\";`);\n      resolver.addLine(`const srctest= \"${srctest}\";`);\n      resolver.addLine('module.exports = {');\n      resolver.addLine(`  resolveSnapshotPath: ${resolveSnapshotPath.toString()},`);\n      resolver.addLine(`  resolveTestPath: ${resolveTestPath.toString()},`);\n      resolver.addLine('  testPathForConsistencyCheck: path.join(\\'some\\', \\'__tests__\\', \\'example.test.js\\')');\n      resolver.addLine('};');\n\n      this.jest.addSnapshotResolver(`./${resolver.path}`);\n    }\n\n    if (this.jest && !compiledTests) {\n      this.jest.addTestMatch('**\\/__tests__/**\\/*.ts?(x)');\n      this.jest.addTestMatch('**\\/?(*.)+(spec|test).ts?(x)');\n\n      // create a tsconfig for jest that does NOT include outDir and rootDir and\n      // includes both \"src\" and \"test\" as inputs.\n      this.jest.addTypeScriptSupport(this.tsconfigDev);\n    }\n\n    if (options.eslint ?? true) {\n      this.eslint = new Eslint(this, {\n        tsconfigPath: `./${this.tsconfigDev.fileName}`,\n        dirs: [this.srcdir],\n        devdirs: [this.testdir, 'build-tools'],\n        fileExtensions: ['.ts', '.tsx'],\n        ...options.eslintOptions,\n      });\n\n      this.tsconfigEslint = this.tsconfigDev;\n    }\n\n    const tsver = options.typescriptVersion ? `@${options.typescriptVersion}` : '';\n\n    this.addDevDeps(\n      `typescript${tsver}`,\n      // @types/node versions numbers match the node runtime versions' major.minor, however, new\n      // releases are only created when API changes are included in a node release... We might for\n      // example have dependencies that require `node >= 12.22`, but as 12.21 and 12.22 did not\n      // include API changes, `@types/node@12.20.x` is the \"correct\" version to use. As it is not\n      // possible to easily determine the correct version to use, we pick up the latest version.\n      //\n      // Additionally, we default to tracking the 12.x line, as the current earliest LTS release of\n      // node is 12.x, so this is what corresponds to the broadest compatibility with supported node\n      // runtimes.\n      `@types/node@^${semver.major(this.package.minNodeVersion ?? '12.0.0')}`,\n    );\n\n    // generate sample code in `src` and `lib` if these directories are empty or non-existent.\n    if (options.sampleCode ?? true) {\n      new SampleCode(this);\n    }\n\n    if (this.docgen) {\n      new TypedocDocgen(this);\n    }\n\n    const projenrcTypeScript = options.projenrcTs ?? false;\n    if (projenrcTypeScript) {\n      new ProjenrcTs(this, options.projenrcTsOptions);\n    }\n  }\n}\n\nclass SampleCode extends Component {\n  constructor(project: TypeScriptProject) {\n    super(project);\n    const srcCode = [\n      'export class Hello {',\n      '  public sayHello() {',\n      '    return \\'hello, world!\\';',\n      '  }',\n      '}',\n    ].join('\\n');\n\n    const testCode = [\n      \"import { Hello } from '../src';\",\n      '',\n      \"test('hello', () => {\",\n      \"  expect(new Hello().sayHello()).toBe('hello, world!');\",\n      '});',\n    ].join('\\n');\n\n    new SampleDir(project, project.srcdir, {\n      files: {\n        'index.ts': srcCode,\n      },\n    });\n\n    new SampleDir(project, project.testdir, {\n      files: {\n        'hello.test.ts': testCode,\n      },\n    });\n  }\n}\n\n                                                     \nexport class TypeScriptAppProject extends TypeScriptProject {\n  constructor(options: TypeScriptProjectOptions) {\n    super({\n      allowLibraryDependencies: false,\n      releaseWorkflow: false,\n      entrypoint: '', // \"main\" is not needed in typescript apps\n      package: false,\n      ...options,\n    });\n  }\n}\n\n                                              \nexport class TypeScriptLibraryProject extends TypeScriptProject {\n};\n\n                                                   \nexport interface TypeScriptLibraryProjectOptions extends TypeScriptProjectOptions {\n}\n\n/**\n * @internal\n */\nexport function mergeTsconfigOptions(...options: (TypescriptConfigOptions | undefined)[]): TypescriptConfigOptions {\n  const definedOptions = options.filter(Boolean) as TypescriptConfigOptions[];\n  return definedOptions.reduce<TypescriptConfigOptions>((previous, current) => ({\n    ...previous,\n    ...current,\n    include: [\n      ...previous.include ?? [],\n      ...current.include ?? [],\n    ],\n    exclude: [\n      ...previous.exclude ?? [],\n      ...current.exclude ?? [],\n    ],\n    compilerOptions: {\n      ...previous.compilerOptions,\n      ...current.compilerOptions,\n    },\n  }), { compilerOptions: {} });\n}\n"]}

package/lib/util/semver.d.ts

@@ -0,0 +1,43 @@
+export declare enum TargetName {
+    JAVA = 0,
+    DOTNET = 1,
+    PYTHON = 2,
+    GO = 3,
+    JAVASCRIPT = 4
+}
+/**
+ * Converts a SemVer range expression to a Maven version range expression.
+ *
+ * @param semverRange the SemVer range expression to convert.
+ * @param suffix      the suffix to add to versions in the range.
+ *
+ * @see https://cwiki.apache.org/confluence/display/MAVENOLD/Dependency+Mediation+and+Conflict+Resolution
+ */
+export declare function toMavenVersionRange(semverRange: string, suffix?: string): string;
+/**
+ * Converts a SemVer range expression to a NuGet version range expression.
+ *
+ * @param semverRange the SemVer range expression to convert.
+ *
+ * @see https://docs.microsoft.com/en-us/nuget/concepts/package-versioning#version-ranges-and-wildcards
+ */
+export declare function toNuGetVersionRange(semverRange: string): string;
+/**
+ * Converts a SemVer range expression to a Python setuptools compatible version
+ * constraint expression.
+ *
+ * @param semverRange the SemVer range expression to convert.
+ */
+export declare function toPythonVersionRange(semverRange: string): string;
+/**
+ * Converts an original version number from the NPM convention to the target
+ * language's convention for expressing the same. For versions that do not
+ * include a prerelease identifier, this always returns the assembly version
+ * unmodified.
+ *
+ * @param assemblyVersion the assembly version being released
+ * @param target          the target language for which the version is destined
+ *
+ * @returns the version that should be serialized
+ */
+export declare function toReleaseVersion(assemblyVersion: string, target: TargetName): string;

package/lib/util/semver.js

@@ -0,0 +1,210 @@
+"use strict";
+// stolen from: https://github.com/aws/jsii/blob/main/packages/jsii-pacmak/lib/targets/version-utils.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toReleaseVersion = exports.toPythonVersionRange = exports.toNuGetVersionRange = exports.toMavenVersionRange = exports.TargetName = void 0;
+const util_1 = require("util");
+const semver_1 = require("semver");
+var TargetName;
+(function (TargetName) {
+    TargetName[TargetName["JAVA"] = 0] = "JAVA";
+    TargetName[TargetName["DOTNET"] = 1] = "DOTNET";
+    TargetName[TargetName["PYTHON"] = 2] = "PYTHON";
+    TargetName[TargetName["GO"] = 3] = "GO";
+    TargetName[TargetName["JAVASCRIPT"] = 4] = "JAVASCRIPT";
+})(TargetName = exports.TargetName || (exports.TargetName = {}));
+/**
+ * Converts a SemVer range expression to a Maven version range expression.
+ *
+ * @param semverRange the SemVer range expression to convert.
+ * @param suffix      the suffix to add to versions in the range.
+ *
+ * @see https://cwiki.apache.org/confluence/display/MAVENOLD/Dependency+Mediation+and+Conflict+Resolution
+ */
+function toMavenVersionRange(semverRange, suffix) {
+    return toBracketNotation(semverRange, suffix, {
+        semver: false,
+        target: TargetName.JAVA,
+    });
+}
+exports.toMavenVersionRange = toMavenVersionRange;
+/**
+ * Converts a SemVer range expression to a NuGet version range expression.
+ *
+ * @param semverRange the SemVer range expression to convert.
+ *
+ * @see https://docs.microsoft.com/en-us/nuget/concepts/package-versioning#version-ranges-and-wildcards
+ */
+function toNuGetVersionRange(semverRange) {
+    return toBracketNotation(semverRange, undefined, {
+        semver: false,
+        target: TargetName.DOTNET,
+    });
+}
+exports.toNuGetVersionRange = toNuGetVersionRange;
+/**
+ * Converts a SemVer range expression to a Python setuptools compatible version
+ * constraint expression.
+ *
+ * @param semverRange the SemVer range expression to convert.
+ */
+function toPythonVersionRange(semverRange) {
+    const range = new semver_1.Range(semverRange);
+    return range.set
+        .map((set) => set
+        .map((comp) => {
+        var _a, _b;
+        const versionId = toReleaseVersion((_b = (_a = comp.semver.raw) === null || _a === void 0 ? void 0 : _a.replace(/-0$/, '')) !== null && _b !== void 0 ? _b : '0.0.0', TargetName.PYTHON);
+        switch (comp.operator) {
+            case '':
+                // With ^0.0.0, somehow we get a left entry with an empty operator and value, we'll fix this up
+                return comp.value === '' ? '>=0.0.0' : `==${versionId}`;
+            case '=':
+                return `==${versionId}`;
+            default:
+                // >, >=, <, <= are all valid expressions
+                return `${comp.operator}${versionId}`;
+        }
+    })
+        .join(', '))
+        .join(', ');
+}
+exports.toPythonVersionRange = toPythonVersionRange;
+/**
+ * Converts an original version number from the NPM convention to the target
+ * language's convention for expressing the same. For versions that do not
+ * include a prerelease identifier, this always returns the assembly version
+ * unmodified.
+ *
+ * @param assemblyVersion the assembly version being released
+ * @param target          the target language for which the version is destined
+ *
+ * @returns the version that should be serialized
+ */
+function toReleaseVersion(assemblyVersion, target) {
+    const version = semver_1.parse(assemblyVersion, { includePrerelease: true });
+    if (version == null) {
+        throw new Error(`Unable to parse the provided assembly version: "${assemblyVersion}"`);
+    }
+    if (version.prerelease.length === 0) {
+        return assemblyVersion;
+    }
+    switch (target) {
+        case TargetName.PYTHON:
+            // Python supports a limited set of identifiers... And we have a mapping table...
+            // https://packaging.python.org/guides/distributing-packages-using-setuptools/#pre-release-versioning
+            const [label, sequence, ...rest] = version.prerelease;
+            if (rest.filter((elt) => elt !== 0).length > 0 || sequence == null) {
+                throw new Error(`Unable to map prerelease identifier (in: ${assemblyVersion}) components to python: ${util_1.inspect(version.prerelease)}. The format should be 'X.Y.Z-label.sequence', where sequence is a positive integer, and label is "dev", "pre", "alpha", beta", or "rc"`);
+            }
+            if (!Number.isInteger(sequence)) {
+                throw new Error(`Unable to map prerelease identifier (in: ${assemblyVersion}) to python, as sequence ${util_1.inspect(sequence)} is not an integer`);
+            }
+            const baseVersion = `${version.major}.${version.minor}.${version.patch}`;
+            // See PEP 440: https://www.python.org/dev/peps/pep-0440/#pre-releases
+            switch (label) {
+                case 'dev':
+                case 'pre':
+                    return `${baseVersion}.dev${sequence}`;
+                case 'alpha':
+                    return `${baseVersion}.a${sequence}`;
+                case 'beta':
+                    return `${baseVersion}.b${sequence}`;
+                case 'rc':
+                    return `${baseVersion}.rc${sequence}`;
+                default:
+                    throw new Error(`Unable to map prerelease identifier (in: ${assemblyVersion}) to python, as label ${util_1.inspect(label)} is not mapped (only "dev", "pre", "alpha", "beta" and "rc" are)`);
+            }
+        case TargetName.DOTNET:
+        case TargetName.GO:
+        case TargetName.JAVA:
+        case TargetName.JAVASCRIPT:
+            // Not touching - the NPM version number should be usable as-is
+            break;
+    }
+    return assemblyVersion;
+}
+exports.toReleaseVersion = toReleaseVersion;
+/**
+ * Converts a semantic version range to the kind of bracket notation used by
+ * Maven and NuGet. For example, this turns `^1.2.3` into `[1.2.3,2.0.0)`.
+ *
+ * @param semverRange The semantic version range to be converted.
+ * @param suffix A version suffix to apply to versions in the resulting expression.
+ * @param semver Whether the target supports full semantic versioning (including
+ *               `-0` as the lowest possible prerelease identifier)
+ *
+ * @returns a bracket-notation version range.
+ */
+function toBracketNotation(semverRange, suffix, { semver = true, target = TargetName.JAVASCRIPT, } = {}) {
+    if (semverRange === '*') {
+        semverRange = '>=0.0.0';
+    }
+    const range = new semver_1.Range(semverRange);
+    if (semverRange === range.range) {
+        return semverRange;
+    }
+    return range.set
+        .map((set) => {
+        if (set.length === 1) {
+            const version = set[0].semver.raw;
+            if (!version && range.raw === '>=0.0.0') {
+                // Case where version is '*'
+                return '[0.0.0,)';
+            }
+            switch (set[0].operator || '=') {
+                // "[version]" => means exactly version
+                case '=':
+                    return `[${addSuffix(version)}]`;
+                // "(version,]" => means greater than version
+                case '>':
+                    return `(${addSuffix(version)},)`;
+                // "[version,]" => means greater than or equal to that version
+                case '>=':
+                    return `[${addSuffix(version)},)`;
+                // "[,version)" => means less than version
+                case '<':
+                    return `(,${addSuffix(version, !semver)})`;
+                // "[,version]" => means less than or equal to version
+                case '<=':
+                    return `(,${addSuffix(version)}]`;
+            }
+        }
+        else if (set.length === 2) {
+            const nugetRange = toBracketRange(set[0], set[1]);
+            if (nugetRange) {
+                return nugetRange;
+            }
+        }
+        throw new Error(`Unsupported SemVer range set in ${semverRange}: ${set
+            .map((comp) => comp.value)
+            .join(', ')}`);
+    })
+        .join(', ');
+    function toBracketRange(left, right) {
+        if (left.operator.startsWith('<') && right.operator.startsWith('>')) {
+            // Order isn't ideal, swap around..
+            [left, right] = [right, left];
+        }
+        // With ^0.0.0, somehow we get a left entry with an empty operator and value, we'll fix this up
+        if (left.operator === '' && left.value === '') {
+            left = new semver_1.Comparator('>=0.0.0', left.options);
+        }
+        if (!left.operator.startsWith('>') || !right.operator.startsWith('<')) {
+            // We only support ranges defined like "> (or >=) left, < (or <=) right"
+            return undefined;
+        }
+        const leftBrace = left.operator.endsWith('=') ? '[' : '(';
+        const rightBrace = right.operator.endsWith('=') ? ']' : ')';
+        return `${leftBrace}${addSuffix(left.semver.raw)},${addSuffix(right.semver.raw, right.operator === '<' && !semver)}${rightBrace}`;
+    }
+    function addSuffix(str, trimDashZero = false) {
+        if (!str) {
+            return '';
+        }
+        if (trimDashZero) {
+            str = str.replace(/-0$/, '');
+        }
+        return suffix ? `${str}${suffix}` : toReleaseVersion(str, target);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"semver.js","sourceRoot":"","sources":["../../src/util/semver.ts"],"names":[],"mappings":"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","sourcesContent":["// stolen from: https://github.com/aws/jsii/blob/main/packages/jsii-pacmak/lib/targets/version-utils.ts\n\nimport { inspect } from 'util';\nimport { Comparator, Range, parse } from 'semver';\n\nexport enum TargetName {\n  JAVA,\n  DOTNET,\n  PYTHON,\n  GO,\n  JAVASCRIPT\n}\n\n/**\n * Converts a SemVer range expression to a Maven version range expression.\n *\n * @param semverRange the SemVer range expression to convert.\n * @param suffix      the suffix to add to versions in the range.\n *\n * @see https://cwiki.apache.org/confluence/display/MAVENOLD/Dependency+Mediation+and+Conflict+Resolution\n */\nexport function toMavenVersionRange(\n  semverRange: string,\n  suffix?: string,\n): string {\n  return toBracketNotation(semverRange, suffix, {\n    semver: false,\n    target: TargetName.JAVA,\n  });\n}\n\n/**\n * Converts a SemVer range expression to a NuGet version range expression.\n *\n * @param semverRange the SemVer range expression to convert.\n *\n * @see https://docs.microsoft.com/en-us/nuget/concepts/package-versioning#version-ranges-and-wildcards\n */\nexport function toNuGetVersionRange(semverRange: string): string {\n  return toBracketNotation(semverRange, undefined, {\n    semver: false,\n    target: TargetName.DOTNET,\n  });\n}\n\n/**\n * Converts a SemVer range expression to a Python setuptools compatible version\n * constraint expression.\n *\n * @param semverRange the SemVer range expression to convert.\n */\nexport function toPythonVersionRange(semverRange: string): string {\n  const range = new Range(semverRange);\n  return range.set\n    .map((set) =>\n      set\n        .map((comp) => {\n          const versionId = toReleaseVersion(\n            comp.semver.raw?.replace(/-0$/, '') ?? '0.0.0',\n            TargetName.PYTHON,\n          );\n          switch (comp.operator) {\n            case '':\n              // With ^0.0.0, somehow we get a left entry with an empty operator and value, we'll fix this up\n              return comp.value === '' ? '>=0.0.0' : `==${versionId}`;\n            case '=':\n              return `==${versionId}`;\n            default:\n              // >, >=, <, <= are all valid expressions\n              return `${comp.operator}${versionId}`;\n          }\n        })\n        .join(', '),\n    )\n    .join(', ');\n}\n\n/**\n * Converts an original version number from the NPM convention to the target\n * language's convention for expressing the same. For versions that do not\n * include a prerelease identifier, this always returns the assembly version\n * unmodified.\n *\n * @param assemblyVersion the assembly version being released\n * @param target          the target language for which the version is destined\n *\n * @returns the version that should be serialized\n */\nexport function toReleaseVersion(\n  assemblyVersion: string,\n  target: TargetName,\n): string {\n  const version = parse(assemblyVersion, { includePrerelease: true });\n  if (version == null) {\n    throw new Error(\n      `Unable to parse the provided assembly version: \"${assemblyVersion}\"`,\n    );\n  }\n  if (version.prerelease.length === 0) {\n    return assemblyVersion;\n  }\n  switch (target) {\n    case TargetName.PYTHON:\n      // Python supports a limited set of identifiers... And we have a mapping table...\n      // https://packaging.python.org/guides/distributing-packages-using-setuptools/#pre-release-versioning\n      const [label, sequence, ...rest] = version.prerelease;\n      if (rest.filter((elt) => elt !== 0).length > 0 || sequence == null) {\n        throw new Error(\n          `Unable to map prerelease identifier (in: ${assemblyVersion}) components to python: ${inspect(\n            version.prerelease,\n          )}. The format should be 'X.Y.Z-label.sequence', where sequence is a positive integer, and label is \"dev\", \"pre\", \"alpha\", beta\", or \"rc\"`,\n        );\n      }\n      if (!Number.isInteger(sequence)) {\n        throw new Error(\n          `Unable to map prerelease identifier (in: ${assemblyVersion}) to python, as sequence ${inspect(\n            sequence,\n          )} is not an integer`,\n        );\n      }\n      const baseVersion = `${version.major}.${version.minor}.${version.patch}`;\n      // See PEP 440: https://www.python.org/dev/peps/pep-0440/#pre-releases\n      switch (label) {\n        case 'dev':\n        case 'pre':\n          return `${baseVersion}.dev${sequence}`;\n        case 'alpha':\n          return `${baseVersion}.a${sequence}`;\n        case 'beta':\n          return `${baseVersion}.b${sequence}`;\n        case 'rc':\n          return `${baseVersion}.rc${sequence}`;\n        default:\n          throw new Error(\n            `Unable to map prerelease identifier (in: ${assemblyVersion}) to python, as label ${inspect(\n              label,\n            )} is not mapped (only \"dev\", \"pre\", \"alpha\", \"beta\" and \"rc\" are)`,\n          );\n      }\n    case TargetName.DOTNET:\n    case TargetName.GO:\n    case TargetName.JAVA:\n    case TargetName.JAVASCRIPT:\n      // Not touching - the NPM version number should be usable as-is\n      break;\n  }\n  return assemblyVersion;\n}\n\n/**\n * Converts a semantic version range to the kind of bracket notation used by\n * Maven and NuGet. For example, this turns `^1.2.3` into `[1.2.3,2.0.0)`.\n *\n * @param semverRange The semantic version range to be converted.\n * @param suffix A version suffix to apply to versions in the resulting expression.\n * @param semver Whether the target supports full semantic versioning (including\n *               `-0` as the lowest possible prerelease identifier)\n *\n * @returns a bracket-notation version range.\n */\nfunction toBracketNotation(\n  semverRange: string,\n  suffix?: string,\n  {\n    semver = true,\n    target = TargetName.JAVASCRIPT,\n  }: { semver?: boolean; target?: TargetName } = {},\n): string {\n  if (semverRange === '*') {\n    semverRange = '>=0.0.0';\n  }\n\n  const range = new Range(semverRange);\n  if (semverRange === range.range) {\n    return semverRange;\n  }\n\n  return range.set\n    .map((set) => {\n      if (set.length === 1) {\n        const version = set[0].semver.raw;\n        if (!version && range.raw === '>=0.0.0') {\n          // Case where version is '*'\n          return '[0.0.0,)';\n        }\n        switch (set[0].operator || '=') {\n          // \"[version]\" => means exactly version\n          case '=':\n            return `[${addSuffix(version)}]`;\n          // \"(version,]\" => means greater than version\n          case '>':\n            return `(${addSuffix(version)},)`;\n          // \"[version,]\" => means greater than or equal to that version\n          case '>=':\n            return `[${addSuffix(version)},)`;\n          // \"[,version)\" => means less than version\n          case '<':\n            return `(,${addSuffix(version, !semver)})`;\n          // \"[,version]\" => means less than or equal to version\n          case '<=':\n            return `(,${addSuffix(version)}]`;\n        }\n      } else if (set.length === 2) {\n        const nugetRange = toBracketRange(set[0], set[1]);\n        if (nugetRange) {\n          return nugetRange;\n        }\n      }\n      throw new Error(\n        `Unsupported SemVer range set in ${semverRange}: ${set\n          .map((comp) => comp.value)\n          .join(', ')}`,\n      );\n    })\n    .join(', ');\n\n  function toBracketRange(\n    left: Comparator,\n    right: Comparator,\n  ): string | undefined {\n    if (left.operator.startsWith('<') && right.operator.startsWith('>')) {\n      // Order isn't ideal, swap around..\n      [left, right] = [right, left];\n    }\n\n    // With ^0.0.0, somehow we get a left entry with an empty operator and value, we'll fix this up\n    if (left.operator === '' && left.value === '') {\n      left = new Comparator('>=0.0.0', left.options);\n    }\n\n    if (!left.operator.startsWith('>') || !right.operator.startsWith('<')) {\n      // We only support ranges defined like \"> (or >=) left, < (or <=) right\"\n      return undefined;\n    }\n\n    const leftBrace = left.operator.endsWith('=') ? '[' : '(';\n    const rightBrace = right.operator.endsWith('=') ? ']' : ')';\n    return `${leftBrace}${addSuffix(left.semver.raw)},${addSuffix(\n      right.semver.raw,\n      right.operator === '<' && !semver,\n    )}${rightBrace}`;\n  }\n\n  function addSuffix(str: string | undefined, trimDashZero = false) {\n    if (!str) {\n      return '';\n    }\n    if (trimDashZero) {\n      str = str.replace(/-0$/, '');\n    }\n    return suffix ? `${str}${suffix}` : toReleaseVersion(str, target);\n  }\n}"]}