@ohos-ports/nx 19.8.4-beta.2 → 20.8.4-beta.1

package/src/project-graph/plugins/load-resolved-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { PluginConfiguration } from '../../config/nx-json';
+import { LoadedNxPlugin } from './loaded-nx-plugin';
+export declare function loadResolvedNxPluginAsync(pluginConfiguration: PluginConfiguration, pluginPath: string, name: string): Promise<LoadedNxPlugin>;

package/src/project-graph/plugins/load-resolved-plugin.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResolvedNxPluginAsync = loadResolvedNxPluginAsync;
+const loaded_nx_plugin_1 = require("./loaded-nx-plugin");
+async function loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name) {
+    const plugin = await importPluginModule(pluginPath);
+    plugin.name ??= name;
+    return new loaded_nx_plugin_1.LoadedNxPlugin(plugin, pluginConfiguration);
+}
+async function importPluginModule(pluginPath) {
+    const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));
+    if (m.default &&
+        ('createNodes' in m.default ||
+            'createNodesV2' in m.default ||
+            'createDependencies' in m.default ||
+            'createMetadata' in m.default ||
+            'preTasksExecution' in m.default ||
+            'postTasksExecution' in m.default)) {
+        return m.default;
+    }
+    return m;
+}

package/src/project-graph/plugins/loaded-nx-plugin.d.ts

@@ -0,0 +1,20 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import { type PluginConfiguration } from '../../config/nx-json';
+import type { RawProjectGraphDependency } from '../project-graph-builder';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
+export declare class LoadedNxPlugin {
+    index?: number;
+    readonly name: string;
+    readonly createNodes?: [
+        filePattern: string,
+        fn: (matchedFiles: string[], context: CreateNodesContextV2) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
+    ];
+    readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
+    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
+    readonly preTasksExecution?: (context: PreTasksExecutionContext) => Promise<NodeJS.ProcessEnv>;
+    readonly postTasksExecution?: (context: PostTasksExecutionContext) => Promise<void>;
+    readonly options?: unknown;
+    readonly include?: string[];
+    readonly exclude?: string[];
+    constructor(plugin: NxPluginV2, pluginDefinition: PluginConfiguration);
+}

package/src/project-graph/plugins/loaded-nx-plugin.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadedNxPlugin = void 0;
+const error_types_1 = require("../error-types");
+const utils_1 = require("./utils");
+const enabled_1 = require("./isolation/enabled");
+const client_1 = require("../../daemon/client/client");
+class LoadedNxPlugin {
+    constructor(plugin, pluginDefinition) {
+        this.name = plugin.name;
+        if (typeof pluginDefinition !== 'string') {
+            this.options = pluginDefinition.options;
+            this.include = pluginDefinition.include;
+            this.exclude = pluginDefinition.exclude;
+        }
+        if (plugin.createNodes && !plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodes[0],
+                (configFiles, context) => (0, utils_1.createNodesFromFiles)(plugin.createNodes[1], configFiles, this.options, context).then((results) => results.map((r) => [this.name, r[0], r[1]])),
+            ];
+        }
+        if (plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodesV2[0],
+                async (configFiles, context) => {
+                    const result = await plugin.createNodesV2[1](configFiles, this.options, context);
+                    return result.map((r) => [this.name, r[0], r[1]]);
+                },
+            ];
+        }
+        if (this.createNodes) {
+            const inner = this.createNodes[1];
+            this.createNodes[1] = async (...args) => {
+                performance.mark(`${plugin.name}:createNodes - start`);
+                try {
+                    return await inner(...args);
+                }
+                catch (e) {
+                    if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
+                        throw e;
+                    }
+                    // The underlying plugin errored out. We can't know any partial results.
+                    throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
+                }
+                finally {
+                    performance.mark(`${plugin.name}:createNodes - end`);
+                    performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+                }
+            };
+        }
+        if (plugin.createDependencies) {
+            this.createDependencies = async (context) => plugin.createDependencies(this.options, context);
+        }
+        if (plugin.createMetadata) {
+            this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
+        }
+        if (plugin.preTasksExecution) {
+            this.preTasksExecution = async (context) => {
+                const updates = {};
+                let originalEnv = process.env;
+                if ((0, enabled_1.isIsolationEnabled)() || (0, client_1.isDaemonEnabled)()) {
+                    process.env = new Proxy(originalEnv, {
+                        set: (target, key, value) => {
+                            target[key] = value;
+                            updates[key] = value;
+                            return true;
+                        },
+                    });
+                }
+                await plugin.preTasksExecution(this.options, context);
+                process.env = originalEnv;
+                return updates;
+            };
+        }
+        if (plugin.postTasksExecution) {
+            this.postTasksExecution = async (context) => plugin.postTasksExecution(this.options, context);
+        }
+    }
+}
+exports.LoadedNxPlugin = LoadedNxPlugin;

package/src/project-graph/plugins/public-api.d.ts

@@ -1,8 +1,8 @@
-import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import { NxJsonConfiguration } from '../../config/nx-json';
-import { RawProjectGraphDependency } from '../project-graph-builder';
+import type { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { NxJsonConfiguration } from '../../config/nx-json';
+import type { RawProjectGraphDependency } from '../project-graph-builder';
+import type { TaskResults } from '../../tasks-runner/life-cycle';
 /**
  * Context for {@link CreateNodesFunction}
  */
@@ -38,12 +38,12 @@ export interface CreateNodesResult {
  * A pair of file patterns and {@link CreateNodesFunction}
  *
  * Nx 19.2+: Both original `CreateNodes` and `CreateNodesV2` are supported. Nx will only invoke `CreateNodesV2` if it is present.
- * Nx 20.X : The `CreateNodesV2` will be the only supported API. This typing will still exist, but be identical to `CreateNodesV2`.
+ * Nx 21.X : The `CreateNodesV2` will be the only supported API. This typing will still exist, but be identical to `CreateNodesV2`.
              Nx **will not** invoke the original `plugin.createNodes` callback. This should give plugin authors a window to transition.
              Plugin authors should update their plugin's `createNodes` function to align with `CreateNodesV2` / the updated `CreateNodes`.
              The plugin should contain something like: `export createNodes = createNodesV2;` during this period. This will allow the plugin
              to maintain compatibility with Nx 19.2 and up.
- * Nx 21.X : The `CreateNodesV2` typing will be removed, as it has replaced `CreateNodes`.
+ * Nx 22.X : The `CreateNodesV2` typing will be removed, as it has replaced `CreateNodes`.
  *
  * @deprecated Use {@link CreateNodesV2} instead. CreateNodesV2 will replace this API. Read more about the transition above.
  */
@@ -53,7 +53,7 @@ export type CreateNodes<T = unknown> = readonly [
 ];
 /**
  * A pair of file patterns and {@link CreateNodesFunctionV2}
- * In Nx 20 {@link CreateNodes} will be replaced with this type. In Nx 21, this type will be removed.
+ * In Nx 21 {@link CreateNodes} will be replaced with this type. In Nx 22, this type will be removed.
  */
 export type CreateNodesV2<T = unknown> = readonly [
     projectFilePattern: string,
@@ -97,7 +97,7 @@ export type CreateMetadataContext = {
 export type ProjectsMetadata = Record<string, Pick<ProjectConfiguration, 'metadata'>>;
 export type CreateMetadata<T = unknown> = (graph: ProjectGraph, options: T | undefined, context: CreateMetadataContext) => ProjectsMetadata | Promise<ProjectsMetadata>;
 /**
- * A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
+ * A plugin which enhances the behavior of Nx
  */
 export type NxPluginV2<TOptions = unknown> = {
     name: string;
@@ -105,14 +105,14 @@ export type NxPluginV2<TOptions = unknown> = {
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
      *
-     * @deprecated Use {@link createNodesV2} instead. In Nx 20 support for calling createNodes with a single file for the first argument will be removed.
+     * @deprecated Use {@link createNodesV2} instead. In Nx 21 support for calling createNodes with a single file for the first argument will be removed.
      */
     createNodes?: CreateNodes<TOptions>;
     /**
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFiles }
      *
-     * In Nx 20 {@link createNodes} will be replaced with this property. In Nx 21, this property will be removed.
+     * In Nx 21 {@link createNodes} will be replaced with this property. In Nx 22, this property will be removed.
      */
     createNodesV2?: CreateNodesV2<TOptions>;
     /**
@@ -123,8 +123,27 @@ export type NxPluginV2<TOptions = unknown> = {
      * Provides a function to create metadata for the {@link ProjectGraph}
      */
     createMetadata?: CreateMetadata<TOptions>;
+    /**
+     * Provides a function to run before the Nx runs tasks
+     */
+    preTasksExecution?: PreTasksExecution<TOptions>;
+    /**
+     * Provides a function to run after the Nx runs tasks
+     */
+    postTasksExecution?: PostTasksExecution<TOptions>;
+};
+export type PreTasksExecutionContext = {
+    readonly workspaceRoot: string;
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+};
+export type PostTasksExecutionContext = {
+    readonly workspaceRoot: string;
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly taskResults: TaskResults;
 };
+export type PreTasksExecution<TOptions = unknown> = (options: TOptions | undefined, context: PreTasksExecutionContext) => void | Promise<void>;
+export type PostTasksExecution<TOptions = unknown> = (options: TOptions | undefined, context: PostTasksExecutionContext) => void | Promise<void>;
 /**
- * A plugin for Nx
+ * A plugin which enhances the behavior of Nx
  */
-export type NxPlugin = NxPluginV1 | NxPluginV2;
+export type NxPlugin = NxPluginV2;

package/src/project-graph/plugins/resolve-plugin.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export declare function resolveNxPlugin(moduleName: string, root: string, paths: string[]): Promise<{
+    pluginPath: string;
+    name: any;
+    shouldRegisterTSTranspiler: boolean;
+}>;
+export declare function resolveLocalNxPlugin(importPath: string, projects: Record<string, ProjectConfiguration>, root?: string): {
+    path: string;
+    projectConfig: ProjectConfiguration;
+} | null;
+export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
+    pluginPath: string;
+    name: any;
+    shouldRegisterTSTranspiler: boolean;
+};

package/src/project-graph/plugins/resolve-plugin.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNxPlugin = resolveNxPlugin;
+exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
+exports.getPluginPathAndName = getPluginPathAndName;
+const path = require("node:path");
+const node_fs_1 = require("node:fs");
+const packages_1 = require("../../plugins/js/utils/packages");
+const fileutils_1 = require("../../utils/fileutils");
+const logger_1 = require("../../utils/logger");
+const path_1 = require("../../utils/path");
+const workspace_root_1 = require("../../utils/workspace-root");
+const find_project_for_path_1 = require("../utils/find-project-for-path");
+const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
+let projectsWithoutInference;
+async function resolveNxPlugin(moduleName, root, paths) {
+    try {
+        require.resolve(moduleName);
+    }
+    catch {
+        // If a plugin cannot be resolved, we will need projects to resolve it
+        projectsWithoutInference ??=
+            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+    }
+    const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+    return { pluginPath, name, shouldRegisterTSTranspiler };
+}
+function readPluginMainFromProjectConfiguration(plugin) {
+    const { main } = Object.values(plugin.targets).find((x) => [
+        '@nx/js:tsc',
+        '@nrwl/js:tsc',
+        '@nx/js:swc',
+        '@nrwl/js:swc',
+        '@nx/node:package',
+        '@nrwl/node:package',
+    ].includes(x.executor))?.options ||
+        plugin.targets?.build?.options ||
+        {};
+    return main;
+}
+function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    return lookupLocalPlugin(importPath, projects, root);
+}
+function getPluginPathAndName(moduleName, paths, projects, root) {
+    let pluginPath;
+    let shouldRegisterTSTranspiler = false;
+    try {
+        pluginPath = require.resolve(moduleName, {
+            paths,
+        });
+        const extension = path.extname(pluginPath);
+        shouldRegisterTSTranspiler = extension === '.ts';
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const plugin = resolveLocalNxPlugin(moduleName, projects, root);
+            if (plugin) {
+                shouldRegisterTSTranspiler = true;
+                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
+                pluginPath = main ? path.join(root, main) : plugin.path;
+            }
+            else {
+                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
+                throw e;
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+    const packageJsonPath = path.join(pluginPath, 'package.json');
+    const { name } = !['.ts', '.js'].some((x) => path.extname(moduleName) === x) && // Not trying to point to a ts or js file
+        (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
+        ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
+        : { name: moduleName };
+    return { pluginPath, name, shouldRegisterTSTranspiler };
+}
+function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
+    if (!projectConfig) {
+        return null;
+    }
+    return { path: path.join(root, projectConfig.root), projectConfig };
+}
+let packageEntryPointsToProjectMap;
+let wildcardEntryPointsToProjectMap;
+function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const tsConfigPaths = readTsConfigPaths(root);
+    const possibleTsPaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p)))) ?? [];
+    const projectRootMappings = new Map();
+    if (possibleTsPaths.length) {
+        const projectNameMap = new Map();
+        for (const projectRoot in projects) {
+            const project = projects[projectRoot];
+            projectRootMappings.set(project.root, project.name);
+            projectNameMap.set(project.name, project);
+        }
+        for (const tsConfigPath of possibleTsPaths) {
+            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
+            if (nxProject) {
+                return projectNameMap.get(nxProject);
+            }
+        }
+    }
+    if (!packageEntryPointsToProjectMap && !wildcardEntryPointsToProjectMap) {
+        ({
+            entryPointsToProjectMap: packageEntryPointsToProjectMap,
+            wildcardEntryPointsToProjectMap,
+        } = (0, packages_1.getWorkspacePackagesMetadata)(projects));
+    }
+    if (packageEntryPointsToProjectMap[importPath]) {
+        return packageEntryPointsToProjectMap[importPath];
+    }
+    const project = (0, packages_1.matchImportToWildcardEntryPointsToProjectMap)(wildcardEntryPointsToProjectMap, importPath);
+    if (project) {
+        return project;
+    }
+    logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
+    throw new Error('Unable to resolve local plugin with import path ' + importPath);
+}
+let tsconfigPaths;
+function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
+    if (!tsconfigPaths) {
+        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
+            .map((x) => path.join(root, x))
+            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
+        if (!tsconfigPath) {
+            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
+        }
+        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        tsconfigPaths = compilerOptions?.paths;
+    }
+    return tsconfigPaths ?? {};
+}

package/src/project-graph/plugins/tasks-execution-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { PostTasksExecutionContext, PreTasksExecutionContext } from './public-api';
+export declare function runPreTasksExecution(pluginContext: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
+export declare function runPostTasksExecution(context: PostTasksExecutionContext): Promise<void>;

package/src/project-graph/plugins/tasks-execution-hooks.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPreTasksExecution = runPreTasksExecution;
+exports.runPostTasksExecution = runPostTasksExecution;
+const get_plugins_1 = require("./get-plugins");
+const is_on_daemon_1 = require("../../daemon/is-on-daemon");
+const client_1 = require("../../daemon/client/client");
+async function runPreTasksExecution(pluginContext) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
+        performance.mark(`preTasksExecution:start`);
+        const plugins = await (0, get_plugins_1.getPlugins)(pluginContext.workspaceRoot);
+        const envs = await Promise.all(plugins
+            .filter((p) => p.preTasksExecution)
+            .map(async (plugin) => {
+            performance.mark(`${plugin.name}:preTasksExecution:start`);
+            try {
+                return await plugin.preTasksExecution(pluginContext);
+            }
+            finally {
+                performance.mark(`${plugin.name}:preTasksExecution:end`);
+                performance.measure(`${plugin.name}:preTasksExecution`, `${plugin.name}:preTasksExecution:start`, `${plugin.name}:preTasksExecution:end`);
+            }
+        }));
+        if (!(0, client_1.isDaemonEnabled)()) {
+            applyProcessEnvs(envs);
+        }
+        performance.mark(`preTasksExecution:end`);
+        performance.measure(`preTasksExecution`, `preTasksExecution:start`, `preTasksExecution:end`);
+        return envs;
+    }
+    else {
+        const envs = await client_1.daemonClient.runPreTasksExecution(pluginContext);
+        applyProcessEnvs(envs);
+    }
+}
+function applyProcessEnvs(envs) {
+    for (const env of envs) {
+        for (const key in env) {
+            process.env[key] = env[key];
+        }
+    }
+}
+async function runPostTasksExecution(context) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
+        performance.mark(`postTasksExecution:start`);
+        const plugins = await (0, get_plugins_1.getPlugins)();
+        await Promise.all(plugins
+            .filter((p) => p.postTasksExecution)
+            .map(async (plugin) => {
+            performance.mark(`${plugin.name}:postTasksExecution:start`);
+            try {
+                await plugin.postTasksExecution(context);
+            }
+            finally {
+                performance.mark(`${plugin.name}:postTasksExecution:end`);
+                performance.measure(`${plugin.name}:postTasksExecution`, `${plugin.name}:postTasksExecution:start`, `${plugin.name}:postTasksExecution:end`);
+            }
+        }));
+        performance.mark(`postTasksExecution:end`);
+        performance.measure(`postTasksExecution`, `postTasksExecution:start`, `postTasksExecution:end`);
+    }
+    else {
+        await client_1.daemonClient.runPostTasksExecution(context);
+    }
+}

package/src/project-graph/plugins/transpiler.d.ts

@@ -0,0 +1,8 @@
+export declare let unregisterPluginTSTranspiler: (() => void) | null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+export declare function registerPluginTSTranspiler(): void;
+export declare function pluginTranspilerIsRegistered(): boolean;
+export declare function cleanupPluginTSTranspiler(): void;

package/src/project-graph/plugins/transpiler.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterPluginTSTranspiler = void 0;
+exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
+exports.pluginTranspilerIsRegistered = pluginTranspilerIsRegistered;
+exports.cleanupPluginTSTranspiler = cleanupPluginTSTranspiler;
+const node_fs_1 = require("node:fs");
+const posix_1 = require("node:path/posix");
+const workspace_root_1 = require("../../utils/workspace-root");
+const register_1 = require("../../plugins/js/utils/register");
+const typescript_1 = require("../../plugins/js/utils/typescript");
+exports.unregisterPluginTSTranspiler = null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+function registerPluginTSTranspiler() {
+    // Get the first tsconfig that matches the allowed set
+    const tsConfigName = [
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
+    ].find((x) => (0, node_fs_1.existsSync)(x));
+    if (!tsConfigName) {
+        return;
+    }
+    const tsConfigOptions = tsConfigName
+        ? (0, typescript_1.readTsConfigOptions)(tsConfigName)
+        : {};
+    const cleanupFns = [
+        (0, register_1.registerTsConfigPaths)(tsConfigName),
+        (0, register_1.registerTranspiler)({
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            ...tsConfigOptions,
+        }),
+    ];
+    exports.unregisterPluginTSTranspiler = () => {
+        cleanupFns.forEach((fn) => fn?.());
+    };
+}
+function pluginTranspilerIsRegistered() {
+    return exports.unregisterPluginTSTranspiler !== null;
+}
+function cleanupPluginTSTranspiler() {
+    (0, exports.unregisterPluginTSTranspiler)?.();
+    exports.unregisterPluginTSTranspiler = null;
+}

package/src/project-graph/plugins/utils.d.ts

@@ -1,8 +1,2 @@
-import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import type { LoadedNxPlugin, NormalizedPlugin } from './internal-api';
-import { CreateNodesContextV2, CreateNodesFunction, CreateNodesResult, type NxPlugin, type NxPluginV2 } from './public-api';
-export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
-export declare function isNxPluginV1(plugin: NxPlugin | LoadedNxPlugin): plugin is NxPluginV1;
-export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
-export type AsyncFn<T extends Function> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : never;
-export declare function createNodesFromFiles<T = unknown>(createNodes: CreateNodesFunction<T>, configFiles: readonly string[], options: T, context: CreateNodesContextV2): Promise<[file: string, value: CreateNodesResult][]>;
+import { CreateNodesContext, CreateNodesContextV2, CreateNodesResult } from './public-api';
+export declare function createNodesFromFiles<T = unknown>(createNodes: (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext, idx: number) => CreateNodesResult | Promise<CreateNodesResult>, configFiles: readonly string[], options: T, context: CreateNodesContextV2): Promise<[file: string, value: CreateNodesResult][]>;

package/src/project-graph/plugins/utils.js

@@ -1,53 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNxPluginV2 = isNxPluginV2;
-exports.isNxPluginV1 = isNxPluginV1;
-exports.normalizeNxPlugin = normalizeNxPlugin;
 exports.createNodesFromFiles = createNodesFromFiles;
-const node_path_1 = require("node:path");
-const to_project_name_1 = require("../../config/to-project-name");
-const globs_1 = require("../../utils/globs");
 const error_types_1 = require("../error-types");
-function isNxPluginV2(plugin) {
-    return 'createNodes' in plugin || 'createDependencies' in plugin;
-}
-function isNxPluginV1(plugin) {
-    return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
-}
-function normalizeNxPlugin(plugin) {
-    if (isNxPluginV2(plugin)) {
-        return plugin;
-    }
-    if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
-        return {
-            ...plugin,
-            createNodes: [
-                `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
-                (configFilePath) => {
-                    const root = (0, node_path_1.dirname)(configFilePath);
-                    return {
-                        projects: {
-                            [root]: {
-                                name: (0, to_project_name_1.toProjectName)(configFilePath),
-                                targets: plugin.registerProjectTargets?.(configFilePath),
-                            },
-                        },
-                    };
-                },
-            ],
-        };
-    }
-    return plugin;
-}
 async function createNodesFromFiles(createNodes, configFiles, options, context) {
     const results = [];
     const errors = [];
-    await Promise.all(configFiles.map(async (file) => {
+    await Promise.all(configFiles.map(async (file, idx) => {
         try {
             const value = await createNodes(file, options, {
                 ...context,
                 configFiles,
-            });
+            }, idx);
             if (value) {
                 results.push([file, value]);
             }

package/src/project-graph/project-graph.d.ts

@@ -2,9 +2,11 @@ import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
+ *
+ * @param {number} [minimumComputedAt] - The minimum timestamp that the cached ProjectGraph must have been computed at.
  * @throws {Error} if there is no cached ProjectGraph to read from
  */
-export declare function readCachedProjectGraph(): ProjectGraph;
+export declare function readCachedProjectGraph(minimumComputedAt?: number): ProjectGraph;
 export declare function readCachedProjectConfiguration(projectName: string): ProjectConfiguration;
 /**
  * Get the {@link ProjectsConfigurations} from the {@link ProjectGraph}