nx 20.8.4 → 22.7.7

package/dist/src/config/nx-json.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNxJson = readNxJson;
+exports.hasNxJson = hasNxJson;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../utils/fileutils");
+const workspace_root_1 = require("../utils/workspace-root");
+const installation_directory_1 = require("../utils/installation-directory");
+function readNxJson(root = workspace_root_1.workspaceRoot) {
+    const nxJson = (0, node_path_1.join)(root, 'nx.json');
+    if ((0, node_fs_1.existsSync)(nxJson)) {
+        const nxJsonConfiguration = (0, fileutils_1.readJsonFile)(nxJson);
+        if (nxJsonConfiguration.extends) {
+            const extendedNxJsonPath = require.resolve(nxJsonConfiguration.extends, {
+                paths: (0, installation_directory_1.getNxRequirePaths)(root),
+            });
+            const baseNxJson = (0, fileutils_1.readJsonFile)(extendedNxJsonPath);
+            return {
+                ...baseNxJson,
+                ...nxJsonConfiguration,
+            };
+        }
+        else {
+            return nxJsonConfiguration;
+        }
+    }
+    else {
+        try {
+            return (0, fileutils_1.readJsonFile)((0, node_path_1.join)(__dirname, '..', '..', 'presets', 'core.json'));
+        }
+        catch (e) {
+            return {};
+        }
+    }
+}
+function hasNxJson(root) {
+    const nxJson = (0, node_path_1.join)(root, 'nx.json');
+    return (0, node_fs_1.existsSync)(nxJson);
+}

package/dist/src/config/schema-utils.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImplementationFactory = getImplementationFactory;
+exports.resolveImplementation = resolveImplementation;
+exports.resolveSchema = resolveSchema;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const resolve_exports_1 = require("resolve.exports");
+const packages_1 = require("../plugins/js/utils/packages");
+const plugins_1 = require("../project-graph/plugins");
+const typescript_1 = require("../plugins/js/utils/typescript");
+const path_2 = require("../utils/path");
+/**
+ * This function is used to get the implementation factory of an executor or generator.
+ * @param implementation path to the implementation
+ * @param directory path to the directory
+ * @returns a function that returns the implementation
+ */
+function getImplementationFactory(implementation, directory, packageName, projects) {
+    const [implementationModulePath, implementationExportName] = implementation.split('#');
+    return () => {
+        const modulePath = resolveImplementation(implementationModulePath, directory, packageName, projects);
+        if ((0, path_1.extname)(modulePath) === '.ts') {
+            (0, plugins_1.registerPluginTSTranspiler)();
+        }
+        const module = require(modulePath);
+        return implementationExportName
+            ? module[implementationExportName]
+            : (module.default ?? module);
+    };
+}
+/**
+ * This function is used to resolve the implementation of an executor or generator.
+ * @param implementationModulePath
+ * @param directory
+ * @returns path to the implementation
+ */
+function resolveImplementation(implementationModulePath, directory, packageName, projects) {
+    const validImplementations = ['', '.js', '.ts'].map((x) => implementationModulePath + x);
+    if (!directory.includes('node_modules')) {
+        // It might be a local plugin where the implementation path points to the
+        // outputs which might not exist or can be stale. We prioritize finding
+        // the implementation from the source over the outputs.
+        for (const maybeImplementation of validImplementations) {
+            const maybeImplementationFromSource = tryResolveFromSource(maybeImplementation, directory, packageName, projects);
+            if (maybeImplementationFromSource) {
+                return maybeImplementationFromSource;
+            }
+        }
+    }
+    for (const maybeImplementation of validImplementations) {
+        const maybeImplementationPath = (0, path_1.join)(directory, maybeImplementation);
+        if ((0, fs_1.existsSync)(maybeImplementationPath)) {
+            return maybeImplementationPath;
+        }
+        try {
+            return require.resolve(maybeImplementation, {
+                paths: [directory],
+            });
+        }
+        catch { }
+    }
+    throw new Error(`Could not resolve "${implementationModulePath}" from "${directory}".`);
+}
+function resolveSchema(schemaPath, directory, packageName, projects) {
+    if (!directory.includes('node_modules')) {
+        // It might be a local plugin where the schema path points to the outputs
+        // which might not exist or can be stale. We prioritize finding the schema
+        // from the source over the outputs.
+        const schemaPathFromSource = tryResolveFromSource(schemaPath, directory, packageName, projects);
+        if (schemaPathFromSource) {
+            return schemaPathFromSource;
+        }
+    }
+    const maybeSchemaPath = (0, path_1.join)(directory, schemaPath);
+    if ((0, fs_1.existsSync)(maybeSchemaPath)) {
+        return maybeSchemaPath;
+    }
+    return require.resolve(schemaPath, {
+        paths: [directory],
+    });
+}
+let packageToProjectMap;
+function tryResolveFromSource(path, directory, packageName, projects) {
+    packageToProjectMap ??=
+        (0, packages_1.getWorkspacePackagesMetadata)(projects).packageToProjectMap;
+    const localProject = packageToProjectMap[packageName];
+    if (!localProject) {
+        // it doesn't match any of the package names from the local projects
+        return null;
+    }
+    try {
+        const fromExports = (0, resolve_exports_1.resolve)({
+            name: localProject.metadata.js.packageName,
+            exports: localProject.metadata.js.packageExports,
+        }, path, { conditions: (0, typescript_1.getRootTsConfigResolveExportsConditions)() });
+        if (fromExports && fromExports.length) {
+            for (const exportPath of fromExports) {
+                if ((0, fs_1.existsSync)((0, path_1.join)(directory, exportPath))) {
+                    return (0, path_1.join)(directory, exportPath);
+                }
+            }
+        }
+    }
+    catch { }
+    /**
+     * Fall back to try to "guess" the source by checking the path in some common directories:
+     * - the root of the project
+     * - the src directory
+     * - the src/lib directory
+     */
+    const segments = (0, path_2.normalizePath)(path).replace(/^\.\//, '').split('/');
+    for (let i = 1; i < segments.length; i++) {
+        const possiblePaths = [
+            (0, path_1.join)(directory, ...segments.slice(i)),
+            (0, path_1.join)(directory, 'src', ...segments.slice(i)),
+            (0, path_1.join)(directory, 'src', 'lib', ...segments.slice(i)),
+        ];
+        for (const possiblePath of possiblePaths) {
+            if ((0, fs_1.existsSync)(possiblePath)) {
+                return possiblePath;
+            }
+        }
+    }
+    return null;
+}

package/dist/src/config/task-graph.d.ts

@@ -0,0 +1,109 @@
+/**
+ * A representation of the invocation of an Executor
+ */
+export interface Task {
+    /**
+     * Unique ID
+     */
+    id: string;
+    /**
+     * Details about which project, target, and configuration to run.
+     */
+    target: {
+        /**
+         * The project for which the task belongs to
+         */
+        project: string;
+        /**
+         * The target name which the task should invoke
+         */
+        target: string;
+        /**
+         * The configuration of the target which the task invokes
+         */
+        configuration?: string;
+    };
+    /**
+     * Overrides for the configured options of the target
+     */
+    overrides: any;
+    /**
+     * The outputs the task may produce
+     */
+    outputs: string[];
+    /**
+     * Root of the project the task belongs to
+     */
+    projectRoot?: string;
+    /**
+     * Hash of the task which is used for caching.
+     */
+    hash?: string;
+    /**
+     * Details about the composition of the hash
+     */
+    hashDetails?: {
+        /**
+         * Command of the task
+         */
+        command: string;
+        /**
+         * Hashes of inputs used in the hash
+         */
+        nodes: {
+            [name: string]: string;
+        };
+        /**
+         * Hashes of implicit dependencies which are included in the hash
+         */
+        implicitDeps?: {
+            [fileName: string]: string;
+        };
+        /**
+         * Hash of the runtime environment which the task was executed
+         */
+        runtime?: {
+            [input: string]: string;
+        };
+    };
+    /**
+     *
+     * Unix timestamp of when a Batch Task starts
+     **/
+    startTime?: number;
+    /**
+     *
+     * Unix timestamp of when a Batch Task ends
+     **/
+    endTime?: number;
+    /**
+     * Determines if a given task should be cacheable.
+     */
+    cache?: boolean;
+    /**
+     * Determines if a given task should be parallelizable.
+     */
+    parallelism: boolean;
+    /**
+     * This denotes if the task runs continuously
+     */
+    continuous?: boolean;
+}
+/**
+ * Graph of Tasks to be executed
+ */
+export interface TaskGraph {
+    /**
+     * IDs of Tasks which do not have any dependencies and are thus ready to execute immediately
+     */
+    roots: string[];
+    /**
+     * Map of Task IDs to Tasks
+     */
+    tasks: Record<string, Task>;
+    /**
+     * Map of Task IDs to IDs of tasks which the task depends on
+     */
+    dependencies: Record<string, string[]>;
+    continuousDependencies: Record<string, string[]>;
+}

package/dist/src/config/workspace-json-project-json.d.ts

@@ -0,0 +1,263 @@
+import type { JsonInput } from '../native';
+import type { PackageJson } from '../utils/package-json';
+import type { NxJsonConfiguration, NxReleaseDockerConfiguration, NxReleaseVersionConfiguration } from './nx-json';
+/**
+ * @deprecated use ProjectsConfigurations or NxJsonConfiguration
+ */
+export interface Workspace extends ProjectsConfigurations, NxJsonConfiguration {
+    projects: Record<string, ProjectConfiguration>;
+}
+/**
+ * @deprecated use ProjectsConfigurations
+ */
+export type WorkspaceJsonConfiguration = ProjectsConfigurations;
+/**
+ * Projects Configurations
+ * @note: when adding properties here add them to `allowedWorkspaceExtensions` in adapter/compat.ts
+ */
+export interface ProjectsConfigurations {
+    /**
+     * Version of the configuration format
+     */
+    version: number;
+    /**
+     * Projects' projects
+     */
+    projects: {
+        [projectName: string]: ProjectConfiguration;
+    };
+}
+/**
+ * Type of project supported
+ */
+export type ProjectType = 'library' | 'application';
+/**
+ * Project configuration
+ *
+ * @note: when adding properties here add them to `allowedProjectExtensions` in adapter/compat.ts
+ */
+export interface ProjectConfiguration {
+    /**
+     * Project's name. Optional if specified in workspace.json
+     */
+    name?: string;
+    /**
+     * Project's targets
+     */
+    targets?: {
+        [targetName: string]: TargetConfiguration;
+    };
+    /**
+     * Project's location relative to the root of the workspace
+     */
+    root: string;
+    /**
+     * The location of project's sources relative to the root of the workspace
+     */
+    sourceRoot?: string;
+    /**
+     * Project type
+     */
+    projectType?: ProjectType;
+    /**
+     * List of default values used by generators.
+     *
+     * These defaults are project specific.
+     *
+     * Example:
+     *
+     * ```
+     * {
+     *   "@nx/react": {
+     *     "library": {
+     *       "style": "scss"
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    generators?: {
+        [collectionName: string]: {
+            [generatorName: string]: any;
+        };
+    };
+    /**
+     * List of projects which are added as a dependency
+     */
+    implicitDependencies?: string[];
+    /**
+     * Named inputs targets can refer to reduce duplication
+     */
+    namedInputs?: {
+        [inputName: string]: (string | InputDefinition)[];
+    };
+    /**
+     * List of tags used by enforce-module-boundaries / project graph
+     */
+    tags?: string[];
+    /**
+     * Project specific configuration for `nx release`
+     */
+    release?: {
+        version?: Pick<NxReleaseVersionConfiguration, 'versionActions' | 'versionActionsOptions' | 'manifestRootsToUpdate' | 'currentVersionResolver' | 'currentVersionResolverMetadata' | 'fallbackCurrentVersionResolver' | 'versionPrefix' | 'preserveLocalDependencyProtocols'>;
+        docker?: NxReleaseDockerConfiguration | true;
+    };
+    /**
+     * Metadata about the project
+     */
+    metadata?: ProjectMetadata;
+}
+export interface ProjectMetadata {
+    [k: string]: any;
+    description?: string;
+    technologies?: string[];
+    targetGroups?: Record<string, string[]>;
+    owners?: {
+        [ownerId: string]: {
+            ownedFiles: {
+                files: ['*'] | string[];
+                fromConfig?: {
+                    filePath: string;
+                    location: {
+                        startLine: number;
+                        endLine: number;
+                    };
+                };
+            }[];
+        };
+    };
+    js?: {
+        packageName: string;
+        packageVersion?: string;
+        packageExports?: PackageJson['exports'];
+        packageMain?: string;
+        isInPackageManagerWorkspaces?: boolean;
+    };
+}
+export interface TargetMetadata {
+    [k: string]: any;
+    description?: string;
+    technologies?: string[];
+    nonAtomizedTarget?: string;
+    help?: {
+        command: string;
+        example: {
+            options?: Record<string, unknown>;
+            args?: string[];
+        };
+    };
+}
+export interface TargetDependencyConfig {
+    /**
+     * A list of projects that have `target`.
+     * Should not be specified together with `dependencies`.
+     */
+    projects?: string[] | string;
+    /**
+     * If true, the target will be executed for each project that this project depends on.
+     * Should not be specified together with `projects`.
+     */
+    dependencies?: boolean;
+    /**
+     * The name of the target to run. If `projects` and `dependencies` are not specified,
+     * the target will be executed for the same project the the current target is running on`.
+     */
+    target: string;
+    /**
+     * Whether to forward CLI params to the dependency target.
+     */
+    params?: 'ignore' | 'forward';
+    /**
+     * Whether to forward task options to the dependency target.
+     */
+    options?: 'ignore' | 'forward';
+}
+export type InputDefinition = {
+    input: string;
+    projects: string | string[];
+} | {
+    input: string;
+    dependencies: true;
+} | {
+    input: string;
+} | {
+    fileset: string;
+} | {
+    fileset: string;
+    dependencies: true;
+} | {
+    runtime: string;
+} | {
+    externalDependencies: string[];
+} | {
+    dependentTasksOutputFiles: string;
+    transitive?: boolean;
+} | {
+    env: string;
+} | {
+    workingDirectory: 'relative' | 'absolute';
+} | JsonInput;
+/**
+ * Target's configuration
+ */
+export interface TargetConfiguration<T = any> {
+    /**
+     * The executor/builder used to implement the target.
+     *
+     * Example: '@nx/rollup:rollup'
+     */
+    executor?: string;
+    /**
+     * Used as a shorthand for nx:run-commands, a command to run.
+     */
+    command?: string;
+    /**
+     * List of the target's outputs. The outputs will be cached by the Nx computation
+     * caching engine.
+     */
+    outputs?: string[];
+    /**
+     * This describes other targets that a target depends on.
+     */
+    dependsOn?: (TargetDependencyConfig | string)[];
+    /**
+     * This describes filesets, runtime dependencies and other inputs that a target depends on.
+     */
+    inputs?: (InputDefinition | string)[];
+    /**
+     * Target's options. They are passed in to the executor.
+     */
+    options?: T;
+    /**
+     * Sets of options
+     */
+    configurations?: {
+        [config: string]: any;
+    };
+    /**
+     * A default named configuration to use when a target configuration is not provided.
+     */
+    defaultConfiguration?: string;
+    /**
+     * Determines if Nx is able to cache a given target.
+     */
+    cache?: boolean;
+    /**
+     * Metadata about the target
+     */
+    metadata?: TargetMetadata;
+    /**
+     * Whether this target can be run in parallel with other tasks
+     * Default is true
+     */
+    parallelism?: boolean;
+    /**
+     * Whether this target runs continuously
+     */
+    continuous?: boolean;
+    /**
+     * List of generators to run before the target to ensure the workspace
+     * is up to date.
+     */
+    syncGenerators?: string[];
+}

package/dist/src/core/graph/index.html

@@ -0,0 +1,32 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Nx Workspace Project Graph</title>
+    <base href="/">
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="icon" type="image/x-icon" href="favicon.ico" />
+
+    <script id="environment" src="environment.js"></script>
+
+    <!-- Theming -->
+    <script>
+      // On page load or when changing themes, best to add inline in `head` to avoid FOUC
+      if (
+        localStorage.getItem('nx-dep-graph-theme') === 'dark' ||
+        (localStorage.getItem('nx-dep-graph-theme') === null &&
+          window.matchMedia('(prefers-color-scheme: dark)').matches)
+      ) {
+        document.documentElement.classList.add('dark');
+      } else {
+        document.documentElement.classList.remove('dark');
+      }
+    </script>
+  <link rel="stylesheet" href="styles.css"></head>
+
+  <body
+    class="h-screen w-screen bg-white text-slate-500 dark:bg-slate-900 dark:text-slate-400"
+  >
+    <div class="flex h-full w-full p-0" id="app"></div>
+  <script src="runtime.js" type="module"></script><script src="styles.js" type="module"></script><script src="main.js" type="module"></script></body>
+</html>