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

package/src/generators/utils/presets.d.ts

@@ -0,0 +1,29 @@
+export declare enum Preset {
+    Apps = "apps",
+    /** @deprecated Use Apps instead
+     */
+    Empty = "empty",
+    /** @deprecated Use NPM instead
+     */
+    Core = "core",
+    NPM = "npm",
+    TS = "ts",
+    WebComponents = "web-components",
+    AngularMonorepo = "angular-monorepo",
+    AngularStandalone = "angular-standalone",
+    ReactMonorepo = "react-monorepo",
+    ReactStandalone = "react-standalone",
+    NextJsStandalone = "nextjs-standalone",
+    ReactNative = "react-native",
+    VueMonorepo = "vue-monorepo",
+    VueStandalone = "vue-standalone",
+    Nuxt = "nuxt",
+    NuxtStandalone = "nuxt-standalone",
+    Expo = "expo",
+    NextJs = "next",
+    Nest = "nest",
+    Express = "express",
+    NodeStandalone = "node-standalone",
+    NodeMonorepo = "node-monorepo",
+    TsStandalone = "ts-standalone"
+}

package/src/generators/utils/presets.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Preset = void 0;
+var Preset;
+(function (Preset) {
+    Preset["Apps"] = "apps";
+    // TODO(v19): Remove Empty and Core presets
+    /** @deprecated Use Apps instead
+     */
+    Preset["Empty"] = "empty";
+    /** @deprecated Use NPM instead
+     */
+    Preset["Core"] = "core";
+    Preset["NPM"] = "npm";
+    Preset["TS"] = "ts";
+    Preset["WebComponents"] = "web-components";
+    Preset["AngularMonorepo"] = "angular-monorepo";
+    Preset["AngularStandalone"] = "angular-standalone";
+    Preset["ReactMonorepo"] = "react-monorepo";
+    Preset["ReactStandalone"] = "react-standalone";
+    Preset["NextJsStandalone"] = "nextjs-standalone";
+    Preset["ReactNative"] = "react-native";
+    Preset["VueMonorepo"] = "vue-monorepo";
+    Preset["VueStandalone"] = "vue-standalone";
+    Preset["Nuxt"] = "nuxt";
+    Preset["NuxtStandalone"] = "nuxt-standalone";
+    Preset["Expo"] = "expo";
+    Preset["NextJs"] = "next";
+    Preset["Nest"] = "nest";
+    Preset["Express"] = "express";
+    Preset["NodeStandalone"] = "node-standalone";
+    Preset["NodeMonorepo"] = "node-monorepo";
+    Preset["TsStandalone"] = "ts-standalone";
+})(Preset || (exports.Preset = Preset = {}));

package/src/migrations/update-15-7-0/split-configuration-into-project-json-files.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare function splitConfigurationIntoProjectJsonFiles(tree: Tree): Promise<void>;
+export default splitConfigurationIntoProjectJsonFiles;

package/src/migrations/update-15-7-0/split-configuration-into-project-json-files.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitConfigurationIntoProjectJsonFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+const convert_to_nx_project_1 = require("../../generators/convert-to-nx-project/convert-to-nx-project");
+async function splitConfigurationIntoProjectJsonFiles(tree) {
+    await (0, convert_to_nx_project_1.default)(tree, { all: true });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.splitConfigurationIntoProjectJsonFiles = splitConfigurationIntoProjectJsonFiles;
+exports.default = splitConfigurationIntoProjectJsonFiles;

package/src/migrations/update-16-0-0/fix-invalid-babelrc.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function update(tree: Tree): void;

package/src/migrations/update-16-0-0/fix-invalid-babelrc.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    const packageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    // In case user installed as prod dep.
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    // If web package is installed, skip update.
+    if (deps['@nrwl/web'] || deps['@nx/web']) {
+        return;
+    }
+    projects.forEach((config, name) => {
+        const babelRcPath = (0, devkit_1.joinPathFragments)(config.root, '.babelrc');
+        if (!tree.exists(babelRcPath))
+            return;
+        const babelRc = (0, devkit_1.readJson)(tree, babelRcPath);
+        const nrwlWebBabelPresetIdx = babelRc.presets?.findIndex((p) => 
+        // Babel preset could be specified as a string or a tuple with options.
+        // Account for rescope migration running before or after this one.
+        Array.isArray(p)
+            ? p[0] === '@nrwl/web/babel' || p[0] === '@nx/web/babel'
+            : p === '@nrwl/web/babel' || p === '@nx/web/babel');
+        if (nrwlWebBabelPresetIdx === undefined || nrwlWebBabelPresetIdx === -1) {
+            return;
+        }
+        if (deps['@nrwl/js'] || deps['@nx/js']) {
+            // If JS plugin is installed, then rename to @nx/js/babel.
+            const found = babelRc.presets[nrwlWebBabelPresetIdx];
+            babelRc.presets[nrwlWebBabelPresetIdx] = Array.isArray(found)
+                ? ['@nx/js/babel', found[1]]
+                : '@nx/js/babel';
+        }
+        else {
+            // Otherwise, remove from config.
+            babelRc.presets.splice(nrwlWebBabelPresetIdx, 1);
+        }
+        (0, devkit_1.writeJson)(tree, babelRcPath, babelRc);
+    });
+}
+exports.default = update;

package/src/migrations/update-16-0-0/move-workspace-generators-to-local-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<() => void>;

package/src/migrations/update-16-0-0/move-workspace-generators-to-local-plugin.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+// nx-ignore-next-line
+const path = require("path");
+const move_1 = require("../../generators/move/move");
+const versions_1 = require("../../utils/versions");
+const path_1 = require("path");
+const get_import_path_1 = require("../../utilities/get-import-path");
+const PROJECT_NAME = 'workspace-plugin';
+const DESTINATION = `tools/${PROJECT_NAME}`;
+async function default_1(tree) {
+    if (!tree.exists('tools/generators')) {
+        return;
+    }
+    const tasks = [];
+    if (hasWorkspaceGenerators(tree)) {
+        tasks.push(...(await moveWorkspaceGeneratorsToLocalPlugin(tree)));
+    }
+    removeToolsGeneratorsIfEmpty(tree);
+    await (0, devkit_1.formatFiles)(tree);
+    return () => {
+        for (const task of tasks) {
+            task();
+        }
+    };
+}
+exports.default = default_1;
+async function moveWorkspaceGeneratorsToLocalPlugin(tree) {
+    const tasks = [];
+    let project = (0, devkit_1.getProjects)(tree).get(PROJECT_NAME);
+    if (!project) {
+        await createNewPlugin(tree);
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/plugin': versions_1.nxVersion,
+        }));
+        project = (0, devkit_1.readProjectConfiguration)(tree, PROJECT_NAME);
+    }
+    updateExistingPlugin(tree, project);
+    return tasks;
+}
+function hasWorkspaceGenerators(tree) {
+    const children = tree.children('tools/generators');
+    return (children.length > 0 &&
+        !(children.length === 1 && children[0] === '.gitkeep'));
+}
+function removeToolsGeneratorsIfEmpty(tree) {
+    if (!hasWorkspaceGenerators(tree)) {
+        tree.delete('tools/generators');
+    }
+}
+// Inspired by packages/nx/src/command-line/workspace-generators.ts
+function collectAndMoveGenerators(tree, destinationProjectRoot) {
+    const generators = {};
+    const generatorsDir = 'tools/generators';
+    const destinationDir = (0, devkit_1.joinPathFragments)(destinationProjectRoot, 'src', 'generators');
+    for (const c of tree.children('tools/generators')) {
+        const childDir = path.join(generatorsDir, c);
+        const schemaPath = (0, devkit_1.joinPathFragments)(childDir, 'schema.json');
+        if (tree.exists(schemaPath)) {
+            const schema = (0, devkit_1.readJson)(tree, schemaPath);
+            generators[c] = {
+                implementation: `./src/generators/${c}`,
+                schema: `./src/generators/${(0, devkit_1.joinPathFragments)(c, 'schema.json')}`,
+                description: schema.description ?? `Generator ${c}`,
+            };
+            moveFilesInDirectory(tree, childDir, (0, devkit_1.joinPathFragments)(destinationDir, c));
+        }
+    }
+    return generators;
+}
+function moveFilesInDirectory(tree, source, destination) {
+    const relative = path_1.posix.relative(source, path_1.posix.dirname(destination));
+    if (!relative.startsWith('../')) {
+        // If the destination is in the same directory or a subdirectory of the source
+        // we can just move the files. If it is not, we need to update the relative imports.
+        return;
+    }
+    let offsetLevel = 0;
+    const pathParts = relative.split('/');
+    for (const part of pathParts) {
+        if (part === '..') {
+            offsetLevel++;
+        }
+        else {
+            break;
+        }
+    }
+    for (const c of tree.children(source)) {
+        if (!tree.isFile(c)) {
+            moveFilesInDirectory(tree, (0, devkit_1.joinPathFragments)(source, c), (0, devkit_1.joinPathFragments)(destination, c));
+        }
+        tree.rename((0, devkit_1.joinPathFragments)(source, c), (0, devkit_1.joinPathFragments)(destination, c));
+        // If its a TS file we can update relative imports with find + replace
+        // This could be done with AST, but since we are only looking at relative
+        // imports its easy to do via string replace. We replace any strings starting
+        // with a relative path outside of their own directory.
+        if (c.endsWith('.ts')) {
+            let content = tree.read((0, devkit_1.joinPathFragments)(destination, c)).toString();
+            // +2 is a bit of a magic number here - represents extra directory levels in a normal
+            // plugin structure compared to the workspace-generator layout
+            const extraDirectoriesInPluginStructure = 2;
+            content = content.replace(new RegExp(`'` + `\.\.\/`.repeat(offsetLevel), 'g'), "'" + '../'.repeat(offsetLevel + extraDirectoriesInPluginStructure));
+            content = content.replace(new RegExp(`"` + `\.\.\/`.repeat(offsetLevel), 'g'), '"' + '../'.repeat(offsetLevel + extraDirectoriesInPluginStructure));
+            // We write it back in the same spot, since it is moved as if it was a regular file after this
+            tree.write((0, devkit_1.joinPathFragments)(source, c), content);
+        }
+        tree.rename((0, devkit_1.joinPathFragments)(source, c), (0, devkit_1.joinPathFragments)(destination, c));
+    }
+}
+async function createNewPlugin(tree) {
+    (0, devkit_1.ensurePackage)('@nx/plugin', versions_1.nxVersion);
+    const { pluginGenerator } = 
+    // nx-ignore-next-line
+    require('@nx/plugin/src/generators/plugin/plugin');
+    // nx-ignore-next-line
+    const { Linter } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
+    const npmScope = (0, get_import_path_1.getNpmScope)(tree);
+    const importPath = npmScope ? `@${npmScope}/${PROJECT_NAME}` : PROJECT_NAME;
+    await pluginGenerator(tree, {
+        minimal: true,
+        name: PROJECT_NAME,
+        importPath: importPath,
+        skipTsConfig: false,
+        compiler: 'tsc',
+        linter: Linter.EsLint,
+        skipFormat: true,
+        skipLintChecks: false,
+        unitTestRunner: 'jest',
+        e2eTestRunner: 'none',
+        publishable: false,
+    });
+    await getCreateGeneratorsJson()(tree, (0, devkit_1.readProjectConfiguration)(tree, PROJECT_NAME).root, PROJECT_NAME);
+    await moveGeneratedPlugin(tree, DESTINATION, importPath);
+}
+function moveGeneratedPlugin(tree, destination, importPath) {
+    const config = (0, devkit_1.readProjectConfiguration)(tree, PROJECT_NAME);
+    if (config.root !== DESTINATION) {
+        return (0, move_1.moveGenerator)(tree, {
+            destination,
+            projectName: PROJECT_NAME,
+            newProjectName: PROJECT_NAME,
+            updateImportPath: true,
+            importPath: importPath,
+            projectNameAndRootFormat: 'as-provided',
+        });
+    }
+}
+function updateExistingPlugin(tree, project) {
+    const packageJson = (0, devkit_1.readJson)(tree, (0, devkit_1.joinPathFragments)(project.root, 'package.json'));
+    const defaultGeneratorsPath = (0, devkit_1.joinPathFragments)(project.root, 'generators.json');
+    let generatorsJsonPath = packageJson.generators ||
+        packageJson.schematics ||
+        tree.exists(defaultGeneratorsPath)
+        ? defaultGeneratorsPath
+        : null;
+    if (!generatorsJsonPath) {
+        getCreateGeneratorsJson()(tree, (0, devkit_1.readProjectConfiguration)(tree, PROJECT_NAME).root, PROJECT_NAME);
+        generatorsJsonPath = defaultGeneratorsPath;
+    }
+    (0, devkit_1.updateJson)(tree, generatorsJsonPath, (json) => {
+        const generators = collectAndMoveGenerators(tree, project.root);
+        json.generators ??= {};
+        for (const generator in generators) {
+            if (json.generators[generator]) {
+                devkit_1.output.warn({
+                    title: `Generator ${generator} already exists in ${project.name}`,
+                    bodyLines: [
+                        'Since you have a generator with the same name in your plugin, the generator from workspace-generators has been discarded.',
+                    ],
+                });
+            }
+            else {
+                json.generators[generator] = generators[generator];
+            }
+        }
+        return json;
+    });
+}
+function getCreateGeneratorsJson() {
+    // We cant use  `as typeof import('@nx/plugin/src/generators/generator/generator');` here
+    // because it will cause a typescript error at build time.
+    const { createGeneratorsJson } = 
+    // nx-ignore-next-line
+    require('@nx/plugin/src/generators/generator/generator');
+    return createGeneratorsJson;
+}

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/workspace', '@nx/workspace');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/tasks-runner/cache.d.ts

@@ -0,0 +1 @@
+export { CachedResult, TaskWithCachedResult, Cache, } from 'nx/src/tasks-runner/cache';

package/src/tasks-runner/cache.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+var cache_1 = require("nx/src/tasks-runner/cache");
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_1.Cache; } });

package/src/tasks-runner/default-tasks-runner.d.ts

@@ -0,0 +1 @@
+export * from 'nx/src/tasks-runner/default-tasks-runner';

package/src/tasks-runner/default-tasks-runner.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("nx/src/tasks-runner/default-tasks-runner"), exports);

package/src/tasks-runner/life-cycle.d.ts

@@ -0,0 +1 @@
+export { CompositeLifeCycle, TaskMetadata, TaskResult, LifeCycle, } from 'nx/src/tasks-runner/life-cycle';

package/src/tasks-runner/life-cycle.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeLifeCycle = void 0;
+var life_cycle_1 = require("nx/src/tasks-runner/life-cycle");
+Object.defineProperty(exports, "CompositeLifeCycle", { enumerable: true, get: function () { return life_cycle_1.CompositeLifeCycle; } });

package/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle.d.ts

@@ -0,0 +1 @@
+export * from 'nx/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle';

package/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("nx/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle"), exports);

package/src/tasks-runner/tasks-runner.d.ts

@@ -0,0 +1,2 @@
+export * from 'nx/src/tasks-runner/tasks-runner';
+export { Task } from '@nx/devkit';

package/src/tasks-runner/tasks-runner.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("nx/src/tasks-runner/tasks-runner"), exports);

package/src/tasks-runner/utils.d.ts

@@ -0,0 +1 @@
+export * from 'nx/src/tasks-runner/utils';

package/src/tasks-runner/utils.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("nx/src/tasks-runner/utils"), exports);

package/src/utilities/app-root.d.ts

@@ -0,0 +1 @@
+export * from 'nx/src/utils/workspace-root';

package/src/utilities/app-root.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("nx/src/utils/workspace-root"), exports);

package/src/utilities/default-base.d.ts

@@ -0,0 +1 @@
+export declare function deduceDefaultBase(): string;

package/src/utilities/default-base.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceDefaultBase = void 0;
+const child_process_1 = require("child_process");
+function deduceDefaultBase() {
+    const nxDefaultBase = 'main';
+    try {
+        return ((0, child_process_1.execSync)('git config --get init.defaultBranch').toString().trim() ||
+            nxDefaultBase);
+    }
+    catch {
+        return nxDefaultBase;
+    }
+}
+exports.deduceDefaultBase = deduceDefaultBase;

package/src/utilities/fileutils.d.ts

@@ -0,0 +1,13 @@
+import { fileExists, directoryExists, isRelativePath, createDirectory } from 'nx/src/utils/fileutils';
+export { fileExists, directoryExists, isRelativePath, createDirectory };
+/**
+ * This method is specifically for updating a JSON file using the filesystem
+ *
+ * @remarks
+ * If you are looking to update a JSON file in a tree, look for ./ast-utils#updateJsonInTree
+ * @param path Path of the JSON file on the filesystem
+ * @param callback Manipulation of the JSON data
+ */
+export declare function updateJsonFile(path: string, callback: (a: any) => any): void;
+export declare function copyFile(file: string, target: string): void;
+export declare function renameSync(from: string, to: string, cb: (err: Error | null) => void): void;

package/src/utilities/fileutils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameSync = exports.copyFile = exports.updateJsonFile = exports.createDirectory = exports.isRelativePath = exports.directoryExists = exports.fileExists = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const fileutils_1 = require("nx/src/utils/fileutils");
+Object.defineProperty(exports, "fileExists", { enumerable: true, get: function () { return fileutils_1.fileExists; } });
+Object.defineProperty(exports, "directoryExists", { enumerable: true, get: function () { return fileutils_1.directoryExists; } });
+Object.defineProperty(exports, "isRelativePath", { enumerable: true, get: function () { return fileutils_1.isRelativePath; } });
+Object.defineProperty(exports, "createDirectory", { enumerable: true, get: function () { return fileutils_1.createDirectory; } });
+/**
+ * This method is specifically for updating a JSON file using the filesystem
+ *
+ * @remarks
+ * If you are looking to update a JSON file in a tree, look for ./ast-utils#updateJsonInTree
+ * @param path Path of the JSON file on the filesystem
+ * @param callback Manipulation of the JSON data
+ */
+function updateJsonFile(path, callback) {
+    const json = (0, fileutils_1.readJsonFile)(path);
+    callback(json);
+    (0, fileutils_1.writeJsonFile)(path, json);
+}
+exports.updateJsonFile = updateJsonFile;
+function copyFile(file, target) {
+    const f = (0, path_1.basename)(file);
+    const source = (0, fs_1.createReadStream)(file);
+    const dest = (0, fs_1.createWriteStream)((0, path_1.resolve)(target, f));
+    source.pipe(dest);
+    source.on('error', (e) => console.error(e));
+}
+exports.copyFile = copyFile;
+function renameSync(from, to, cb) {
+    try {
+        if (!(0, fs_1.existsSync)(from)) {
+            throw new Error(`Path: ${from} does not exist`);
+        }
+        else if ((0, fs_1.existsSync)(to)) {
+            throw new Error(`Path: ${to} already exists`);
+        }
+        // Make sure parent path exists
+        const parentPath = (0, path_1.resolve)(to, '..');
+        (0, fileutils_1.createDirectory)(parentPath);
+        (0, fs_1.renameSync)(from, to);
+        cb(null);
+    }
+    catch (e) {
+        cb(e);
+    }
+}
+exports.renameSync = renameSync;

package/src/utilities/get-import-path.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from 'nx/src/generators/tree';
+export declare function getImportPath(tree: Tree, projectDirectory: string): string;
+export declare function getNpmScope(tree: Tree): string;

package/src/utilities/get-import-path.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNpmScope = exports.getImportPath = void 0;
+const json_1 = require("nx/src/generators/utils/json");
+function getImportPath(tree, projectDirectory) {
+    const npmScope = getNpmScope(tree);
+    return npmScope
+        ? `${npmScope === '@' ? '' : '@'}${npmScope}/${projectDirectory}`
+        : projectDirectory;
+}
+exports.getImportPath = getImportPath;
+function getNpmScope(tree) {
+    const { name } = tree.exists('package.json')
+        ? (0, json_1.readJson)(tree, 'package.json')
+        : { name: null };
+    if (name?.startsWith('@')) {
+        return name.split('/')[0].substring(1);
+    }
+}
+exports.getNpmScope = getNpmScope;

package/src/utilities/output.d.ts

@@ -0,0 +1 @@
+export * from 'nx/src/utils/output';

package/src/utilities/output.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("nx/src/utils/output"), exports);

package/src/utilities/ts-config.d.ts

@@ -0,0 +1,7 @@
+import { Tree } from '@nx/devkit';
+import type { Node, SyntaxKind } from 'typescript';
+export declare function readTsConfig(tsConfigPath: string): import("typescript").ParsedCommandLine;
+export declare function getRootTsConfigPathInTree(tree: Tree): string | null;
+export declare function getRelativePathToRootTsConfig(tree: Tree, targetPath: string): string;
+export declare function getRootTsConfigFileName(): string | null;
+export declare function findNodes(node: Node, kind: SyntaxKind | SyntaxKind[], max?: number): Node[];

package/src/utilities/ts-config.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNodes = exports.getRootTsConfigFileName = exports.getRelativePathToRootTsConfig = exports.getRootTsConfigPathInTree = exports.readTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const typescript_1 = require("./typescript");
+let tsModule;
+function readTsConfig(tsConfigPath) {
+    if (!tsModule) {
+        tsModule = (0, typescript_1.ensureTypescript)();
+    }
+    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
+    return tsModule.parseJsonConfigFileContent(readResult.config, tsModule.sys, (0, path_1.dirname)(tsConfigPath));
+}
+exports.readTsConfig = readTsConfig;
+function getRootTsConfigPathInTree(tree) {
+    for (const path of ['tsconfig.base.json', 'tsconfig.json']) {
+        if (tree.exists(path)) {
+            return path;
+        }
+    }
+    return 'tsconfig.base.json';
+}
+exports.getRootTsConfigPathInTree = getRootTsConfigPathInTree;
+function getRelativePathToRootTsConfig(tree, targetPath) {
+    return (0, devkit_1.offsetFromRoot)(targetPath) + getRootTsConfigPathInTree(tree);
+}
+exports.getRelativePathToRootTsConfig = getRelativePathToRootTsConfig;
+function getRootTsConfigFileName() {
+    for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+        const tsConfigPath = (0, path_1.join)(devkit_1.workspaceRoot, tsConfigName);
+        if ((0, fs_1.existsSync)(tsConfigPath)) {
+            return tsConfigName;
+        }
+    }
+    return null;
+}
+exports.getRootTsConfigFileName = getRootTsConfigFileName;
+function findNodes(node, kind, max = Infinity) {
+    if (!node || max == 0) {
+        return [];
+    }
+    const arr = [];
+    const hasMatch = Array.isArray(kind)
+        ? kind.includes(node.kind)
+        : node.kind === kind;
+    if (hasMatch) {
+        arr.push(node);
+        max--;
+    }
+    if (max > 0) {
+        for (const child of node.getChildren()) {
+            findNodes(child, kind, max).forEach((node) => {
+                if (max > 0) {
+                    arr.push(node);
+                }
+                max--;
+            });
+            if (max <= 0) {
+                break;
+            }
+        }
+    }
+    return arr;
+}
+exports.findNodes = findNodes;

package/src/utilities/typescript/compilation.d.ts

@@ -0,0 +1,22 @@
+import type * as ts from 'typescript';
+import type { CustomTransformers, Diagnostic, Program } from 'typescript';
+export interface TypeScriptCompilationOptions {
+    outputPath: string;
+    projectName: string;
+    projectRoot: string;
+    tsConfig: string;
+    deleteOutputPath?: boolean;
+    rootDir?: string;
+    watch?: boolean;
+    getCustomTransformers?(program: Program): CustomTransformers;
+}
+export interface TypescriptWatchChangeEvent {
+    diagnostic: ts.Diagnostic;
+    newLine: string;
+    options: ts.CompilerOptions;
+    errorCount: number;
+}
+export declare function compileTypeScript(options: TypeScriptCompilationOptions): {
+    success: boolean;
+};
+export declare function compileTypeScriptWatcher(options: TypeScriptCompilationOptions, callback: (diagnostic: Diagnostic, newLine: string, options: ts.CompilerOptions, errorCount: number) => void | Promise<void>): ts.WatchOfFilesAndCompilerOptions<ts.BuilderProgram>;