@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

package/dist/src/generators/utils/glob.d.ts

@@ -1,22 +0,0 @@
-import { Tree } from '../tree';
-/**
- * Performs a tree-aware glob search on the files in a workspace. Able to find newly
- * created files and hides deleted files before the updates are committed to disk.
- * Paths should be unix-style with forward slashes.
- *
- * @param tree The file system tree
- * @param patterns A list of glob patterns
- * @returns Normalized paths in the workspace that match the provided glob patterns.
- * @deprecated Use {@link globAsync} instead.
- */
-export declare function glob(tree: Tree, patterns: string[]): string[];
-/**
- * Performs a tree-aware glob search on the files in a workspace. Able to find newly
- * created files and hides deleted files before the updates are committed to disk.
- * Paths should be unix-style with forward slashes.
- *
- * @param tree The file system tree
- * @param patterns A list of glob patterns
- * @returns Normalized paths in the workspace that match the provided glob patterns.
- */
-export declare function globAsync(tree: Tree, patterns: string[]): Promise<string[]>;

package/dist/src/generators/utils/glob.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.glob = glob;
-exports.globAsync = globAsync;
-const minimatch_1 = require("minimatch");
-const globs_1 = require("../../utils/globs");
-const workspace_context_1 = require("../../utils/workspace-context");
-/**
- * Performs a tree-aware glob search on the files in a workspace. Able to find newly
- * created files and hides deleted files before the updates are committed to disk.
- * Paths should be unix-style with forward slashes.
- *
- * @param tree The file system tree
- * @param patterns A list of glob patterns
- * @returns Normalized paths in the workspace that match the provided glob patterns.
- * @deprecated Use {@link globAsync} instead.
- */
-function glob(tree, patterns) {
-    return combineGlobResultsWithTree(tree, patterns, (0, workspace_context_1.globWithWorkspaceContextSync)(tree.root, patterns));
-}
-/**
- * Performs a tree-aware glob search on the files in a workspace. Able to find newly
- * created files and hides deleted files before the updates are committed to disk.
- * Paths should be unix-style with forward slashes.
- *
- * @param tree The file system tree
- * @param patterns A list of glob patterns
- * @returns Normalized paths in the workspace that match the provided glob patterns.
- */
-async function globAsync(tree, patterns) {
-    return combineGlobResultsWithTree(tree, patterns, await (0, workspace_context_1.globWithWorkspaceContext)(tree.root, patterns));
-}
-function combineGlobResultsWithTree(tree, patterns, results) {
-    const matches = new Set(results);
-    const combinedGlob = (0, globs_1.combineGlobPatterns)(patterns);
-    const matcher = minimatch_1.minimatch.makeRe(combinedGlob);
-    if (!matcher) {
-        throw new Error('Invalid glob pattern: ' + combinedGlob);
-    }
-    for (const change of tree.listChanges()) {
-        if (change.type !== 'UPDATE' && matcher.test(change.path)) {
-            if (change.type === 'CREATE') {
-                matches.add(change.path);
-            }
-            else if (change.type === 'DELETE') {
-                matches.delete(change.path);
-            }
-        }
-    }
-    return Array.from(matches);
-}

package/dist/src/generators/utils/json.d.ts

@@ -1,28 +0,0 @@
-import type { Tree } from '../tree';
-import type { JsonParseOptions, JsonSerializeOptions } from '../../utils/json';
-/**
- * Reads a json file, removes all comments and parses JSON.
- *
- * @param tree - file system tree
- * @param path - file path
- * @param options - Optional JSON Parse Options
- */
-export declare function readJson<T extends object = any>(tree: Tree, path: string, options?: JsonParseOptions): T;
-/**
- * Writes a JSON value to the file system tree
-
- * @param tree File system tree
- * @param path Path of JSON file in the Tree
- * @param value Serializable value to write
- * @param options Optional JSON Serialize Options
- */
-export declare function writeJson<T extends object = object>(tree: Tree, path: string, value: T, options?: JsonSerializeOptions): void;
-/**
- * Updates a JSON value to the file system tree
- *
- * @param tree File system tree
- * @param path Path of JSON file in the Tree
- * @param updater Function that maps the current value of a JSON document to a new value to be written to the document
- * @param options Optional JSON Parse and Serialize Options
- */
-export declare function updateJson<T extends object = any, U extends object = T>(tree: Tree, path: string, updater: (value: T) => U, options?: JsonParseOptions & JsonSerializeOptions): void;

package/dist/src/generators/utils/json.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readJson = readJson;
-exports.writeJson = writeJson;
-exports.updateJson = updateJson;
-const json_1 = require("../../utils/json");
-/**
- * Reads a json file, removes all comments and parses JSON.
- *
- * @param tree - file system tree
- * @param path - file path
- * @param options - Optional JSON Parse Options
- */
-function readJson(tree, path, options) {
-    if (!tree.exists(path)) {
-        throw new Error(`Cannot find ${path}`);
-    }
-    try {
-        return (0, json_1.parseJson)(tree.read(path, 'utf-8'), options);
-    }
-    catch (e) {
-        throw new Error(`Cannot parse ${path}: ${e.message}`);
-    }
-}
-/**
- * Writes a JSON value to the file system tree
-
- * @param tree File system tree
- * @param path Path of JSON file in the Tree
- * @param value Serializable value to write
- * @param options Optional JSON Serialize Options
- */
-function writeJson(tree, path, value, options) {
-    const serialized = (0, json_1.serializeJson)(value, options);
-    tree.write(path, `${serialized}\n`);
-}
-/**
- * Updates a JSON value to the file system tree
- *
- * @param tree File system tree
- * @param path Path of JSON file in the Tree
- * @param updater Function that maps the current value of a JSON document to a new value to be written to the document
- * @param options Optional JSON Parse and Serialize Options
- */
-function updateJson(tree, path, updater, options) {
-    const updatedValue = updater(readJson(tree, path, options));
-    writeJson(tree, path, updatedValue, options);
-}

package/dist/src/generators/utils/nx-json.d.ts

@@ -1,10 +0,0 @@
-import type { NxJsonConfiguration } from '../../config/nx-json';
-import type { Tree } from '../tree';
-/**
- * Reads nx.json
- */
-export declare function readNxJson(tree: Tree): NxJsonConfiguration | null;
-/**
- * Update nx.json
- */
-export declare function updateNxJson(tree: Tree, nxJson: NxJsonConfiguration): void;

package/dist/src/generators/utils/nx-json.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readNxJson = readNxJson;
-exports.updateNxJson = updateNxJson;
-const path_1 = require("path");
-const json_1 = require("./json");
-/**
- * Reads nx.json
- */
-function readNxJson(tree) {
-    if (!tree.exists('nx.json')) {
-        return null;
-    }
-    let nxJson = (0, json_1.readJson)(tree, 'nx.json');
-    if (nxJson.extends) {
-        nxJson = { ...readNxJsonExtends(tree, nxJson.extends), ...nxJson };
-    }
-    return nxJson;
-}
-/**
- * Update nx.json
- */
-function updateNxJson(tree, nxJson) {
-    if (tree.exists('nx.json')) {
-        (0, json_1.updateJson)(tree, 'nx.json', (json) => {
-            if (json.extends) {
-                const nxJsonExtends = readNxJsonExtends(tree, json.extends);
-                const changedPropsOfNxJson = {};
-                Object.keys(nxJson).forEach((prop) => {
-                    if (JSON.stringify(nxJson[prop], null, 2) !=
-                        JSON.stringify(nxJsonExtends[prop], null, 2)) {
-                        changedPropsOfNxJson[prop] = nxJson[prop];
-                    }
-                });
-                return changedPropsOfNxJson;
-            }
-            else {
-                return nxJson;
-            }
-        });
-    }
-}
-function readNxJsonExtends(tree, extendsPath) {
-    try {
-        let resolvedExtendsPath;
-        try {
-            resolvedExtendsPath = require.resolve(extendsPath, {
-                paths: [tree.root],
-            });
-        }
-        catch {
-            // Tree roots without a node_modules folder (e.g. the in-memory trees
-            // used in tests) can't anchor module resolution; fall back to
-            // resolving from the running nx package.
-            resolvedExtendsPath = require.resolve(extendsPath);
-        }
-        return (0, json_1.readJson)(tree, (0, path_1.relative)(tree.root, resolvedExtendsPath));
-    }
-    catch (e) {
-        throw new Error(`Unable to resolve nx.json extends. Error: ${e.message}`);
-    }
-}

package/dist/src/generators/utils/project-configuration.d.ts

@@ -1,51 +0,0 @@
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import type { Tree } from '../tree';
-export { readNxJson, updateNxJson } from './nx-json';
-/**
- * Adds project configuration to the Nx workspace.
- *
- * @param tree - the file system tree
- * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
- * @param projectConfiguration - project configuration
- */
-export declare function addProjectConfiguration(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration): void;
-/**
- * Adds project configuration to the Nx workspace.
- *
- * @param tree - the file system tree
- * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
- * @param projectConfiguration - project configuration
- * @param standalone - whether the project is configured in workspace.json or not
- * @deprecated Nx only supports standalone projects. The `standalone` parameter is ignored and will be removed in a future version. Use the 3-argument overload instead.
- */
-export declare function addProjectConfiguration(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration, standalone: boolean): void;
-/**
- * Updates the configuration of an existing project.
- *
- * @param tree - the file system tree
- * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
- * @param projectConfiguration - project configuration
- */
-export declare function updateProjectConfiguration(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration): void;
-/**
- * Removes the configuration of an existing project.
- *
- * @param tree - the file system tree
- * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
- */
-export declare function removeProjectConfiguration(tree: Tree, projectName: string): void;
-/**
- * Reads a project configuration.
- *
- * @param tree - the file system tree
- * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
- * @throws If supplied projectName cannot be found
- */
-export declare function readProjectConfiguration(tree: Tree, projectName: string): ProjectConfiguration;
-/**
- * Get a map of all projects in a workspace.
- *
- * Use {@link readProjectConfiguration} if only one project is needed.
- */
-export declare function getProjects(tree: Tree): Map<string, ProjectConfiguration>;
-export declare function getRelativeProjectJsonSchemaPath(tree: Tree, project: ProjectConfiguration): string;

package/dist/src/generators/utils/project-configuration.js

@@ -1,299 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateNxJson = exports.readNxJson = void 0;
-exports.addProjectConfiguration = addProjectConfiguration;
-exports.updateProjectConfiguration = updateProjectConfiguration;
-exports.removeProjectConfiguration = removeProjectConfiguration;
-exports.readProjectConfiguration = readProjectConfiguration;
-exports.getProjects = getProjects;
-exports.getRelativeProjectJsonSchemaPath = getRelativeProjectJsonSchemaPath;
-const minimatch_1 = require("minimatch");
-const path_1 = require("path");
-const package_json_1 = require("../../plugins/package-json");
-const project_json_1 = require("../../plugins/project-json/build-nodes/project-json");
-const angular_json_1 = require("../../adapter/angular-json");
-const project_nodes_manager_1 = require("../../project-graph/utils/project-configuration/project-nodes-manager");
-const workspace_context_1 = require("../../utils/workspace-context");
-const output_1 = require("../../utils/output");
-const path_2 = require("../../utils/path");
-const json_1 = require("./json");
-const to_project_name_1 = require("../../config/to-project-name");
-var nx_json_1 = require("./nx-json");
-Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_1.readNxJson; } });
-Object.defineProperty(exports, "updateNxJson", { enumerable: true, get: function () { return nx_json_1.updateNxJson; } });
-function addProjectConfiguration(tree, projectName, projectConfiguration, standalone = true) {
-    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
-    if (!standalone) {
-        output_1.output.warn({
-            title: 'Nx only supports standalone projects. Setting standalone to false is ignored.',
-        });
-    }
-    if (tree.exists(projectConfigFile)) {
-        throw new Error(`Cannot create a new project ${projectName} at ${projectConfiguration.root}. A project already exists in this directory.`);
-    }
-    delete projectConfiguration.$schema;
-    handleEmptyTargets(projectName, projectConfiguration);
-    (0, json_1.writeJson)(tree, projectConfigFile, {
-        name: projectName,
-        $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
-        ...projectConfiguration,
-        root: undefined,
-    });
-}
-/**
- * Updates the configuration of an existing project.
- *
- * @param tree - the file system tree
- * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
- * @param projectConfiguration - project configuration
- */
-function updateProjectConfiguration(tree, projectName, projectConfiguration) {
-    if (tree.exists((0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json'))) {
-        updateProjectConfigurationInProjectJson(tree, projectName, projectConfiguration);
-    }
-    else if (tree.exists((0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json'))) {
-        updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration);
-    }
-    else {
-        throw new Error(`Cannot update Project ${projectName} at ${projectConfiguration.root}. It either doesn't exist yet, or may not use project.json for configuration. Use \`addProjectConfiguration()\` instead if you want to create a new project.`);
-    }
-}
-function updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration) {
-    const packageJsonFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json');
-    const packageJson = (0, json_1.readJson)(tree, packageJsonFile);
-    projectConfiguration.name = projectName;
-    if (packageJson.name === projectConfiguration.name) {
-        delete projectConfiguration.name;
-    }
-    if (projectConfiguration.targets &&
-        !Object.keys(projectConfiguration.targets).length) {
-        delete projectConfiguration.targets;
-    }
-    packageJson.nx = {
-        ...packageJson.nx,
-        ...projectConfiguration,
-    };
-    // We don't want to ever this since it is inferred
-    delete packageJson.nx.root;
-    // Only set `nx` property in `package.json` if it is a root project (necessary to mark it as Nx project),
-    // or if there are properties to be set. If it is empty, then avoid it so we don't add unnecessary boilerplate.
-    if (projectConfiguration.root === '.' ||
-        Object.keys(packageJson.nx).length > 0) {
-        (0, json_1.writeJson)(tree, packageJsonFile, packageJson);
-    }
-}
-function updateProjectConfigurationInProjectJson(tree, projectName, projectConfiguration) {
-    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
-    handleEmptyTargets(projectName, projectConfiguration);
-    (0, json_1.writeJson)(tree, projectConfigFile, {
-        name: projectConfiguration.name ?? projectName,
-        $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
-        ...projectConfiguration,
-        root: undefined,
-    });
-}
-/**
- * Removes the configuration of an existing project.
- *
- * @param tree - the file system tree
- * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
- */
-function removeProjectConfiguration(tree, projectName) {
-    const projectConfiguration = readProjectConfiguration(tree, projectName);
-    if (!projectConfiguration) {
-        throw new Error(`Cannot delete Project ${projectName}`);
-    }
-    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
-    if (tree.exists(projectConfigFile)) {
-        tree.delete(projectConfigFile);
-    }
-}
-/**
- * Reads a project configuration.
- *
- * @param tree - the file system tree
- * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
- * @throws If supplied projectName cannot be found
- */
-function readProjectConfiguration(tree, projectName) {
-    const allProjects = readAndCombineAllProjectConfigurations(tree);
-    if (!allProjects[projectName]) {
-        // temporary polyfill to make sure our generators work for existing angularcli workspaces
-        if (tree.exists('angular.json')) {
-            const angularJson = toNewFormat((0, json_1.readJson)(tree, 'angular.json'));
-            if (angularJson.projects[projectName])
-                return angularJson.projects[projectName];
-        }
-        throw new Error(`Cannot find configuration for '${projectName}'`);
-    }
-    return allProjects[projectName];
-}
-/**
- * Get a map of all projects in a workspace.
- *
- * Use {@link readProjectConfiguration} if only one project is needed.
- */
-function getProjects(tree) {
-    let allProjects = readAndCombineAllProjectConfigurations(tree);
-    // temporary polyfill to make sure our generators work for existing angularcli workspaces
-    if (tree.exists('angular.json')) {
-        const angularJson = toNewFormat((0, json_1.readJson)(tree, 'angular.json'));
-        allProjects = { ...allProjects, ...angularJson.projects };
-    }
-    return new Map(Object.keys(allProjects || {}).map((projectName) => {
-        return [projectName, allProjects[projectName]];
-    }));
-}
-function getRelativeProjectJsonSchemaPath(tree, project) {
-    return (0, path_2.normalizePath)((0, path_1.relative)((0, path_1.join)(tree.root, project.root), (0, path_1.join)(tree.root, 'node_modules/nx/schemas/project-schema.json')));
-}
-function readAndCombineAllProjectConfigurations(tree) {
-    /**
-     * We can't update projects that come from plugins anyways, so we are going
-     * to ignore them for now. Plugins should add their own add/create/update methods
-     * if they would like to use devkit to update inferred projects.
-     */
-    const patterns = [
-        '**/project.json',
-        'project.json',
-        ...(0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (p) => (0, json_1.readJson)(tree, p, { expectComments: true }), (p) => {
-            const content = tree.read(p, 'utf-8');
-            const { load } = require('@zkochan/js-yaml');
-            return load(content, { filename: p });
-        }, (p) => tree.exists(p)),
-    ];
-    const globbedFiles = (0, workspace_context_1.globWithWorkspaceContextSync)(tree.root, patterns);
-    const createdFiles = findCreatedProjectFiles(tree, patterns);
-    const deletedFiles = findDeletedProjectFiles(tree, patterns);
-    // Ensure we don't duplicate files that are both globbed and in tree changes
-    const allProjectFiles = new Set([...globbedFiles, ...createdFiles]);
-    const projectFiles = Array.from(allProjectFiles).filter((r) => deletedFiles.indexOf(r) === -1);
-    const rootMap = {};
-    for (const projectFile of projectFiles) {
-        if ((0, path_1.basename)(projectFile) === 'project.json') {
-            const json = (0, json_1.readJson)(tree, projectFile);
-            const config = (0, project_json_1.buildProjectFromProjectJson)(json, projectFile);
-            if (!config.name) {
-                try {
-                    const packageJson = (0, json_1.readJson)(tree, (0, path_2.joinPathFragments)(config.root, 'package.json'));
-                    if (packageJson.name) {
-                        config.name = packageJson.name;
-                    }
-                }
-                catch {
-                    // Maybe no package json, is ok.
-                }
-                config.name ??= (0, to_project_name_1.toProjectName)(projectFile);
-            }
-            (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(rootMap, config, undefined, undefined, true);
-        }
-        if ((0, path_1.basename)(projectFile) === 'package.json') {
-            const packageJson = (0, json_1.readJson)(tree, projectFile);
-            // We don't want to have all of the extra inferred stuff in here, as
-            // when generators update the project they shouldn't inline that stuff.
-            // so rather than using `buildProjectFromPackageJson` and stripping it out
-            // we are going to build the config manually.
-            const config = {
-                root: (0, path_1.dirname)(projectFile),
-                name: packageJson.name ?? (0, to_project_name_1.toProjectName)(projectFile),
-                ...packageJson.nx,
-            };
-            if (!rootMap[config.root]) {
-                (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
-                // Inferred targets, tags, etc don't show up when running generators
-                // This is to help avoid running into issues when trying to update the workspace
-                config, undefined, undefined, true);
-            }
-        }
-    }
-    return (0, project_nodes_manager_1.readProjectConfigurationsFromRootMap)(rootMap);
-}
-/**
- * Used to ensure that projects created during
- * the same devkit generator run show up when
- * there is no project.json file, as `glob`
- * cannot find them.
- *
- * We exclude the root `package.json` from this list unless
- * considered a project during workspace generation
- */
-function findCreatedProjectFiles(tree, globPatterns) {
-    const createdProjectFiles = [];
-    for (const change of tree.listChanges()) {
-        // Include both CREATE and UPDATE changes to handle project files
-        // created during generator callbacks (which are marked as UPDATE
-        // since the tree has already been flushed to disk)
-        if (change.type === 'CREATE' || change.type === 'UPDATE') {
-            const fileName = (0, path_1.basename)(change.path);
-            if (globPatterns.some((pattern) => (0, minimatch_1.minimatch)(change.path, pattern, { dot: true }))) {
-                createdProjectFiles.push(change.path);
-            }
-            else if (fileName === 'package.json') {
-                try {
-                    const contents = JSON.parse(change.content.toString());
-                    if (contents.nx) {
-                        createdProjectFiles.push(change.path);
-                    }
-                }
-                catch { }
-            }
-        }
-    }
-    return createdProjectFiles.map(path_2.normalizePath);
-}
-/**
- * Used to ensure that projects created during
- * the same devkit generator run show up when
- * there is no project.json file, as `glob`
- * cannot find them.
- */
-function findDeletedProjectFiles(tree, globPatterns) {
-    return tree
-        .listChanges()
-        .filter((f) => {
-        return (f.type === 'DELETE' &&
-            globPatterns.some((pattern) => (0, minimatch_1.minimatch)(f.path, pattern)));
-    })
-        .map((r) => r.path);
-}
-function toNewFormat(w) {
-    const projects = {};
-    Object.keys(w.projects || {}).forEach((name) => {
-        if (typeof w.projects[name] === 'string')
-            return;
-        const projectConfig = w.projects[name];
-        if (projectConfig.architect) {
-            (0, angular_json_1.renamePropertyWithStableKeys)(projectConfig, 'architect', 'targets');
-        }
-        if (projectConfig.schematics) {
-            (0, angular_json_1.renamePropertyWithStableKeys)(projectConfig, 'schematics', 'generators');
-        }
-        Object.values(projectConfig.targets || {}).forEach((target) => {
-            if (target.builder !== undefined) {
-                (0, angular_json_1.renamePropertyWithStableKeys)(target, 'builder', 'executor');
-            }
-        });
-        projects[name] = projectConfig;
-    });
-    w.projects = projects;
-    if (w.schematics) {
-        (0, angular_json_1.renamePropertyWithStableKeys)(w, 'schematics', 'generators');
-    }
-    if (w.version !== 2) {
-        w.version = 2;
-    }
-    return w;
-}
-function handleEmptyTargets(projectName, projectConfiguration) {
-    if (projectConfiguration.targets &&
-        !Object.keys(projectConfiguration.targets).length) {
-        // Re-order `targets` to appear after the `// target` comment.
-        delete projectConfiguration.targets;
-        projectConfiguration['// targets'] =
-            `to see all targets run: nx show project ${projectName} --web`;
-        projectConfiguration.targets = {};
-    }
-    else {
-        delete projectConfiguration['// targets'];
-    }
-}

package/dist/src/hasher/check-task-files.d.ts

@@ -1,86 +0,0 @@
-import { type NxJsonConfiguration } from '../config/nx-json';
-import type { ProjectGraph } from '../config/project-graph';
-import type { HashInputs } from '../native';
-/**
- * A project graph the caller has already built. `nx show target` resolves one to
- * find the target in the first place, and `createProjectGraphAsync` is not
- * memoized, so without this the CLI would build the graph a second time.
- */
-export interface TaskFileCheckSeed {
-    projectGraph: ProjectGraph;
-    nxJson: NxJsonConfiguration;
-}
-/** The rule that made a value an input for a task. */
-export type InputCategory = 'files' | 'depOutputs' | 'dependentTasksOutputFiles' | 'runtime' | 'environment' | 'external';
-export interface InputCandidate {
-    /** The value as supplied — matched verbatim against environment/runtime/external. */
-    value: string;
-    /** Workspace-relative path form of `value` — matched against the path categories. */
-    path: string;
-}
-/**
- * Check which values are legitimate inputs for the given task. A value matches
- * when it is:
- *   - a declared environment variable, runtime input, or external dependency;
- *   - a file in the task's declared input file list;
- *   - a file in the task's materialized `depOutputs` (upstream has run);
- *   - a file matching a `dependentTasksOutputFiles` glob declared on the task
- *     that lies inside the declared outputs of an upstream task in the task
- *     graph (static — works even when upstream tasks have not yet run).
- *
- * `categories` records the rule each matched value satisfied. Paths may be
- * workspace-relative or absolute; absolute ones are relativized against the
- * workspace root, and a path outside the workspace simply matches nothing. A
- * caller resolving paths against a cwd passes an {@link InputCandidate} so that
- * names are still matched verbatim.
- */
-export declare function checkFilesAreInputs(taskId: string, files: Array<string | InputCandidate>): Promise<{
-    matched: string[];
-    unmatched: string[];
-    categories: Map<string, InputCategory>;
-}>;
-/**
- * Check which files match the output globs declared for the given task.
- * Uses the same path-matching logic as the task runner (directory containment
- * + glob matching through the native `globset` engine), including negated
- * (`!`-prefixed) patterns acting as exclusions over the whole pattern set.
- *
- * Paths may be workspace-relative or absolute; absolute ones are relativized
- * against the workspace root. An output pattern whose `{options.*}` token has no
- * value resolves to nothing — exactly as the task runner drops it — so a file it
- * would have covered is reported `unmatched`, like any other non-output.
- *
- * That last case makes `unmatched` two answers in one: "not an output" and
- * "the outputs could not be determined". A consumer judging sandbox violations
- * cannot tell them apart, and would call the second one illegal. `getTaskOutputs`
- * already computes the `unresolved` list this would need; surfacing it here is
- * deliberately deferred until a consumer's contract asks for the distinction.
- */
-export declare function checkFilesAreOutputs(taskId: string, files: string[]): Promise<{
-    matched: string[];
-    unmatched: string[];
-}>;
-/**
- * Returns the full hash inputs for a task (files + runtime + env + depOutputs
- * + external). Used internally by the `nx show target --inputs` renderer.
- */
-export declare function getTaskRawInputs(taskId: string, seed?: TaskFileCheckSeed): Promise<HashInputs | null>;
-export interface TaskOutputs {
-    /** Output patterns after token substitution — what the task runner will cache. */
-    resolved: string[];
-    /** `resolved`, expanded against the files currently on disk. */
-    expanded: string[];
-    /** Configured outputs left out of `resolved` because an option had no value. */
-    unresolved: string[];
-}
-/**
- * Returns the outputs declared for a task, resolved against its effective
- * configuration. Used internally by the `nx show target --outputs` renderer.
- */
-export declare function getTaskOutputs(taskId: string, seed?: TaskFileCheckSeed): Promise<TaskOutputs>;
-/**
- * Resets all module-level caches. Call this in `beforeEach` when testing so
- * each test gets a fresh context load. Not part of the public API.
- * @internal
- */
-export declare function _resetContextForTesting(): void;