projen 0.101.3 → 0.101.4

package/lib/typescript/projenrc.js

@@ -7,23 +7,25 @@ const path_1 = require("path");
 const javascript_1 = require("../javascript");
 const render_options_1 = require("../javascript/render-options");
 const projenrc_1 = require("../projenrc");
+const typescript_runner_1 = require("./typescript-runner");
 const DEFAULT_FILENAME = ".projenrc.ts";
 /**
- * Sets up a typescript project to use TypeScript for projenrc.
+ * A projenrc file written in TypeScript
+ *
+ * This component is used within TypeScriptProject.
  */
 class Projenrc extends projenrc_1.ProjenrcFile {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.typescript.Projenrc", version: "0.101.3" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.typescript.Projenrc", version: "0.101.4" };
     filePath;
     tsconfig;
     _projenCodeDir;
     _tsProject;
-    _swc;
+    _runner;
     constructor(project, options = {}) {
         super(project);
         this._tsProject = project;
         this.filePath = options.filename ?? DEFAULT_FILENAME;
         this._projenCodeDir = options.projenCodeDir ?? "projenrc";
-        this._swc = options.swc ?? false;
         // Give the projenrc source tree its own `tsconfig.json` so the eslint
         // project service (and editors) resolve it as the nearest config for those
         // files. This avoids listing the whole tree under `allowDefaultProject`,
@@ -32,30 +34,46 @@ class Projenrc extends projenrc_1.ProjenrcFile {
         const baseTsconfig = project.tsconfig ?? project.tsconfigDev;
         this.tsconfig = new javascript_1.TypescriptConfig(project, {
             fileName: `${this._projenCodeDir}/tsconfig.json`,
-            include: ["**/*.ts"],
+            include: ["**/*.ts", path_1.posix.relative(this._projenCodeDir, this.filePath)],
             extends: javascript_1.TypescriptConfigExtends.fromTypescriptConfigs([baseTsconfig]),
             compilerOptions: {
                 noEmit: true,
                 rootDir: path_1.posix.relative(this._projenCodeDir, ".") || ".",
             },
         });
+        // A runner is a future component, make sure it is attached
+        this._runner = this.getRunner(options).tryAttach(this._tsProject);
         this.addDefaultTask();
         this.generateProjenrc();
     }
     addDefaultTask() {
-        const deps = ["ts-node"];
-        if (this._swc) {
-            deps.push("@swc/core");
+        // Render the run config for the entrypoint
+        const { dependencies, steps } = this._runner.configFor(this.filePath);
+        // Request runner dependencies
+        for (const dep of dependencies) {
+            this._tsProject.deps.requestDependency(dep);
         }
-        // this is the task projen executes when running `projen` without a
-        // specific task (if this task is not defined, projen falls back to
-        // running "node .projenrc.js").
-        this._tsProject.addDevDeps(...deps);
-        const tsNode = this._swc ? "ts-node --swc" : "ts-node";
-        // ts-node compiles the entrypoint and its imports on demand using the dev
-        // tsconfig's compiler options, so projen source files may reside anywhere
-        // in the project tree regardless of the config's `include`.
-        this._tsProject.defaultTask?.exec(`${tsNode} --project ${this._tsProject.tsconfigDev.fileName} ${this.filePath}`);
+        // Add runner steps
+        this._tsProject.defaultTask?.addSteps(...steps);
+    }
+    getRunner(options) {
+        // use a provide runner as is
+        if (options.runner) {
+            return options.runner;
+        }
+        // swc implies ts-node runner for backwards compatibility
+        if (options.swc) {
+            return typescript_runner_1.TypeScriptRunner.tsNode({
+                swc: true,
+                typeCheck: true,
+                tsconfig: this.tsconfig.fileName,
+            }).tryAttach(this._tsProject);
+        }
+        // we use the project's default runner with the correct tsconfig and type-checking enabled
+        return this._tsProject.runner.copy({
+            tsconfig: this.tsconfig.fileName,
+            typeCheck: true,
+        });
     }
     preSynthesize() {
         super.preSynthesize();
@@ -118,4 +136,4 @@ class Projenrc extends projenrc_1.ProjenrcFile {
     }
 }
 exports.Projenrc = Projenrc;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"projenrc.js","sourceRoot":"","sources":["../../src/typescript/projenrc.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync, writeFileSync, mkdirSync } from \"fs\";\nimport { dirname, posix, resolve } from \"path\";\nimport type { InventoryProjectType } from \"../inventory\";\nimport { TypescriptConfig, TypescriptConfigExtends } from \"../javascript\";\nimport { renderJavaScriptOptions } from \"../javascript/render-options\";\nimport { ProjenrcFile } from \"../projenrc\";\nimport type { TypeScriptProject } from \"../typescript\";\n\nexport interface ProjenrcOptions {\n  /**\n   * The name of the projenrc file.\n   * @default \".projenrc.ts\"\n   */\n  readonly filename?: string;\n\n  /**\n   * A directory tree that may contain *.ts files that can be referenced from\n   * your projenrc typescript file.\n   *\n   * @default \"projenrc\"\n   */\n  readonly projenCodeDir?: string;\n\n  /**\n   * Whether to use `SWC` for ts-node.\n   *\n   * @default false\n   */\n  readonly swc?: boolean;\n}\n\nconst DEFAULT_FILENAME = \".projenrc.ts\";\n\n/**\n * Sets up a typescript project to use TypeScript for projenrc.\n */\nexport class Projenrc extends ProjenrcFile {\n  public readonly filePath: string;\n  public readonly tsconfig: TypescriptConfig;\n\n  private readonly _projenCodeDir: string;\n  private readonly _tsProject: TypeScriptProject;\n  private readonly _swc: boolean;\n\n  constructor(project: TypeScriptProject, options: ProjenrcOptions = {}) {\n    super(project);\n    this._tsProject = project;\n\n    this.filePath = options.filename ?? DEFAULT_FILENAME;\n    this._projenCodeDir = options.projenCodeDir ?? \"projenrc\";\n    this._swc = options.swc ?? false;\n\n    // Give the projenrc source tree its own `tsconfig.json` so the eslint\n    // project service (and editors) resolve it as the nearest config for those\n    // files. This avoids listing the whole tree under `allowDefaultProject`,\n    // which only permits a small number of loose files (and rejects `**`\n    // globs). It extends the root config and is type-check only.\n    const baseTsconfig = project.tsconfig ?? project.tsconfigDev;\n    this.tsconfig = new TypescriptConfig(project, {\n      fileName: `${this._projenCodeDir}/tsconfig.json`,\n      include: [\"**/*.ts\"],\n      extends: TypescriptConfigExtends.fromTypescriptConfigs([baseTsconfig]),\n      compilerOptions: {\n        noEmit: true,\n        rootDir: posix.relative(this._projenCodeDir, \".\") || \".\",\n      },\n    });\n\n    this.addDefaultTask();\n\n    this.generateProjenrc();\n  }\n\n  private addDefaultTask() {\n    const deps = [\"ts-node\"];\n    if (this._swc) {\n      deps.push(\"@swc/core\");\n    }\n\n    // this is the task projen executes when running `projen` without a\n    // specific task (if this task is not defined, projen falls back to\n    // running \"node .projenrc.js\").\n    this._tsProject.addDevDeps(...deps);\n\n    const tsNode = this._swc ? \"ts-node --swc\" : \"ts-node\";\n\n    // ts-node compiles the entrypoint and its imports on demand using the dev\n    // tsconfig's compiler options, so projen source files may reside anywhere\n    // in the project tree regardless of the config's `include`.\n    this._tsProject.defaultTask?.exec(\n      `${tsNode} --project ${this._tsProject.tsconfigDev.fileName} ${this.filePath}`,\n    );\n  }\n\n  public override preSynthesize(): void {\n    super.preSynthesize();\n\n    this._tsProject.addPackageIgnore(`/${this.filePath}`);\n    this._tsProject.addPackageIgnore(`/${this._projenCodeDir}`);\n\n    // The projenrc entrypoint lives at the repository root and is not covered\n    // by any `tsconfig.json`. Register only this single file with the eslint\n    // project service's default project (the projenrc source tree is covered\n    // by its own tsconfig). `allowDefaultProject` does not permit `**` globs.\n    this._tsProject.eslint?.allowDefaultProjectFiles(this.filePath);\n\n    this._tsProject.eslint?.addLintPattern(this._projenCodeDir);\n    this._tsProject.eslint?.addLintPattern(this.filePath);\n    this._tsProject.eslint?.allowDevDeps(this.filePath);\n    this._tsProject.eslint?.allowDevDeps(`${this._projenCodeDir}/**/*.ts`);\n    this._tsProject.eslint?.addIgnorePattern(`!${this.filePath}`);\n    this._tsProject.eslint?.addIgnorePattern(`!${this._projenCodeDir}/**/*.ts`);\n\n    this._tsProject.eslint?.addOverride({\n      files: [this.filePath],\n      rules: {\n        \"@typescript-eslint/no-require-imports\": \"off\",\n        \"import/no-extraneous-dependencies\": \"off\",\n      },\n    });\n\n    this._tsProject.biome?.addFilePattern(this.filePath);\n    this._tsProject.biome?.addFilePattern(`${this._projenCodeDir}/**`);\n\n    this._tsProject.jest?.discoverTestMatchPatternsForDirs(\n      [this._projenCodeDir],\n      {\n        fileExtensionPattern: this._tsProject.tsconfig?.compilerOptions?.allowJs\n          ? undefined\n          : \"ts?(x)\",\n      },\n    );\n  }\n\n  private generateProjenrc() {\n    const rcfile = resolve(this.project.outdir, this.filePath);\n    if (existsSync(rcfile)) {\n      return; // already exists\n    }\n\n    const bootstrap = this.project.initProject;\n    if (!bootstrap) {\n      return;\n    }\n\n    const parts = bootstrap.fqn.split(\".\");\n    const moduleName = parts[0];\n    const importName = parts[1];\n    const className = parts.slice(1).join(\".\");\n\n    const { renderedOptions, imports } = renderJavaScriptOptions({\n      args: bootstrap.args,\n      type: bootstrap.type as InventoryProjectType,\n      comments: bootstrap.comments,\n    });\n\n    imports.add(moduleName, importName);\n\n    const lines = new Array<string>();\n    lines.push(...imports.asEsmImports());\n    lines.push();\n    lines.push(`const project = new ${className}(${renderedOptions});`);\n    lines.push();\n    lines.push(\"project.synth();\");\n\n    mkdirSync(dirname(rcfile), { recursive: true });\n    writeFileSync(rcfile, lines.join(\"\\n\"));\n    this.project.logger.info(\n      `Project definition file was created at ${rcfile}`,\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"projenrc.js","sourceRoot":"","sources":["../../src/typescript/projenrc.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from \"fs\";\nimport { dirname, posix, resolve } from \"path\";\nimport type { InventoryProjectType } from \"../inventory\";\nimport { TypescriptConfig, TypescriptConfigExtends } from \"../javascript\";\nimport type { TypeScriptProject } from \"./typescript\";\nimport { renderJavaScriptOptions } from \"../javascript/render-options\";\nimport { ProjenrcFile } from \"../projenrc\";\nimport { TypeScriptRunner } from \"./typescript-runner\";\n\nexport interface ProjenrcOptions {\n  /**\n   * The name of the projenrc file.\n   * @default \".projenrc.ts\"\n   */\n  readonly filename?: string;\n\n  /**\n   * A directory tree that may contain *.ts files that can be referenced from\n   * your projenrc typescript file.\n   *\n   * @default \"projenrc\"\n   */\n  readonly projenCodeDir?: string;\n\n  /**\n   * Whether to use `SWC` for ts-node.\n   *\n   * @default false\n   * @deprecated Use `runner: TypeScriptRunner.tsNode({ swc: true })` instead.\n   */\n  readonly swc?: boolean;\n\n  /**\n   * The runner to use for executing TypeScript files.\n   *\n   * @default - the project's runner\n   */\n  readonly runner?: TypeScriptRunner;\n}\n\nconst DEFAULT_FILENAME = \".projenrc.ts\";\n\n/**\n * A projenrc file written in TypeScript\n *\n * This component is used within TypeScriptProject.\n */\nexport class Projenrc extends ProjenrcFile {\n  public readonly filePath: string;\n  public readonly tsconfig: TypescriptConfig;\n\n  private readonly _projenCodeDir: string;\n  private readonly _tsProject: TypeScriptProject;\n  private readonly _runner: TypeScriptRunner;\n\n  constructor(project: TypeScriptProject, options: ProjenrcOptions = {}) {\n    super(project);\n    this._tsProject = project;\n\n    this.filePath = options.filename ?? DEFAULT_FILENAME;\n    this._projenCodeDir = options.projenCodeDir ?? \"projenrc\";\n\n    // Give the projenrc source tree its own `tsconfig.json` so the eslint\n    // project service (and editors) resolve it as the nearest config for those\n    // files. This avoids listing the whole tree under `allowDefaultProject`,\n    // which only permits a small number of loose files (and rejects `**`\n    // globs). It extends the root config and is type-check only.\n    const baseTsconfig = project.tsconfig ?? project.tsconfigDev;\n    this.tsconfig = new TypescriptConfig(project, {\n      fileName: `${this._projenCodeDir}/tsconfig.json`,\n      include: [\"**/*.ts\", posix.relative(this._projenCodeDir, this.filePath)],\n      extends: TypescriptConfigExtends.fromTypescriptConfigs([baseTsconfig]),\n      compilerOptions: {\n        noEmit: true,\n        rootDir: posix.relative(this._projenCodeDir, \".\") || \".\",\n      },\n    });\n\n    // A runner is a future component, make sure it is attached\n    this._runner = this.getRunner(options).tryAttach(this._tsProject);\n\n    this.addDefaultTask();\n\n    this.generateProjenrc();\n  }\n\n  private addDefaultTask() {\n    // Render the run config for the entrypoint\n    const { dependencies, steps } = this._runner.configFor(this.filePath);\n\n    // Request runner dependencies\n    for (const dep of dependencies) {\n      this._tsProject.deps.requestDependency(dep);\n    }\n\n    // Add runner steps\n    this._tsProject.defaultTask?.addSteps(...steps);\n  }\n\n  private getRunner(options: ProjenrcOptions): TypeScriptRunner {\n    // use a provide runner as is\n    if (options.runner) {\n      return options.runner;\n    }\n\n    // swc implies ts-node runner for backwards compatibility\n    if (options.swc) {\n      return TypeScriptRunner.tsNode({\n        swc: true,\n        typeCheck: true,\n        tsconfig: this.tsconfig.fileName,\n      }).tryAttach(this._tsProject);\n    }\n\n    // we use the project's default runner with the correct tsconfig and type-checking enabled\n    return this._tsProject.runner.copy({\n      tsconfig: this.tsconfig.fileName,\n      typeCheck: true,\n    });\n  }\n\n  public override preSynthesize(): void {\n    super.preSynthesize();\n\n    this._tsProject.addPackageIgnore(`/${this.filePath}`);\n    this._tsProject.addPackageIgnore(`/${this._projenCodeDir}`);\n\n    // The projenrc entrypoint lives at the repository root and is not covered\n    // by any `tsconfig.json`. Register only this single file with the eslint\n    // project service's default project (the projenrc source tree is covered\n    // by its own tsconfig). `allowDefaultProject` does not permit `**` globs.\n    this._tsProject.eslint?.allowDefaultProjectFiles(this.filePath);\n\n    this._tsProject.eslint?.addLintPattern(this._projenCodeDir);\n    this._tsProject.eslint?.addLintPattern(this.filePath);\n    this._tsProject.eslint?.allowDevDeps(this.filePath);\n    this._tsProject.eslint?.allowDevDeps(`${this._projenCodeDir}/**/*.ts`);\n    this._tsProject.eslint?.addIgnorePattern(`!${this.filePath}`);\n    this._tsProject.eslint?.addIgnorePattern(`!${this._projenCodeDir}/**/*.ts`);\n\n    this._tsProject.eslint?.addOverride({\n      files: [this.filePath],\n      rules: {\n        \"@typescript-eslint/no-require-imports\": \"off\",\n        \"import/no-extraneous-dependencies\": \"off\",\n      },\n    });\n\n    this._tsProject.biome?.addFilePattern(this.filePath);\n    this._tsProject.biome?.addFilePattern(`${this._projenCodeDir}/**`);\n\n    this._tsProject.jest?.discoverTestMatchPatternsForDirs(\n      [this._projenCodeDir],\n      {\n        fileExtensionPattern: this._tsProject.tsconfig?.compilerOptions?.allowJs\n          ? undefined\n          : \"ts?(x)\",\n      },\n    );\n  }\n\n  private generateProjenrc() {\n    const rcfile = resolve(this.project.outdir, this.filePath);\n    if (existsSync(rcfile)) {\n      return; // already exists\n    }\n\n    const bootstrap = this.project.initProject;\n    if (!bootstrap) {\n      return;\n    }\n\n    const parts = bootstrap.fqn.split(\".\");\n    const moduleName = parts[0];\n    const importName = parts[1];\n    const className = parts.slice(1).join(\".\");\n\n    const { renderedOptions, imports } = renderJavaScriptOptions({\n      args: bootstrap.args,\n      type: bootstrap.type as InventoryProjectType,\n      comments: bootstrap.comments,\n    });\n\n    imports.add(moduleName, importName);\n\n    const lines = new Array<string>();\n    lines.push(...imports.asEsmImports());\n    lines.push();\n    lines.push(`const project = new ${className}(${renderedOptions});`);\n    lines.push();\n    lines.push(\"project.synth();\");\n\n    mkdirSync(dirname(rcfile), { recursive: true });\n    writeFileSync(rcfile, lines.join(\"\\n\"));\n    this.project.logger.info(\n      `Project definition file was created at ${rcfile}`,\n    );\n  }\n}\n"]}

package/lib/typescript/typescript-runner.d.ts

@@ -0,0 +1,146 @@
+import { type RunScriptConfig, ScriptRunner } from "../script-runner";
+/**
+ * Options for the ts-node runner.
+ */
+export interface TsNodeRunnerOptions {
+    /**
+     * Whether to type-check the script during executing.
+     *
+     * @see https://github.com/TypeStrong/ts-node#typecheck
+     *
+     * @default true
+     */
+    readonly typeCheck?: boolean;
+    /**
+     * Path to the tsconfig file to use.
+     *
+     * @default - ts-node default discovery
+     */
+    readonly tsconfig?: string;
+    /**
+     * Whether to use SWC for transpilation.
+     *
+     * This will disable type-checking.
+     *
+     * @see https://github.com/TypeStrong/ts-node#swc
+     *
+     * @default false
+     */
+    readonly swc?: boolean;
+}
+/**
+ * Options for the tsx runner.
+ */
+export interface TsxRunnerOptions {
+    /**
+     * Whether to type-check the entrypoint before executing.
+     *
+     * Because tsx does not type check code, you may want to enable this for additional type safety.
+     * When enabled, runs `tsc --noEmit`, using the provided tsconfig.
+     *
+     * @default false
+     */
+    readonly typeCheck?: boolean;
+    /**
+     * Path to the tsconfig file to use.
+     * When specified, will use this tsconfig for running tsx and type-checking (if enabled).
+     *
+     * @default - tsx/typescript default discovery
+     */
+    readonly tsconfig?: string;
+}
+/**
+ * Options for the native Node.js TypeScript runner.
+ */
+export interface NodeRunnerOptions {
+    /**
+     * Whether to type-check the entrypoint before executing.
+     *
+     * Because the native Node.js TypeScript does not type check code,
+     * you may want to enable this for additional type safety.
+     * When enabled, runs `tsc --noEmit`, using the provided tsconfig.
+     *
+     * @default false
+     */
+    readonly typeCheck?: boolean;
+    /**
+     * Path to the tsconfig file for type-checking.
+     * When specified, will use this tsconfig for type-checking (if enabled).
+     *
+     * @default - typescript default discovery
+     */
+    readonly tsconfig?: string;
+    /**
+     * Whether to also enable `--experimental-transform-types`.
+     * @default false
+     */
+    readonly experimentalTransformTypes?: boolean;
+}
+/**
+ * The options that can be adjusted on any {@link TypeScriptRunner}, regardless
+ * of its runtime.
+ *
+ * This is the override type for {@link TypeScriptRunner.copy}. Runtime-specific
+ * creation options (such as `swc` for ts-node) are set via the static factories
+ * and are preserved - but cannot be changed - by `copy`, so a copy can never
+ * change the runtime of a runner.
+ */
+export interface TypeScriptRunnerOptions {
+    /**
+     * Whether to type-check the entrypoint.
+     */
+    readonly typeCheck?: boolean;
+    /**
+     * Path to the tsconfig file to use.
+     */
+    readonly tsconfig?: string;
+}
+/**
+ * The runner used to execute TypeScript files.
+ *
+ * A runner is a {@link FutureComponent}: create it standalone (e.g. via one of
+ * the static factories) and it is attached to a project by the component that
+ * consumes it. Use {@link TypeScriptRunner.copy} to derive a new runner with
+ * adjusted options.
+ */
+export declare class TypeScriptRunner extends ScriptRunner {
+    /**
+     * Use ts-node to execute TypeScript files.
+     */
+    static tsNode(options?: TsNodeRunnerOptions): TypeScriptRunner;
+    /**
+     * Use tsx to execute TypeScript files.
+     *
+     * tsx is a fast TypeScript runtime that does not perform type-checking.
+     * You may opt-in to an explicit type-checking step before the script is run.
+     */
+    static tsx(options?: TsxRunnerOptions): TypeScriptRunner;
+    /**
+     * Use the native Node.js TypeScript support.
+     *
+     * Requires Node.js 22.18.0 or later.
+     * The script must use ESM style imports (no directories, include file endings, etc.).
+     *
+     * Named `nodejs` (not `node`) because a runner is a construct, and `node` is
+     * reserved by `constructs.Construct` for the construct's tree node.
+     */
+    static nodejs(options?: NodeRunnerOptions): TypeScriptRunner;
+    private readonly _kind;
+    private readonly _options;
+    private constructor();
+    /**
+     * Returns a new (detached) runner of the same kind, with `overrides` merged
+     * over the current options.
+     *
+     * Safe to call while detached.
+     */
+    copy(overrides?: TypeScriptRunnerOptions): TypeScriptRunner;
+    /**
+     * Produce the {@link RunScriptConfig} to run the given entrypoint with this
+     * runner.
+     */
+    configFor(entrypoint: string): RunScriptConfig;
+    private renderTsNode;
+    private renderTsx;
+    private renderNode;
+}

package/lib/typescript/typescript-runner.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptRunner = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const script_runner_1 = require("../script-runner");
+const recreate_1 = require("../util/recreate");
+/**
+ * The runner used to execute TypeScript files.
+ *
+ * A runner is a {@link FutureComponent}: create it standalone (e.g. via one of
+ * the static factories) and it is attached to a project by the component that
+ * consumes it. Use {@link TypeScriptRunner.copy} to derive a new runner with
+ * adjusted options.
+ */
+class TypeScriptRunner extends script_runner_1.ScriptRunner {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.typescript.TypeScriptRunner", version: "0.101.4" };
+    /**
+     * Use ts-node to execute TypeScript files.
+     */
+    static tsNode(options = {}) {
+        return new TypeScriptRunner("ts-node", options);
+    }
+    /**
+     * Use tsx to execute TypeScript files.
+     *
+     * tsx is a fast TypeScript runtime that does not perform type-checking.
+     * You may opt-in to an explicit type-checking step before the script is run.
+     */
+    static tsx(options = {}) {
+        return new TypeScriptRunner("tsx", options);
+    }
+    /**
+     * Use the native Node.js TypeScript support.
+     *
+     * Requires Node.js 22.18.0 or later.
+     * The script must use ESM style imports (no directories, include file endings, etc.).
+     *
+     * Named `nodejs` (not `node`) because a runner is a construct, and `node` is
+     * reserved by `constructs.Construct` for the construct's tree node.
+     */
+    static nodejs(options = {}) {
+        return new TypeScriptRunner("node", options);
+    }
+    _kind;
+    _options;
+    constructor(kind, options) {
+        super();
+        this._kind = kind;
+        this._options = options;
+    }
+    /**
+     * Returns a new (detached) runner of the same kind, with `overrides` merged
+     * over the current options.
+     *
+     * Safe to call while detached.
+     */
+    copy(overrides = {}) {
+        return (0, recreate_1.recreate)(this, this._kind, { ...this._options, ...overrides });
+    }
+    /**
+     * Produce the {@link RunScriptConfig} to run the given entrypoint with this
+     * runner.
+     */
+    configFor(entrypoint) {
+        switch (this._kind) {
+            case "ts-node":
+                return this.renderTsNode(entrypoint);
+            case "tsx":
+                return this.renderTsx(entrypoint);
+            case "node":
+                return this.renderNode(entrypoint);
+        }
+    }
+    renderTsNode(entrypoint) {
+        const typeCheck = this._options.typeCheck ?? true;
+        const swc = this._options.swc ?? false;
+        const command = ["ts-node"];
+        const dependencies = [{ name: "ts-node" }];
+        if (swc) {
+            dependencies.push({ name: "@swc/core" });
+            command.push("--swc");
+        }
+        if (!typeCheck) {
+            command.push("--transpileOnly");
+        }
+        if (this._options.tsconfig) {
+            command.push("--project", this._options.tsconfig);
+        }
+        // command.push("--prefer-ts-exts");
+        return {
+            dependencies,
+            steps: [{ execArgs: [...command, entrypoint] }],
+        };
+    }
+    renderTsx(entrypoint) {
+        const typeCheck = this._options.typeCheck ?? false;
+        const command = ["tsx"];
+        const steps = [];
+        const dependencies = [{ name: "tsx" }];
+        if (this._options.tsconfig) {
+            command.push("--tsconfig", this._options.tsconfig);
+        }
+        if (typeCheck) {
+            steps.push(typeCheckStep(this._options.tsconfig));
+        }
+        steps.push({ execArgs: [...command, entrypoint] });
+        return { dependencies, steps };
+    }
+    renderNode(entrypoint) {
+        const typeCheck = this._options.typeCheck ?? false;
+        const command = ["node"];
+        const steps = [];
+        const dependencies = [];
+        if (this._options.experimentalTransformTypes ?? false) {
+            command.push("--experimental-transform-types");
+            command.push("--disable-warning=ExperimentalWarning");
+        }
+        if (typeCheck) {
+            steps.push(typeCheckStep(this._options.tsconfig));
+            dependencies.push({ name: "typescript" });
+        }
+        steps.push({ execArgs: [...command, entrypoint] });
+        return { dependencies, steps };
+    }
+}
+exports.TypeScriptRunner = TypeScriptRunner;
+function typeCheckStep(tsconfig) {
+    const args = ["tsc", "--noEmit"];
+    if (tsconfig) {
+        args.push("-p", tsconfig);
+    }
+    return { execArgs: args, name: "typecheck" };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript-runner.js","sourceRoot":"","sources":["../../src/typescript/typescript-runner.ts"],"names":[],"mappings":"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","sourcesContent":["import type { DependencyRequest } from \"../dependencies\";\nimport { type RunScriptConfig, ScriptRunner } from \"../script-runner\";\nimport type { TaskStep } from \"../task-model\";\nimport { recreate } from \"../util/recreate\";\n\n/**\n * Options for the ts-node runner.\n */\nexport interface TsNodeRunnerOptions {\n  /**\n   * Whether to type-check the script during executing.\n   *\n   * @see https://github.com/TypeStrong/ts-node#typecheck\n   *\n   * @default true\n   */\n  readonly typeCheck?: boolean;\n\n  /**\n   * Path to the tsconfig file to use.\n   *\n   * @default - ts-node default discovery\n   */\n  readonly tsconfig?: string;\n\n  /**\n   * Whether to use SWC for transpilation.\n   *\n   * This will disable type-checking.\n   *\n   * @see https://github.com/TypeStrong/ts-node#swc\n   *\n   * @default false\n   */\n  readonly swc?: boolean;\n}\n\n/**\n * Options for the tsx runner.\n */\nexport interface TsxRunnerOptions {\n  /**\n   * Whether to type-check the entrypoint before executing.\n   *\n   * Because tsx does not type check code, you may want to enable this for additional type safety.\n   * When enabled, runs `tsc --noEmit`, using the provided tsconfig.\n   *\n   * @default false\n   */\n  readonly typeCheck?: boolean;\n\n  /**\n   * Path to the tsconfig file to use.\n   * When specified, will use this tsconfig for running tsx and type-checking (if enabled).\n   *\n   * @default - tsx/typescript default discovery\n   */\n  readonly tsconfig?: string;\n}\n\n/**\n * Options for the native Node.js TypeScript runner.\n */\nexport interface NodeRunnerOptions {\n  /**\n   * Whether to type-check the entrypoint before executing.\n   *\n   * Because the native Node.js TypeScript does not type check code,\n   * you may want to enable this for additional type safety.\n   * When enabled, runs `tsc --noEmit`, using the provided tsconfig.\n   *\n   * @default false\n   */\n  readonly typeCheck?: boolean;\n\n  /**\n   * Path to the tsconfig file for type-checking.\n   * When specified, will use this tsconfig for type-checking (if enabled).\n   *\n   * @default - typescript default discovery\n   */\n  readonly tsconfig?: string;\n\n  /**\n   * Whether to also enable `--experimental-transform-types`.\n   * @default false\n   */\n  readonly experimentalTransformTypes?: boolean;\n}\n\n/**\n * The options that can be adjusted on any {@link TypeScriptRunner}, regardless\n * of its runtime.\n *\n * This is the override type for {@link TypeScriptRunner.copy}. Runtime-specific\n * creation options (such as `swc` for ts-node) are set via the static factories\n * and are preserved - but cannot be changed - by `copy`, so a copy can never\n * change the runtime of a runner.\n */\nexport interface TypeScriptRunnerOptions {\n  /**\n   * Whether to type-check the entrypoint.\n   */\n  readonly typeCheck?: boolean;\n\n  /**\n   * Path to the tsconfig file to use.\n   */\n  readonly tsconfig?: string;\n}\n\ntype RunnerKind = \"ts-node\" | \"tsx\" | \"node\";\n\n/**\n * The full, internal option set for a runner: the common options plus the\n * runtime-specific creation options. Never exposed publicly.\n */\ninterface RunnerState extends TypeScriptRunnerOptions {\n  readonly swc?: boolean;\n  readonly experimentalTransformTypes?: boolean;\n}\n\n/**\n * The runner used to execute TypeScript files.\n *\n * A runner is a {@link FutureComponent}: create it standalone (e.g. via one of\n * the static factories) and it is attached to a project by the component that\n * consumes it. Use {@link TypeScriptRunner.copy} to derive a new runner with\n * adjusted options.\n */\nexport class TypeScriptRunner extends ScriptRunner {\n  /**\n   * Use ts-node to execute TypeScript files.\n   */\n  public static tsNode(options: TsNodeRunnerOptions = {}): TypeScriptRunner {\n    return new TypeScriptRunner(\"ts-node\", options);\n  }\n\n  /**\n   * Use tsx to execute TypeScript files.\n   *\n   * tsx is a fast TypeScript runtime that does not perform type-checking.\n   * You may opt-in to an explicit type-checking step before the script is run.\n   */\n  public static tsx(options: TsxRunnerOptions = {}): TypeScriptRunner {\n    return new TypeScriptRunner(\"tsx\", options);\n  }\n\n  /**\n   * Use the native Node.js TypeScript support.\n   *\n   * Requires Node.js 22.18.0 or later.\n   * The script must use ESM style imports (no directories, include file endings, etc.).\n   *\n   * Named `nodejs` (not `node`) because a runner is a construct, and `node` is\n   * reserved by `constructs.Construct` for the construct's tree node.\n   */\n  public static nodejs(options: NodeRunnerOptions = {}): TypeScriptRunner {\n    return new TypeScriptRunner(\"node\", options);\n  }\n\n  private readonly _kind: RunnerKind;\n  private readonly _options: RunnerState;\n\n  private constructor(kind: RunnerKind, options: RunnerState) {\n    super();\n    this._kind = kind;\n    this._options = options;\n  }\n\n  /**\n   * Returns a new (detached) runner of the same kind, with `overrides` merged\n   * over the current options.\n   *\n   * Safe to call while detached.\n   */\n  public copy(overrides: TypeScriptRunnerOptions = {}): TypeScriptRunner {\n    return recreate(this, this._kind, { ...this._options, ...overrides });\n  }\n\n  /**\n   * Produce the {@link RunScriptConfig} to run the given entrypoint with this\n   * runner.\n   */\n  public configFor(entrypoint: string): RunScriptConfig {\n    switch (this._kind) {\n      case \"ts-node\":\n        return this.renderTsNode(entrypoint);\n      case \"tsx\":\n        return this.renderTsx(entrypoint);\n      case \"node\":\n        return this.renderNode(entrypoint);\n    }\n  }\n\n  private renderTsNode(entrypoint: string): RunScriptConfig {\n    const typeCheck = this._options.typeCheck ?? true;\n    const swc = this._options.swc ?? false;\n\n    const command: string[] = [\"ts-node\"];\n    const dependencies: DependencyRequest[] = [{ name: \"ts-node\" }];\n\n    if (swc) {\n      dependencies.push({ name: \"@swc/core\" });\n      command.push(\"--swc\");\n    }\n\n    if (!typeCheck) {\n      command.push(\"--transpileOnly\");\n    }\n\n    if (this._options.tsconfig) {\n      command.push(\"--project\", this._options.tsconfig);\n    }\n\n    // command.push(\"--prefer-ts-exts\");\n\n    return {\n      dependencies,\n      steps: [{ execArgs: [...command, entrypoint] }],\n    };\n  }\n\n  private renderTsx(entrypoint: string): RunScriptConfig {\n    const typeCheck = this._options.typeCheck ?? false;\n\n    const command: string[] = [\"tsx\"];\n    const steps: TaskStep[] = [];\n    const dependencies: DependencyRequest[] = [{ name: \"tsx\" }];\n\n    if (this._options.tsconfig) {\n      command.push(\"--tsconfig\", this._options.tsconfig);\n    }\n\n    if (typeCheck) {\n      steps.push(typeCheckStep(this._options.tsconfig));\n    }\n\n    steps.push({ execArgs: [...command, entrypoint] });\n\n    return { dependencies, steps };\n  }\n\n  private renderNode(entrypoint: string): RunScriptConfig {\n    const typeCheck = this._options.typeCheck ?? false;\n\n    const command: string[] = [\"node\"];\n    const steps: TaskStep[] = [];\n    const dependencies: DependencyRequest[] = [];\n\n    if (this._options.experimentalTransformTypes ?? false) {\n      command.push(\"--experimental-transform-types\");\n      command.push(\"--disable-warning=ExperimentalWarning\");\n    }\n\n    if (typeCheck) {\n      steps.push(typeCheckStep(this._options.tsconfig));\n      dependencies.push({ name: \"typescript\" });\n    }\n\n    steps.push({ execArgs: [...command, entrypoint] });\n\n    return { dependencies, steps };\n  }\n}\n\nfunction typeCheckStep(tsconfig?: string): TaskStep {\n  const args = [\"tsc\", \"--noEmit\"];\n  if (tsconfig) {\n    args.push(\"-p\", tsconfig);\n  }\n  return { execArgs: args, name: \"typecheck\" };\n}\n"]}

package/lib/typescript/typescript-typedoc.js

@@ -6,7 +6,7 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
   Adds a simple Typescript documentation generator
  */
 class TypedocDocgen {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.typescript.TypedocDocgen", version: "0.101.3" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "projen.typescript.TypedocDocgen", version: "0.101.4" };
     constructor(project) {
         project.addDevDeps("typedoc");
         const docgen = project.addTask("docgen", {

package/lib/typescript/typescript.d.ts

@@ -2,6 +2,7 @@ import type { EslintOptions, NodeProjectOptions, TypeScriptCompilerOptions, Type
 import { Eslint, NodeProject, TypescriptConfig } from "../javascript";
 import type { Task } from "../task";
 import type { ProjenrcOptions as ProjenrcTsOptions } from "../typescript";
+import { TypeScriptRunner } from "../typescript";
 /**
  * @see https://kulshekhar.github.io/ts-jest/docs/getting-started/options/babelConfig/
  */
@@ -273,6 +274,15 @@ export interface TypeScriptProjectOptions extends NodeProjectOptions {
      * Options for .projenrc.ts
      */
     readonly projenrcTsOptions?: ProjenrcTsOptions;
+    /**
+     * The TypeScript runner to use for executing TypeScript files.
+     *
+     * This is a project-level setting that components (e.g. projenrc) will
+     * use as their default runner.
+     *
+     * @default TypeScriptRunner.tsNode()
+     */
+    readonly runner?: TypeScriptRunner;
     /**
      * Options for ts-jest
      */
@@ -305,6 +315,10 @@ export declare class TypeScriptProject extends NodeProject {
      * The directory in which tests reside.
      */
     readonly testdir: string;
+    /**
+     * The TypeScript runner used for executing TypeScript files.
+     */
+    readonly runner: TypeScriptRunner;
     /**
      * The "watch" task.
      */