@nx/js 0.0.0-pr-22179-271588f

package/src/executors/tsc/schema.json

@@ -0,0 +1,163 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "Typescript Build Target",
+  "description": "Builds using TypeScript.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "main": {
+      "type": "string",
+      "description": "The name of the main entry-point file.",
+      "x-completion-type": "file",
+      "x-completion-glob": "main@(.js|.ts|.jsx|.tsx)",
+      "x-priority": "important"
+    },
+    "generateExportsField": {
+      "type": "boolean",
+      "alias": "exports",
+      "description": "Update the output package.json file's 'exports' field. This field is used by Node and bundles.",
+      "default": false,
+      "x-priority": "important"
+    },
+    "additionalEntryPoints": {
+      "type": "array",
+      "description": "Additional entry-points to add to exports field in the package.json file.",
+      "items": {
+        "type": "string"
+      },
+      "x-priority": "important"
+    },
+    "rootDir": {
+      "type": "string",
+      "description": "Sets the rootDir for TypeScript compilation. When not defined, it uses the root of project."
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "The output path of the generated files.",
+      "x-completion-type": "directory",
+      "x-priority": "important"
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The path to the Typescript configuration file.",
+      "x-completion-type": "file",
+      "x-completion-glob": "tsconfig.*.json",
+      "x-priority": "important"
+    },
+    "assets": {
+      "type": "array",
+      "description": "List of static assets.",
+      "default": [],
+      "items": {
+        "$ref": "#/definitions/assetPattern"
+      }
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Enable re-building when files change.",
+      "default": false
+    },
+    "clean": {
+      "type": "boolean",
+      "description": "Remove previous output before build.",
+      "default": true
+    },
+    "transformers": {
+      "type": "array",
+      "description": "List of TypeScript Transformer Plugins.",
+      "default": [],
+      "items": {
+        "$ref": "#/definitions/transformerPattern"
+      },
+      "x-priority": "important"
+    },
+    "external": {
+      "description": "A list projects to be treated as external. This feature is experimental",
+      "oneOf": [
+        {
+          "type": "string",
+          "enum": ["all", "none"]
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ]
+    },
+    "externalBuildTargets": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of target names that annotate a build target for a project",
+      "default": ["build"]
+    },
+    "generateLockfile": {
+      "type": "boolean",
+      "description": "Generate a lockfile (e.g. package-lock.json) that matches the workspace lockfile to ensure package versions match.",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["main", "outputPath", "tsConfig"],
+  "definitions": {
+    "assetPattern": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "glob": {
+              "type": "string",
+              "description": "The pattern to match."
+            },
+            "input": {
+              "type": "string",
+              "description": "The input directory path in which to apply 'glob'. Defaults to the project root."
+            },
+            "ignore": {
+              "description": "An array of globs to ignore.",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "output": {
+              "type": "string",
+              "description": "Absolute path within the output."
+            }
+          },
+          "additionalProperties": false,
+          "required": ["glob", "input", "output"]
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "transformerPattern": {
+      "oneOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string"
+            },
+            "options": {
+              "type": "object",
+              "additionalProperties": true
+            }
+          },
+          "additionalProperties": false,
+          "required": ["name"]
+        }
+      ]
+    }
+  },
+  "examplesFile": "../../../docs/tsc-examples.md"
+}

package/src/executors/tsc/tsc.batch-impl.d.ts

@@ -0,0 +1,5 @@
+import { ExecutorContext, TaskGraph } from '@nx/devkit';
+import type { BatchExecutorTaskResult } from 'nx/src/config/misc-interfaces';
+import type { ExecutorOptions } from '../../utils/schema';
+export declare function tscBatchExecutor(taskGraph: TaskGraph, inputs: Record<string, ExecutorOptions>, overrides: ExecutorOptions, context: ExecutorContext): AsyncGenerator<BatchExecutorTaskResult, any, unknown>;
+export default tscBatchExecutor;

package/src/executors/tsc/tsc.batch-impl.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tscBatchExecutor = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const async_iterator_1 = require("nx/src/utils/async-iterator");
+const update_package_json_1 = require("../../utils/package-json/update-package-json");
+const tsc_impl_1 = require("./tsc.impl");
+const lib_1 = require("./lib");
+const batch_1 = require("./lib/batch");
+const create_entry_points_1 = require("../../utils/package-json/create-entry-points");
+async function* tscBatchExecutor(taskGraph, inputs, overrides, context) {
+    const tasksOptions = (0, batch_1.normalizeTasksOptions)(inputs, context);
+    let shouldWatch = false;
+    Object.values(tasksOptions).forEach((taskOptions) => {
+        if (taskOptions.clean) {
+            (0, fs_1.rmSync)(taskOptions.outputPath, { force: true, recursive: true });
+        }
+        if (taskOptions.watch) {
+            shouldWatch = true;
+        }
+    });
+    const taskInMemoryTsConfigMap = (0, lib_1.getProcessedTaskTsConfigs)(Object.keys(taskGraph.tasks), tasksOptions, context);
+    const tsConfigTaskInfoMap = (0, batch_1.createTaskInfoPerTsConfigMap)(tasksOptions, context, Object.keys(taskGraph.tasks), taskInMemoryTsConfigMap);
+    const tsCompilationContext = createTypescriptCompilationContext(tsConfigTaskInfoMap, taskInMemoryTsConfigMap, context);
+    const logger = {
+        error: (message, tsConfig) => {
+            process.stderr.write(message);
+            if (tsConfig) {
+                tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+            }
+        },
+        info: (message, tsConfig) => {
+            process.stdout.write(message);
+            if (tsConfig) {
+                tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+            }
+        },
+        warn: (message, tsConfig) => {
+            process.stdout.write(message);
+            if (tsConfig) {
+                tsConfigTaskInfoMap[tsConfig].terminalOutput += message;
+            }
+        },
+    };
+    const processTaskPostCompilation = (tsConfig) => {
+        if (tsConfigTaskInfoMap[tsConfig]) {
+            const taskInfo = tsConfigTaskInfoMap[tsConfig];
+            taskInfo.assetsHandler.processAllAssetsOnceSync();
+            (0, update_package_json_1.updatePackageJson)({
+                ...taskInfo.options,
+                additionalEntryPoints: (0, create_entry_points_1.createEntryPoints)(taskInfo.options.additionalEntryPoints, context.root),
+                format: [(0, tsc_impl_1.determineModuleFormatFromTsConfig)(tsConfig)],
+                // As long as d.ts files match their .js counterparts, we don't need to emit them.
+                // TSC can match them correctly based on file names.
+                skipTypings: true,
+            }, taskInfo.context, taskInfo.projectGraphNode, taskInfo.buildableProjectNodeDependencies);
+            taskInfo.endTime = Date.now();
+        }
+    };
+    const typescriptCompilation = (0, lib_1.compileTypescriptSolution)(tsCompilationContext, shouldWatch, logger, {
+        beforeProjectCompilationCallback: (tsConfig) => {
+            if (tsConfigTaskInfoMap[tsConfig]) {
+                tsConfigTaskInfoMap[tsConfig].startTime = Date.now();
+            }
+        },
+        afterProjectCompilationCallback: processTaskPostCompilation,
+    });
+    if (shouldWatch) {
+        const taskInfos = Object.values(tsConfigTaskInfoMap);
+        const watchAssetsChangesDisposer = await (0, batch_1.watchTaskProjectsFileChangesForAssets)(taskInfos);
+        const watchProjectsChangesDisposer = await (0, batch_1.watchTaskProjectsPackageJsonFileChanges)(taskInfos, (changedTaskInfos) => {
+            for (const t of changedTaskInfos) {
+                (0, update_package_json_1.updatePackageJson)({
+                    ...t.options,
+                    additionalEntryPoints: (0, create_entry_points_1.createEntryPoints)(t.options.additionalEntryPoints, context.root),
+                    format: [(0, tsc_impl_1.determineModuleFormatFromTsConfig)(t.options.tsConfig)],
+                    // As long as d.ts files match their .js counterparts, we don't need to emit them.
+                    // TSC can match them correctly based on file names.
+                    skipTypings: true,
+                }, t.context, t.projectGraphNode, t.buildableProjectNodeDependencies);
+            }
+        });
+        const handleTermination = async (exitCode) => {
+            watchAssetsChangesDisposer();
+            watchProjectsChangesDisposer();
+            process.exit(exitCode);
+        };
+        process.on('SIGINT', () => handleTermination(128 + 2));
+        process.on('SIGTERM', () => handleTermination(128 + 15));
+        return yield* mapAsyncIterable(typescriptCompilation, async (iterator) => {
+            // drain the iterator, we don't use the results
+            await (0, async_iterator_1.getLastValueFromAsyncIterableIterator)(iterator);
+            return { value: undefined, done: true };
+        });
+    }
+    const toBatchExecutorTaskResult = (tsConfig, success) => ({
+        task: tsConfigTaskInfoMap[tsConfig].task,
+        result: {
+            success: success,
+            terminalOutput: tsConfigTaskInfoMap[tsConfig].terminalOutput,
+            startTime: tsConfigTaskInfoMap[tsConfig].startTime,
+            endTime: tsConfigTaskInfoMap[tsConfig].endTime,
+        },
+    });
+    let isCompilationDone = false;
+    const taskTsConfigsToReport = new Set(Object.keys(taskGraph.tasks).map((t) => taskInMemoryTsConfigMap[t].path));
+    let tasksToReportIterator;
+    const processSkippedTasks = () => {
+        const { value: tsConfig, done } = tasksToReportIterator.next();
+        if (done) {
+            return { value: undefined, done: true };
+        }
+        tsConfigTaskInfoMap[tsConfig].startTime = Date.now();
+        processTaskPostCompilation(tsConfig);
+        return { value: toBatchExecutorTaskResult(tsConfig, true), done: false };
+    };
+    return yield* mapAsyncIterable(typescriptCompilation, async (iterator) => {
+        if (isCompilationDone) {
+            return processSkippedTasks();
+        }
+        const { value, done } = await iterator.next();
+        if (done) {
+            if (taskTsConfigsToReport.size > 0) {
+                /**
+                 * TS compilation is done but we still have tasks to report. This can
+                 * happen if, for example, a project is identified as affected, but
+                 * no file in the TS project is actually changed or if running a
+                 * task with `--skip-nx-cache` and the outputs are already there. There
+                 * can still be changes to assets or other files we need to process.
+                 *
+                 * Switch to handle the iterator for the tasks we still need to report.
+                 */
+                isCompilationDone = true;
+                tasksToReportIterator = taskTsConfigsToReport.values();
+                return processSkippedTasks();
+            }
+            return { value: undefined, done: true };
+        }
+        taskTsConfigsToReport.delete(value.tsConfig);
+        return {
+            value: toBatchExecutorTaskResult(value.tsConfig, value.success),
+            done: false,
+        };
+    });
+}
+exports.tscBatchExecutor = tscBatchExecutor;
+exports.default = tscBatchExecutor;
+async function* mapAsyncIterable(iterable, nextFn) {
+    return yield* {
+        [Symbol.asyncIterator]() {
+            const iterator = iterable[Symbol.asyncIterator].call(iterable);
+            return {
+                async next() {
+                    return await nextFn(iterator);
+                },
+            };
+        },
+    };
+}
+function createTypescriptCompilationContext(tsConfigTaskInfoMap, taskInMemoryTsConfigMap, context) {
+    const tsCompilationContext = Object.entries(tsConfigTaskInfoMap).reduce((acc, [tsConfig, taskInfo]) => {
+        acc[tsConfig] = {
+            project: taskInfo.context.projectName,
+            tsConfig: taskInfo.tsConfig,
+            transformers: taskInfo.options.transformers,
+        };
+        return acc;
+    }, {});
+    Object.entries(taskInMemoryTsConfigMap).forEach(([task, tsConfig]) => {
+        if (!tsCompilationContext[tsConfig.path]) {
+            tsCompilationContext[tsConfig.path] = {
+                project: (0, devkit_1.parseTargetString)(task, context).project,
+                transformers: [],
+                tsConfig: tsConfig,
+            };
+        }
+    });
+    return tsCompilationContext;
+}

package/src/executors/tsc/tsc.impl.d.ts

@@ -0,0 +1,7 @@
+import { ExecutorContext } from '@nx/devkit';
+import type { TypeScriptCompilationOptions } from '@nx/workspace/src/utilities/typescript/compilation';
+import { ExecutorOptions, NormalizedExecutorOptions } from '../../utils/schema';
+export declare function determineModuleFormatFromTsConfig(absolutePathToTsConfig: string): 'cjs' | 'esm';
+export declare function createTypeScriptCompilationOptions(normalizedOptions: NormalizedExecutorOptions, context: ExecutorContext): TypeScriptCompilationOptions;
+export declare function tscExecutor(_options: ExecutorOptions, context: ExecutorContext): AsyncGenerator<import("../../utils/typescript/compile-typescript-files").TypescriptCompilationResult, any, undefined>;
+export default tscExecutor;

package/src/executors/tsc/tsc.impl.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tscExecutor = exports.createTypeScriptCompilationOptions = exports.determineModuleFormatFromTsConfig = void 0;
+const ts = require("typescript");
+const copy_assets_handler_1 = require("../../utils/assets/copy-assets-handler");
+const check_dependencies_1 = require("../../utils/check-dependencies");
+const compiler_helper_dependency_1 = require("../../utils/compiler-helper-dependency");
+const inline_1 = require("../../utils/inline");
+const update_package_json_1 = require("../../utils/package-json/update-package-json");
+const compile_typescript_files_1 = require("../../utils/typescript/compile-typescript-files");
+const watch_for_single_file_changes_1 = require("../../utils/watch-for-single-file-changes");
+const lib_1 = require("./lib");
+const ts_config_1 = require("../../utils/typescript/ts-config");
+const create_entry_points_1 = require("../../utils/package-json/create-entry-points");
+function determineModuleFormatFromTsConfig(absolutePathToTsConfig) {
+    const tsConfig = (0, ts_config_1.readTsConfig)(absolutePathToTsConfig);
+    if (tsConfig.options.module === ts.ModuleKind.ES2015 ||
+        tsConfig.options.module === ts.ModuleKind.ES2020 ||
+        tsConfig.options.module === ts.ModuleKind.ES2022 ||
+        tsConfig.options.module === ts.ModuleKind.ESNext) {
+        return 'esm';
+    }
+    else {
+        return 'cjs';
+    }
+}
+exports.determineModuleFormatFromTsConfig = determineModuleFormatFromTsConfig;
+function createTypeScriptCompilationOptions(normalizedOptions, context) {
+    return {
+        outputPath: normalizedOptions.outputPath,
+        projectName: context.projectName,
+        projectRoot: normalizedOptions.projectRoot,
+        rootDir: normalizedOptions.rootDir,
+        tsConfig: normalizedOptions.tsConfig,
+        watch: normalizedOptions.watch,
+        deleteOutputPath: normalizedOptions.clean,
+        getCustomTransformers: (0, lib_1.getCustomTrasformersFactory)(normalizedOptions.transformers),
+    };
+}
+exports.createTypeScriptCompilationOptions = createTypeScriptCompilationOptions;
+async function* tscExecutor(_options, context) {
+    const { sourceRoot, root } = context.projectsConfigurations.projects[context.projectName];
+    const options = (0, lib_1.normalizeOptions)(_options, context.root, sourceRoot, root);
+    const { projectRoot, tmpTsConfig, target, dependencies } = (0, check_dependencies_1.checkDependencies)(context, options.tsConfig);
+    if (tmpTsConfig) {
+        options.tsConfig = tmpTsConfig;
+    }
+    const tsLibDependency = (0, compiler_helper_dependency_1.getHelperDependency)(compiler_helper_dependency_1.HelperDependency.tsc, options.tsConfig, dependencies, context.projectGraph);
+    if (tsLibDependency) {
+        dependencies.push(tsLibDependency);
+    }
+    const assetHandler = new copy_assets_handler_1.CopyAssetsHandler({
+        projectDir: projectRoot,
+        rootDir: context.root,
+        outputDir: _options.outputPath,
+        assets: _options.assets,
+    });
+    const tsCompilationOptions = createTypeScriptCompilationOptions(options, context);
+    const inlineProjectGraph = (0, inline_1.handleInliningBuild)(context, options, tsCompilationOptions.tsConfig);
+    if (!(0, inline_1.isInlineGraphEmpty)(inlineProjectGraph)) {
+        tsCompilationOptions.rootDir = '.';
+    }
+    const typescriptCompilation = (0, compile_typescript_files_1.compileTypeScriptFiles)(options, tsCompilationOptions, async () => {
+        await assetHandler.processAllAssetsOnce();
+        (0, update_package_json_1.updatePackageJson)({
+            ...options,
+            additionalEntryPoints: (0, create_entry_points_1.createEntryPoints)(options.additionalEntryPoints, context.root),
+            format: [determineModuleFormatFromTsConfig(options.tsConfig)],
+            // As long as d.ts files match their .js counterparts, we don't need to emit them.
+            // TSC can match them correctly based on file names.
+            skipTypings: true,
+        }, context, target, dependencies);
+        (0, inline_1.postProcessInlinedDependencies)(tsCompilationOptions.outputPath, tsCompilationOptions.projectRoot, inlineProjectGraph);
+    });
+    if (options.watch) {
+        const disposeWatchAssetChanges = await assetHandler.watchAndProcessOnAssetChange();
+        const disposePackageJsonChanges = await (0, watch_for_single_file_changes_1.watchForSingleFileChanges)(context.projectName, options.projectRoot, 'package.json', () => (0, update_package_json_1.updatePackageJson)({
+            ...options,
+            additionalEntryPoints: (0, create_entry_points_1.createEntryPoints)(options.additionalEntryPoints, context.root),
+            // As long as d.ts files match their .js counterparts, we don't need to emit them.
+            // TSC can match them correctly based on file names.
+            skipTypings: true,
+            format: [determineModuleFormatFromTsConfig(options.tsConfig)],
+        }, context, target, dependencies));
+        const handleTermination = async (exitCode) => {
+            await typescriptCompilation.close();
+            disposeWatchAssetChanges();
+            disposePackageJsonChanges();
+            process.exit(exitCode);
+        };
+        process.on('SIGINT', () => handleTermination(128 + 2));
+        process.on('SIGTERM', () => handleTermination(128 + 15));
+    }
+    return yield* typescriptCompilation.iterator;
+}
+exports.tscExecutor = tscExecutor;
+exports.default = tscExecutor;

package/src/executors/verdaccio/schema.d.ts

@@ -0,0 +1,7 @@
+export interface VerdaccioExecutorSchema {
+  location: 'global' | 'user' | 'project' | 'none';
+  storage?: string;
+  port: number;
+  config?: string;
+  clear?: boolean;
+}

package/src/executors/verdaccio/schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Verdaccio Local Registry",
+  "description": "Start a local registry with Verdaccio.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "location": {
+      "type": "string",
+      "description": "Location option for npm config",
+      "default": "user",
+      "enum": ["global", "user", "project", "none"]
+    },
+    "storage": {
+      "type": "string",
+      "description": "Path to the custom storage directory for Verdaccio"
+    },
+    "port": {
+      "type": "number",
+      "description": "Port of local registry that Verdaccio should listen to",
+      "default": 4873
+    },
+    "config": {
+      "type": "string",
+      "description": "Path to the custom Verdaccio config file"
+    },
+    "clear": {
+      "type": "boolean",
+      "description": "Clear local registry storage before starting Verdaccio",
+      "default": true
+    }
+  },
+  "required": ["port"]
+}

package/src/executors/verdaccio/verdaccio.impl.d.ts

@@ -0,0 +1,12 @@
+import { ExecutorContext } from '@nx/devkit';
+import { VerdaccioExecutorSchema } from './schema';
+/**
+ * - set npm and yarn to use local registry
+ * - start verdaccio
+ * - stop local registry when done
+ */
+export declare function verdaccioExecutor(options: VerdaccioExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+    port: number;
+}>;
+export default verdaccioExecutor;