@depup/nx 22.5.4-depup.0

package/src/plugins/js/utils/register.js

@@ -0,0 +1,406 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTsProject = registerTsProject;
+exports.getSwcTranspiler = getSwcTranspiler;
+exports.getTsNodeTranspiler = getTsNodeTranspiler;
+exports.getTranspiler = getTranspiler;
+exports.registerTranspiler = registerTranspiler;
+exports.registerTsConfigPaths = registerTsConfigPaths;
+exports.getTsNodeCompilerOptions = getTsNodeCompilerOptions;
+const path_1 = require("path");
+const logger_1 = require("../../../utils/logger");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const typescript_1 = require("./typescript");
+const swcNodeInstalled = packageIsInstalled('@swc-node/register');
+const tsNodeInstalled = packageIsInstalled('ts-node/register');
+let ts;
+let isTsEsmLoaderRegistered = false;
+/**
+ * tsx is a utility to run TypeScript files in node which is growing in popularity:
+ * https://tsx.is
+ *
+ * Behind the scenes it is invoking node with relevant --require and --import flags.
+ *
+ * If the user is invoking Nx via a script which is being invoked via tsx, then we
+ * do not need to register any transpiler at all as the environment will have already
+ * been configured by tsx. In fact, registering a transpiler such as ts-node or swc
+ * in this case causes issues.
+ *
+ * Because node is being invoked by tsx, the tsx binary does not end up in the final
+ * process.argv and so we need to check a few possible things to account for usage
+ * via different package managers (e.g. pnpm does not set process._ to tsx, but rather
+ * pnpm itself, modern yarn does not set process._ at all etc.).
+ */
+const isInvokedByTsx = (() => {
+    if (process.env._?.endsWith(`${path_1.sep}tsx`)) {
+        return true;
+    }
+    const requireArgs = [];
+    const importArgs = [];
+    (process.execArgv ?? []).forEach((arg, i) => {
+        if (arg === '-r' || arg === '--require') {
+            requireArgs.push(process.execArgv[i + 1]);
+        }
+        if (arg === '--import') {
+            importArgs.push(process.execArgv[i + 1]);
+        }
+    });
+    const isTsxPath = (p) => p.includes(`${path_1.sep}tsx${path_1.sep}`);
+    return (requireArgs.some((a) => isTsxPath(a)) ||
+        importArgs.some((a) => isTsxPath(a)));
+})();
+/**
+ * When process.features.typescript is truthy and the user has opted in via
+ * NX_PREFER_NODE_STRIP_TYPES=true, we can skip registering swc-node or ts-node
+ * transpilers since Node.js will handle TypeScript natively.
+ *
+ * This can significantly improve performance when loading TypeScript config files, but there are some things
+ * that won't work. See: https://nodejs.org/api/typescript.html#full-typescript-support
+ *
+ * TODO(v23): We should turn this on by default, but look at if need to fallback to SWC/ts-node if it fails.
+ */
+const preferNodeStripTypes = (() => {
+    if (process.env.NX_PREFER_NODE_STRIP_TYPES !== 'true') {
+        return false;
+    }
+    // process.features.typescript is 'strip' | 'transform' | false in Node 22.6+
+    return !!process.features?.typescript;
+})();
+function registerTsProject(path, configFilename) {
+    // See explanation alongside isInvokedByTsx declaration
+    if (isInvokedByTsx) {
+        return () => { };
+    }
+    const tsConfigPath = configFilename ? (0, path_1.join)(path, configFilename) : path;
+    // See explanation alongside preferNodeStripTypes declaration
+    // When using Node.js native type stripping, skip transpiler registration
+    // but still register tsconfig-paths for path mapping support
+    if (preferNodeStripTypes) {
+        return registerTsConfigPaths(tsConfigPath);
+    }
+    const { compilerOptions, tsConfigRaw } = readCompilerOptions(tsConfigPath);
+    const cleanupFunctions = [
+        registerTsConfigPaths(tsConfigPath),
+        registerTranspiler(compilerOptions, tsConfigRaw),
+    ];
+    // Add ESM support for `.ts` files.
+    // NOTE: There is no cleanup function for this, as it's not possible to unregister the loader.
+    //       Based on limited testing, it doesn't seem to matter if we register it multiple times, but just in
+    //       case let's keep a flag to prevent it.
+    if (!isTsEsmLoaderRegistered) {
+        // We need a way to ensure that `.ts` files are treated as ESM not CJS.
+        // Since there is no way to pass compilerOptions like we do with the programmatic API, we should default
+        // the environment variable that ts-node checks.
+        process.env.TS_NODE_COMPILER_OPTIONS ??= JSON.stringify({
+            moduleResolution: 'nodenext',
+            module: 'nodenext',
+        });
+        const module = require('node:module');
+        if (module.register && packageIsInstalled('ts-node/esm')) {
+            const url = require('node:url');
+            module.register(url.pathToFileURL(require.resolve('ts-node/esm')));
+        }
+        isTsEsmLoaderRegistered = true;
+    }
+    return () => {
+        for (const fn of cleanupFunctions) {
+            fn();
+        }
+    };
+}
+function getSwcTranspiler(compilerOptions) {
+    // These are requires to prevent it from registering when it shouldn't
+    const register = require('@swc-node/register/register')
+        .register;
+    const cleanupFn = register({
+        ...compilerOptions,
+        baseUrl: compilerOptions.baseUrl ?? './',
+    });
+    return typeof cleanupFn === 'function' ? cleanupFn : () => { };
+}
+function getTsNodeTranspiler(compilerOptions, tsNodeOptions, preferTsNode) {
+    const { register } = require('ts-node');
+    // ts-node doesn't provide a cleanup method
+    const service = register({
+        ...tsNodeOptions,
+        transpileOnly: true,
+        compilerOptions: getTsNodeCompilerOptions({
+            ...tsNodeOptions?.compilerOptions,
+            ...compilerOptions,
+        }),
+        // we already read and provide the compiler options, so prevent ts-node from reading them again
+        skipProject: true,
+    });
+    const { transpiler, swc } = service.options;
+    // Don't warn if a faster transpiler is enabled
+    if (!transpiler && !swc && !preferTsNode) {
+        warnTsNodeUsage();
+    }
+    return () => {
+        // Do not cleanup ts-node service since other consumers may need it
+    };
+}
+/**
+ * Given the raw "ts-node" sub-object from a tsconfig, return an object with only the properties
+ * recognized by "ts-node"
+ *
+ * Adapted from the function of the same name in ts-node
+ */
+function filterRecognizedTsConfigTsNodeOptions(jsonObject) {
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+        return { recognized: {}, unrecognized: {} };
+    }
+    const { compiler, compilerHost, compilerOptions, emit, files, ignore, ignoreDiagnostics, logError, preferTsExts, pretty, require, skipIgnore, transpileOnly, typeCheck, transpiler, scope, scopeDir, moduleTypes, experimentalReplAwait, swc, experimentalResolver, esm, experimentalSpecifierResolution, experimentalTsImportSpecifiers, ...unrecognized } = jsonObject;
+    const filteredTsConfigOptions = {
+        compiler,
+        compilerHost,
+        compilerOptions,
+        emit,
+        experimentalReplAwait,
+        files,
+        ignore,
+        ignoreDiagnostics,
+        logError,
+        preferTsExts,
+        pretty,
+        require,
+        skipIgnore,
+        transpileOnly,
+        typeCheck,
+        transpiler,
+        scope,
+        scopeDir,
+        moduleTypes,
+        swc,
+        experimentalResolver,
+        esm,
+        experimentalSpecifierResolution,
+        experimentalTsImportSpecifiers,
+    };
+    // Use the typechecker to make sure this implementation has the correct set of properties
+    const catchExtraneousProps = null;
+    const catchMissingProps = null;
+    return { recognized: filteredTsConfigOptions, unrecognized };
+}
+const registered = new Map();
+function getTranspiler(compilerOptions, tsConfigRaw) {
+    const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
+    if (!ts) {
+        ts = require('typescript');
+    }
+    compilerOptions.lib = ['es2021'];
+    compilerOptions.module = ts.ModuleKind.CommonJS;
+    // use NodeJs module resolution until support for TS 4.x is dropped and then
+    // we can switch to Node10
+    compilerOptions.moduleResolution = ts.ModuleResolutionKind.NodeJs;
+    compilerOptions.customConditions = null;
+    compilerOptions.target = ts.ScriptTarget.ES2021;
+    compilerOptions.inlineSourceMap = true;
+    compilerOptions.skipLibCheck = true;
+    // These options are different per project, and since they are not needed for transpilation, we can remove them so we have more cache hits.
+    compilerOptions.outDir = undefined;
+    compilerOptions.outFile = undefined;
+    compilerOptions.declaration = undefined;
+    compilerOptions.declarationMap = undefined;
+    compilerOptions.composite = undefined;
+    compilerOptions.tsBuildInfoFile = undefined;
+    delete compilerOptions.strict;
+    let _getTranspiler;
+    let registrationKey = JSON.stringify(compilerOptions);
+    let tsNodeOptions;
+    if (swcNodeInstalled && !preferTsNode) {
+        _getTranspiler = getSwcTranspiler;
+    }
+    else if (tsNodeInstalled) {
+        // We can fall back on ts-node if it's available
+        _getTranspiler = getTsNodeTranspiler;
+        tsNodeOptions = filterRecognizedTsConfigTsNodeOptions(tsConfigRaw?.['ts-node']).recognized;
+        // include ts-node options in the registration key
+        registrationKey += JSON.stringify(tsNodeOptions);
+    }
+    else {
+        _getTranspiler = undefined;
+    }
+    // Just return if transpiler was already registered before.
+    const registrationEntry = registered.get(registrationKey);
+    if (registered.has(registrationKey)) {
+        registrationEntry.refCount++;
+        return registrationEntry.cleanup;
+    }
+    if (_getTranspiler) {
+        const transpilerCleanup = _getTranspiler(compilerOptions, tsNodeOptions, preferTsNode);
+        const currRegistrationEntry = {
+            refCount: 1,
+            cleanup: () => {
+                return () => {
+                    currRegistrationEntry.refCount--;
+                    if (currRegistrationEntry.refCount === 0) {
+                        registered.delete(registrationKey);
+                        transpilerCleanup();
+                    }
+                };
+            },
+        };
+        registered.set(registrationKey, currRegistrationEntry);
+        return currRegistrationEntry.cleanup;
+    }
+}
+/**
+ * Register ts-node or swc-node given a set of compiler options.
+ *
+ * Note: Several options require enums from typescript. To avoid importing typescript,
+ * use import type + raw values
+ *
+ * @returns cleanup method
+ */
+function registerTranspiler(compilerOptions, tsConfigRaw) {
+    // Function to register transpiler that returns cleanup function
+    const transpiler = getTranspiler(compilerOptions, tsConfigRaw);
+    if (!transpiler) {
+        warnNoTranspiler();
+        return () => { };
+    }
+    return transpiler();
+}
+/**
+ * @param tsConfigPath Adds the paths from a tsconfig file into node resolutions
+ * @returns cleanup function
+ */
+function registerTsConfigPaths(tsConfigPath) {
+    try {
+        /**
+         * Load the ts config from the source project
+         */
+        const tsconfigPaths = loadTsConfigPaths();
+        const tsConfigResult = tsconfigPaths.loadConfig(tsConfigPath);
+        /**
+         * Register the custom workspace path mappings with node so that workspace libraries
+         * can be imported and used within project
+         */
+        if (tsConfigResult.resultType === 'success') {
+            return tsconfigPaths.register({
+                baseUrl: tsConfigResult.absoluteBaseUrl,
+                paths: tsConfigResult.paths,
+            });
+        }
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new Error(`Unable to load ${tsConfigPath}: ` + err.message);
+        }
+    }
+    throw new Error(`Unable to load ${tsConfigPath}`);
+}
+function readCompilerOptions(tsConfigPath) {
+    const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
+    if (swcNodeInstalled && !preferTsNode) {
+        return {
+            compilerOptions: readCompilerOptionsWithSwc(tsConfigPath),
+        };
+    }
+    else {
+        return readCompilerOptionsWithTypescript(tsConfigPath);
+    }
+}
+function readCompilerOptionsWithSwc(tsConfigPath) {
+    const { readDefaultTsConfig, } = require('@swc-node/register/read-default-tsconfig');
+    const compilerOptions = readDefaultTsConfig(tsConfigPath);
+    // This is returned in compiler options for some reason, but not part of the typings.
+    // @swc-node/register filters the files to transpile based on it, but it can be limiting when processing
+    // files not part of the received tsconfig included files (e.g. shared helpers, or config files not in source, etc.).
+    delete compilerOptions.files;
+    // @swc-node/register's readDefaultTsConfig auto-sets baseUrl to the
+    // dirname of the tsconfig when not explicitly configured. This is incorrect
+    // when paths are inherited via "extends" from a parent tsconfig at a
+    // different directory level (e.g., tsconfig.base.json at workspace root),
+    // because SWC will resolve "./"-prefixed paths relative to the wrong
+    // directory. Use the workspace root as baseUrl in that case.
+    // baseUrl will not be configured when using newer versions of TypeScript like `tsgo`.
+    if (compilerOptions.paths) {
+        const { options: tsOptions } = (0, typescript_1.readTsConfigWithoutFiles)(tsConfigPath);
+        if (!tsOptions.baseUrl) {
+            compilerOptions.baseUrl = workspace_root_1.workspaceRoot;
+        }
+    }
+    return compilerOptions;
+}
+function readCompilerOptionsWithTypescript(tsConfigPath) {
+    const { options, raw } = (0, typescript_1.readTsConfigWithoutFiles)(tsConfigPath);
+    // This property is returned in compiler options for some reason, but not part of the typings.
+    // ts-node fails on unknown props, so we have to remove it.
+    delete options.configFilePath;
+    return {
+        compilerOptions: options,
+        tsConfigRaw: raw,
+    };
+}
+function loadTsConfigPaths() {
+    try {
+        return require('tsconfig-paths');
+    }
+    catch {
+        warnNoTsconfigPaths();
+    }
+}
+function warnTsNodeUsage() {
+    logger_1.logger.warn((0, logger_1.stripIndent)(`${logger_1.NX_PREFIX} Falling back to ts-node for local typescript execution. This may be a little slower.
+  - To fix this, ensure @swc-node/register and @swc/core have been installed`));
+}
+function warnNoTsconfigPaths() {
+    logger_1.logger.warn((0, logger_1.stripIndent)(`${logger_1.NX_PREFIX} Unable to load tsconfig-paths, workspace libraries may be inaccessible.
+  - To fix this, install tsconfig-paths with npm/yarn/pnpm`));
+}
+function warnNoTranspiler() {
+    logger_1.logger.warn((0, logger_1.stripIndent)(`${logger_1.NX_PREFIX} Unable to locate swc-node or ts-node. Nx will be unable to run local ts files without transpiling.
+  - To fix this, ensure @swc-node/register and @swc/core have been installed`));
+}
+function packageIsInstalled(m) {
+    try {
+        const p = require.resolve(m);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * ts-node requires string values for enum based typescript options.
+ * `register`'s signature just types the field as `object`, so we
+ * unfortunately do not get any kind of type safety on this.
+ */
+function getTsNodeCompilerOptions(compilerOptions) {
+    if (!ts) {
+        ts = require('typescript');
+    }
+    const flagMap = {
+        module: 'ModuleKind',
+        target: 'ScriptTarget',
+        moduleDetection: 'ModuleDetectionKind',
+        newLine: 'NewLineKind',
+        moduleResolution: 'ModuleResolutionKind',
+        importsNotUsedAsValues: 'ImportsNotUsedAsValues',
+    };
+    const result = {
+        ...compilerOptions,
+    };
+    for (const flag in flagMap) {
+        if (compilerOptions[flag]) {
+            result[flag] = ts[flagMap[flag]][compilerOptions[flag]];
+        }
+    }
+    delete result.pathsBasePath;
+    delete result.configFilePath;
+    // instead of mapping to enum value we just remove it as it shouldn't ever need to be set for ts-node
+    delete result.jsx;
+    // lib option is in the format `lib.es2022.d.ts`, so we need to remove the leading `lib.` and trailing `.d.ts` to make it valid
+    result.lib = result.lib?.map((value) => {
+        return value.replace(/^lib\./, '').replace(/\.d\.ts$/, '');
+    });
+    if (result.moduleResolution) {
+        result.moduleResolution =
+            result.moduleResolution === 'NodeJs'
+                ? 'node'
+                : result.moduleResolution.toLowerCase();
+    }
+    return result;
+}

package/src/plugins/js/utils/resolve-relative-to-dir.d.ts

@@ -0,0 +1,6 @@
+/**
+ * NOTE: This function is in its own file because it is not possible to mock
+ * require.resolve directly in jest https://github.com/jestjs/jest/issues/9543
+ */
+export declare function resolveRelativeToDir(path: string, relativeToDir: any): string;
+//# sourceMappingURL=resolve-relative-to-dir.d.ts.map

package/src/plugins/js/utils/resolve-relative-to-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-relative-to-dir.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/plugins/js/utils/resolve-relative-to-dir.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,KAAA,GAAG,MAAM,CAQxE"}

package/src/plugins/js/utils/resolve-relative-to-dir.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelativeToDir = resolveRelativeToDir;
+/**
+ * NOTE: This function is in its own file because it is not possible to mock
+ * require.resolve directly in jest https://github.com/jestjs/jest/issues/9543
+ */
+function resolveRelativeToDir(path, relativeToDir) {
+    try {
+        return require.resolve(path, {
+            paths: [relativeToDir],
+        });
+    }
+    catch {
+        return null;
+    }
+}

package/src/plugins/js/utils/typescript.d.ts

@@ -0,0 +1,17 @@
+import type * as ts from 'typescript';
+import type { Node, SyntaxKind } from 'typescript';
+export declare function readTsConfig(tsConfigPath: string, sys?: ts.System): ts.ParsedCommandLine;
+export declare function readTsConfigWithoutFiles(tsConfigPath: string): ts.ParsedCommandLine;
+export declare function readTsConfigOptions(tsConfigPath: string): ts.CompilerOptions;
+/**
+ * Find a module based on its import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+export declare function resolveModuleByImport(importExpr: string, filePath: string, tsConfigPath: string): string;
+export declare function getRootTsConfigFileName(): string | null;
+export declare function getRootTsConfigPath(): string | null;
+export declare function findNodes(node: Node, kind: SyntaxKind | SyntaxKind[], max?: number): Node[];
+//# sourceMappingURL=typescript.d.ts.map

package/src/plugins/js/utils/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/plugins/js/utils/typescript.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAMnD,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,EACpB,GAAG,CAAC,EAAE,EAAE,CAAC,MAAM,GACd,EAAE,CAAC,iBAAiB,CAatB;AAED,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,MAAM,GACnB,EAAE,CAAC,iBAAiB,CAatB;AAED,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,EAAE,CAAC,eAAe,CAI5E;AAQD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,UAkBrB;AAYD,wBAAgB,uBAAuB,IAAI,MAAM,GAAG,IAAI,CASvD;AAED,wBAAgB,mBAAmB,IAAI,MAAM,GAAG,IAAI,CAInD;AAED,wBAAgB,SAAS,CACvB,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,EAC/B,GAAG,SAAW,GACb,IAAI,EAAE,CA6BR"}

package/src/plugins/js/utils/typescript.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTsConfig = readTsConfig;
+exports.readTsConfigWithoutFiles = readTsConfigWithoutFiles;
+exports.readTsConfigOptions = readTsConfigOptions;
+exports.resolveModuleByImport = resolveModuleByImport;
+exports.getRootTsConfigFileName = getRootTsConfigFileName;
+exports.getRootTsConfigPath = getRootTsConfigPath;
+exports.findNodes = findNodes;
+const workspace_root_1 = require("../../../utils/workspace-root");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const normalizedAppRoot = workspace_root_1.workspaceRoot.replace(/\\/g, '/');
+let tsModule;
+function readTsConfig(tsConfigPath, sys) {
+    if (!tsModule) {
+        tsModule = require('typescript');
+    }
+    sys ??= tsModule.sys;
+    const readResult = tsModule.readConfigFile(tsConfigPath, sys.readFile);
+    return tsModule.parseJsonConfigFileContent(readResult.config, sys, (0, path_1.dirname)(tsConfigPath));
+}
+function readTsConfigWithoutFiles(tsConfigPath) {
+    if (!tsModule) {
+        tsModule = require('typescript');
+    }
+    // We only care about options, so we don't need to scan source files, and thus
+    // `readDirectory` is stubbed for performance.
+    const sys = {
+        ...tsModule.sys,
+        readDirectory: () => [],
+    };
+    return readTsConfig(tsConfigPath, sys);
+}
+function readTsConfigOptions(tsConfigPath) {
+    const { options } = readTsConfigWithoutFiles(tsConfigPath);
+    return options;
+}
+let compilerHost;
+/**
+ * Find a module based on its import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+function resolveModuleByImport(importExpr, filePath, tsConfigPath) {
+    compilerHost = compilerHost || getCompilerHost(tsConfigPath);
+    const { options, host, moduleResolutionCache } = compilerHost;
+    const { resolvedModule } = tsModule.resolveModuleName(importExpr, filePath, options, host, moduleResolutionCache);
+    if (!resolvedModule) {
+        return;
+    }
+    else {
+        return resolvedModule.resolvedFileName.replace(`${normalizedAppRoot}/`, '');
+    }
+}
+function getCompilerHost(tsConfigPath) {
+    const options = readTsConfigOptions(tsConfigPath);
+    const host = tsModule.createCompilerHost(options, true);
+    const moduleResolutionCache = tsModule.createModuleResolutionCache(workspace_root_1.workspaceRoot, host.getCanonicalFileName);
+    return { options, host, moduleResolutionCache };
+}
+function getRootTsConfigFileName() {
+    for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+        const tsConfigPath = (0, path_1.join)(workspace_root_1.workspaceRoot, tsConfigName);
+        if ((0, fs_1.existsSync)(tsConfigPath)) {
+            return tsConfigName;
+        }
+    }
+    return null;
+}
+function getRootTsConfigPath() {
+    const tsConfigFileName = getRootTsConfigFileName();
+    return tsConfigFileName ? (0, path_1.join)(workspace_root_1.workspaceRoot, tsConfigFileName) : null;
+}
+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;
+}

package/src/plugins/js/versions.d.ts

@@ -0,0 +1,2 @@
+export declare const typescriptVersion = "~5.9.2";
+//# sourceMappingURL=versions.d.ts.map

package/src/plugins/js/versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versions.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/plugins/js/versions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,WAAW,CAAC"}

package/src/plugins/js/versions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptVersion = void 0;
+exports.typescriptVersion = '~5.9.2';

package/src/plugins/package-json/create-nodes.d.ts

@@ -0,0 +1,28 @@
+import { NxJsonConfiguration } from '../../config/nx-json';
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { PackageJson } from '../../utils/package-json';
+import { CreateNodesV2 } from '../../project-graph/plugins';
+import { PackageJsonConfigurationCache } from '../../../plugins/package-json';
+export declare const createNodesV2: CreateNodesV2;
+export declare function buildPackageJsonPatterns(workspaceRoot: string, readJson: (path: string) => any): PackageJsonPatterns;
+type PackageJsonPatterns = {
+    positive: string[];
+    positiveLookup: Record<string, boolean>;
+    negative: string[];
+    negativeLookup: Record<string, boolean>;
+};
+export declare function buildPackageJsonWorkspacesMatcher(patterns: PackageJsonPatterns): (p: any) => boolean;
+export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache, isInPackageManagerWorkspaces: boolean): {
+    projects: {
+        [x: string]: ProjectConfiguration;
+    };
+};
+export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, workspaceRoot: string, packageJsonPath: string, nxJson: NxJsonConfiguration, isInPackageManagerWorkspaces: boolean): ProjectConfiguration & {
+    name: string;
+};
+/**
+ * Get the package.json globs from package manager workspaces
+ */
+export declare function getGlobPatternsFromPackageManagerWorkspaces(root: string, readJson?: <T extends Object>(path: string) => T, readYaml?: <T extends Object>(path: string) => T, exists?: (path: string) => boolean): string[];
+export {};
+//# sourceMappingURL=create-nodes.d.ts.map

package/src/plugins/package-json/create-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-nodes.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/plugins/package-json/create-nodes.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAc,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAMrF,OAAO,EAEL,WAAW,EAGZ,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAEL,aAAa,EACd,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,6BAA6B,EAE9B,MAAM,+BAA+B,CAAC;AASvC,eAAO,MAAM,aAAa,EAAE,aAgD3B,CAAC;AAmBF,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,GAC9B,mBAAmB,CAqCrB;AACD,KAAK,mBAAmB,GAAG;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC,CAAC;AACF,wBAAgB,iCAAiC,CAC/C,QAAQ,EAAE,mBAAmB,IAErB,MAAC,aAeV;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,6BAA6B,EACpC,4BAA4B,EAAE,OAAO;;;;EAoCtC;AAED,wBAAgB,wCAAwC,CACtD,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,mBAAmB,EAC3B,4BAA4B,EAAE,OAAO,GACpC,oBAAoB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CA8DzC;AAED;;GAEG;AACH,wBAAgB,2CAA2C,CACzD,IAAI,EAAE,MAAM,EAEZ,QAAQ,GAAE,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,CAER,EACtC,QAAQ,GAAE,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,CAER,EACtC,MAAM,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAA0C,GACnE,MAAM,EAAE,CA+CV"}