@ohos-ports/nx 17.3.2-beta.0

package/src/utils/print-help.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHelp = void 0;
+const chalk = require("chalk");
+const stringWidth = require("string-width");
+const logger_1 = require("./logger");
+const output_1 = require("./output");
+const versions_1 = require("./versions");
+const package_json_1 = require("./package-json");
+// cliui is the CLI layout engine developed by, and used within, yargs
+// the typings for cliui do not play nice with our tsconfig, it either
+// works in build or in test but not both.
+const cliui = require('cliui');
+function printHelp(header, schema, meta) {
+    const allPositional = Object.keys(schema.properties).filter((key) => {
+        const p = schema.properties[key];
+        return p['$default'] && p['$default']['$source'] === 'argv';
+    });
+    const positional = allPositional.length > 0 ? ` [${allPositional[0]}]` : '';
+    logger_1.logger.info(`
+${output_1.output.applyNxPrefix('cyan', chalk.bold(`${`${header + chalk.reset.cyan(positional)} ${chalk.reset.cyan('[options,...]')}`}`))}
+
+${generateOverviewOutput({
+        pluginName: meta.plugin,
+        name: meta.entity,
+        description: schema.description,
+        mode: meta.mode,
+        aliases: meta.mode === 'generate' ? meta.aliases : [],
+    })}
+${generateOptionsOutput(schema)}
+${generateExamplesOutput(schema)}
+${generateLinkOutput({
+        pluginName: meta.plugin,
+        name: meta.entity,
+        type: meta.mode === 'generate' ? 'generators' : 'executors',
+    })}
+`);
+}
+exports.printHelp = printHelp;
+function generateOverviewOutput({ pluginName, name, description, mode, aliases, }) {
+    switch (mode) {
+        case 'generate':
+            return generateGeneratorOverviewOutput({
+                pluginName,
+                name,
+                description,
+                aliases,
+            });
+        case 'run':
+            return generateExecutorOverviewOutput({
+                pluginName,
+                name,
+                description,
+            });
+        default:
+            throw new Error(`Unexpected mode ${mode}`);
+    }
+}
+function generateGeneratorOverviewOutput({ pluginName, name, description, aliases, }) {
+    const ui = cliui(null);
+    const overviewItemsLabelWidth = 
+    // Chars in labels "From" and "Name"
+    4 +
+        // The `:` char
+        1;
+    let installedVersion;
+    try {
+        installedVersion = (0, package_json_1.readModulePackageJson)(pluginName).packageJson.version;
+    }
+    catch { }
+    ui.div(...[
+        {
+            text: chalk.bold('From:'),
+            padding: [1, 0, 0, 0],
+            width: overviewItemsLabelWidth,
+        },
+        {
+            text: pluginName +
+                (installedVersion ? chalk.dim(` (v${installedVersion})`) : ''),
+            padding: [1, 0, 0, 2],
+        },
+    ]);
+    ui.div(...[
+        {
+            text: chalk.bold('Name:'),
+            padding: [0, 0, 0, 0],
+            width: overviewItemsLabelWidth,
+        },
+        {
+            text: `${name}${aliases.length ? chalk.dim(` (aliases: ${aliases.join(', ')})`) : ''}`,
+            padding: [0, 0, 0, 2],
+        },
+    ]);
+    ui.div(...[
+        {
+            text: description,
+            padding: [2, 0, 1, 2],
+        },
+    ]);
+    return ui.toString();
+}
+function generateExecutorOverviewOutput({ pluginName, name, description, }) {
+    const ui = cliui(null);
+    const overviewItemsLeftPadding = 2;
+    const overviewItemsLabelWidth = overviewItemsLeftPadding + 'Executor:'.length;
+    ui.div(...[
+        {
+            text: chalk.bold('Executor:'),
+            padding: [1, 0, 0, 0],
+            width: overviewItemsLabelWidth,
+        },
+        {
+            text: `${pluginName}:${name}` +
+                (pluginName.startsWith('@nrwl/')
+                    ? chalk.dim(` (v${versions_1.nxVersion})`)
+                    : ''),
+            padding: [1, 0, 0, 0],
+        },
+    ]);
+    ui.div(...[
+        {
+            text: description,
+            padding: [2, 0, 1, 2],
+        },
+    ]);
+    return ui.toString();
+}
+const formatOptionVal = (maybeStr) => typeof maybeStr === 'string' ? `"${maybeStr}"` : JSON.stringify(maybeStr);
+// From our JSON schemas an option could possibly have more than one valid type
+const formatOptionType = (optionConfig) => {
+    if (Array.isArray(optionConfig.oneOf)) {
+        return optionConfig.oneOf
+            .map((typeConfig) => formatOptionType(typeConfig))
+            .join(' OR ');
+    }
+    return `[${optionConfig.type}]`;
+};
+function generateOptionsOutput(schema) {
+    const ui = cliui(null);
+    const flagAndAliasLeftPadding = 4;
+    const flagAndAliasRightPadding = 4;
+    // Construct option flags (including optional aliases) and descriptions and track the required space to render them
+    const optionsToRender = new Map();
+    let requiredSpaceToRenderAllFlagsAndAliases = 0;
+    const sorted = Object.entries(schema.properties).sort((a, b) => compareByPriority(a, b, schema));
+    for (const [optionName, optionConfig] of sorted) {
+        const renderedFlagAndAlias = `--${optionName}` +
+            (optionConfig.alias ? `, -${optionConfig.alias}` : '');
+        const renderedFlagAndAliasTrueWidth = stringWidth(renderedFlagAndAlias);
+        if (renderedFlagAndAliasTrueWidth > requiredSpaceToRenderAllFlagsAndAliases) {
+            requiredSpaceToRenderAllFlagsAndAliases = renderedFlagAndAliasTrueWidth;
+        }
+        const renderedDescription = optionConfig.description;
+        const renderedTypesAndDefault = `${formatOptionType(optionConfig)}${optionConfig.enum
+            ? ` [choices: ${optionConfig.enum
+                .map((e) => formatOptionVal(e))
+                .join(', ')}]`
+            : ''}${optionConfig.default
+            ? ` [default: ${formatOptionVal(optionConfig.default)}]`
+            : ''}`;
+        optionConfig.hidden ??= optionConfig.visible === false;
+        if (!optionConfig.hidden)
+            optionsToRender.set(optionName, {
+                renderedFlagAndAlias,
+                renderedDescription,
+                renderedTypesAndDefault,
+            });
+    }
+    ui.div({
+        text: 'Options:',
+        padding: [1, 0, 0, 0],
+    });
+    for (const { renderedFlagAndAlias, renderedDescription, renderedTypesAndDefault, } of optionsToRender.values()) {
+        const cols = [
+            {
+                text: renderedFlagAndAlias,
+                width: requiredSpaceToRenderAllFlagsAndAliases +
+                    flagAndAliasLeftPadding +
+                    flagAndAliasRightPadding,
+                padding: [0, flagAndAliasRightPadding, 0, flagAndAliasLeftPadding],
+            },
+            {
+                text: renderedDescription,
+                padding: [0, 0, 0, 0],
+            },
+            {
+                text: renderedTypesAndDefault,
+                padding: [0, 0, 0, 0],
+                align: 'right',
+            },
+        ];
+        ui.div(...cols);
+    }
+    return ui.toString();
+}
+function generateExamplesOutput(schema) {
+    if (!schema.examples || schema.examples.length === 0) {
+        return '';
+    }
+    const ui = cliui(null);
+    const xPadding = 4;
+    ui.div({
+        text: 'Examples:',
+        padding: [1, 0, 0, 0],
+    });
+    for (const { command, description } of schema.examples) {
+        const cols = [
+            {
+                text: command,
+                padding: [0, xPadding, 0, xPadding],
+            },
+            {
+                text: description || '',
+                padding: [0, 2, 0, 0],
+            },
+        ];
+        ui.div(...cols);
+    }
+    return ui.toString();
+}
+// TODO: generalize link generation so it works for non @nx plugins as well
+function generateLinkOutput({ pluginName, name, type, }) {
+    const nxPackagePrefix = '@nx/';
+    const nrwlPackagePrefix = '@nrwl/';
+    if (!pluginName.startsWith(nxPackagePrefix) &&
+        !pluginName.startsWith(nrwlPackagePrefix)) {
+        return '';
+    }
+    const link = `https://nx.dev/packages/${pluginName.substring(pluginName.startsWith(nxPackagePrefix)
+        ? nxPackagePrefix.length
+        : nrwlPackagePrefix.length)}/${type}/${name}`;
+    return `\n\n${chalk.dim('Find more information and examples at:')} ${chalk.bold(link)}`;
+}
+/**
+ * sorts properties in the following order
+ * - required
+ * - x-priority: important
+ * - everything else
+ * - x-priority: internal
+ * - deprecated
+ * if two properties have equal priority, they are sorted by name
+ */
+function compareByPriority(a, b, schema) {
+    function getPriority([name, property]) {
+        if (schema.required?.includes(name)) {
+            return 0;
+        }
+        if (property['x-priority'] === 'important') {
+            return 1;
+        }
+        if (property['x-deprecated']) {
+            return 4;
+        }
+        if (property['x-priority'] === 'internal') {
+            return 3;
+        }
+        return 2;
+    }
+    const aPriority = getPriority(a);
+    const bPriority = getPriority(b);
+    if (aPriority === bPriority) {
+        return a[0].localeCompare(b[0]);
+    }
+    return aPriority - bPriority;
+}

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

@@ -0,0 +1,13 @@
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+export declare function projectHasTarget(project: ProjectGraphProjectNode, target: string): boolean;
+export declare function projectHasTargetAndConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string): any;
+export declare function getSourceDirOfDependentProjects(projectName: string, projectGraph?: ProjectGraph): [projectDirs: string[], warnings: string[]];
+/**
+ * Find all internal project dependencies.
+ * All the external (npm) dependencies will be filtered out unless includeExternalDependencies is set to true
+ * @param {string} parentNodeName
+ * @param {ProjectGraph} projectGraph
+ * @param includeExternalDependencies
+ * @returns {string[]}
+ */
+export declare function findAllProjectNodeDependencies(parentNodeName: string, projectGraph?: ProjectGraph, includeExternalDependencies?: boolean): string[];

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAllProjectNodeDependencies = exports.getSourceDirOfDependentProjects = exports.projectHasTargetAndConfiguration = exports.projectHasTarget = void 0;
+const project_graph_1 = require("../project-graph/project-graph");
+function projectHasTarget(project, target) {
+    return !!(project.data &&
+        project.data.targets &&
+        project.data.targets[target]);
+}
+exports.projectHasTarget = projectHasTarget;
+function projectHasTargetAndConfiguration(project, target, configuration) {
+    return (projectHasTarget(project, target) &&
+        project.data.targets[target].configurations &&
+        project.data.targets[target].configurations[configuration]);
+}
+exports.projectHasTargetAndConfiguration = projectHasTargetAndConfiguration;
+function getSourceDirOfDependentProjects(projectName, projectGraph = (0, project_graph_1.readCachedProjectGraph)()) {
+    if (!projectGraph.nodes[projectName]) {
+        throw new Error(`Couldn't find project "${projectName}" in this Nx workspace`);
+    }
+    const nodeNames = findAllProjectNodeDependencies(projectName, projectGraph);
+    return nodeNames.reduce((result, nodeName) => {
+        if (projectGraph.nodes[nodeName].data.sourceRoot) {
+            result[0].push(projectGraph.nodes[nodeName].data.sourceRoot);
+        }
+        else {
+            result[1].push(nodeName);
+        }
+        return result;
+    }, [[], []]);
+}
+exports.getSourceDirOfDependentProjects = getSourceDirOfDependentProjects;
+/**
+ * Find all internal project dependencies.
+ * All the external (npm) dependencies will be filtered out unless includeExternalDependencies is set to true
+ * @param {string} parentNodeName
+ * @param {ProjectGraph} projectGraph
+ * @param includeExternalDependencies
+ * @returns {string[]}
+ */
+function findAllProjectNodeDependencies(parentNodeName, projectGraph = (0, project_graph_1.readCachedProjectGraph)(), includeExternalDependencies = false) {
+    const dependencyNodeNames = new Set();
+    collectDependentProjectNodesNames(projectGraph, dependencyNodeNames, parentNodeName, includeExternalDependencies);
+    return Array.from(dependencyNodeNames);
+}
+exports.findAllProjectNodeDependencies = findAllProjectNodeDependencies;
+// Recursively get all the dependencies of the node
+function collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, parentNodeName, includeExternalDependencies) {
+    const dependencies = nxDeps.dependencies[parentNodeName];
+    if (!dependencies) {
+        // no dependencies for the given node, so silently return,
+        // as we probably wouldn't want to throw here
+        return;
+    }
+    for (const dependency of dependencies) {
+        const dependencyName = dependency.target;
+        // skip dependencies already added (avoid circular dependencies)
+        if (dependencyNodeNames.has(dependencyName)) {
+            continue;
+        }
+        // we're only interested in internal nodes, not external
+        if (nxDeps.externalNodes?.[dependencyName]) {
+            if (includeExternalDependencies) {
+                dependencyNodeNames.add(dependencyName);
+            }
+            else {
+                continue;
+            }
+        }
+        dependencyNodeNames.add(dependencyName);
+        // Get the dependencies of the dependencies
+        collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, dependencyName, includeExternalDependencies);
+    }
+}

package/src/utils/promised-based-queue.d.ts

@@ -0,0 +1,6 @@
+export declare class PromisedBasedQueue {
+    private counter;
+    private promise;
+    sendToQueue(fn: () => Promise<any>): Promise<any>;
+    isEmpty(): boolean;
+}

package/src/utils/promised-based-queue.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisedBasedQueue = void 0;
+class PromisedBasedQueue {
+    constructor() {
+        this.counter = 0;
+        this.promise = Promise.resolve(null);
+    }
+    sendToQueue(fn) {
+        this.counter++;
+        let res, rej;
+        const r = new Promise((_res, _rej) => {
+            res = _res;
+            rej = _rej;
+        });
+        this.promise = this.promise
+            .then(async () => {
+            try {
+                res(await fn());
+                this.counter--;
+            }
+            catch (e) {
+                rej(e);
+                this.counter--;
+            }
+        })
+            .catch(async () => {
+            try {
+                res(await fn());
+                this.counter--;
+            }
+            catch (e) {
+                rej(e);
+                this.counter--;
+            }
+        });
+        return r;
+    }
+    isEmpty() {
+        return this.counter === 0;
+    }
+}
+exports.PromisedBasedQueue = PromisedBasedQueue;

package/src/utils/serialize-overrides-into-command-line.d.ts

@@ -0,0 +1,3 @@
+export declare function serializeOverridesIntoCommandLine(options: {
+    [k: string]: any;
+}): string[];

package/src/utils/serialize-overrides-into-command-line.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeOverridesIntoCommandLine = void 0;
+const flat_1 = require("flat");
+function serializeOverridesIntoCommandLine(options) {
+    const unparsed = options._ ? [...options._] : [];
+    for (const key of Object.keys(options)) {
+        const value = options[key];
+        if (key !== '_') {
+            serializeOption(key, value, unparsed);
+        }
+    }
+    return unparsed;
+}
+exports.serializeOverridesIntoCommandLine = serializeOverridesIntoCommandLine;
+function serializeOption(key, value, unparsed) {
+    if (value === true) {
+        unparsed.push(`--${key}`);
+    }
+    else if (value === false) {
+        unparsed.push(`--no-${key}`);
+    }
+    else if (Array.isArray(value)) {
+        value.forEach((item) => serializeOption(key, item, unparsed));
+    }
+    else if (Object.prototype.toString.call(value) === '[object Object]') {
+        const flattened = (0, flat_1.flatten)(value, { safe: true });
+        for (const flattenedKey in flattened) {
+            serializeOption(`${key}.${flattenedKey}`, flattened[flattenedKey], unparsed);
+        }
+    }
+    else if (typeof value === 'string' &&
+        stringShouldBeWrappedIntoQuotes(value)) {
+        const sanitized = value.replace(/"/g, String.raw `\"`);
+        unparsed.push(`--${key}="${sanitized}"`);
+    }
+    else if (value != null) {
+        unparsed.push(`--${key}=${value}`);
+    }
+}
+function stringShouldBeWrappedIntoQuotes(str) {
+    return str.includes(' ') || str.includes('{') || str.includes('"');
+}

package/src/utils/split-target.d.ts

@@ -0,0 +1,3 @@
+import { ProjectGraph } from '../config/project-graph';
+export declare function splitTarget(s: string, projectGraph: ProjectGraph): [project: string, target?: string, configuration?: string];
+export declare function splitByColons(s: string): [string, ...string[]];

package/src/utils/split-target.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitByColons = exports.splitTarget = void 0;
+function splitTarget(s, projectGraph) {
+    let [project, ...segments] = splitByColons(s);
+    const validTargets = projectGraph.nodes[project]
+        ? projectGraph.nodes[project].data.targets
+        : {};
+    const validTargetNames = new Set(Object.keys(validTargets ?? {}));
+    return [project, ...groupJointSegments(segments, validTargetNames)];
+}
+exports.splitTarget = splitTarget;
+function groupJointSegments(segments, validTargetNames) {
+    for (let endingSegmentIdx = segments.length; endingSegmentIdx > 0; endingSegmentIdx--) {
+        const potentialTargetName = segments.slice(0, endingSegmentIdx).join(':');
+        if (validTargetNames.has(potentialTargetName)) {
+            const configurationName = endingSegmentIdx < segments.length
+                ? segments.slice(endingSegmentIdx).join(':')
+                : null;
+            return configurationName
+                ? [potentialTargetName, configurationName]
+                : [potentialTargetName];
+        }
+    }
+    // If we can't find a segment match, keep older behaviour
+    return segments;
+}
+function splitByColons(s) {
+    const parts = [];
+    let currentPart = '';
+    for (let i = 0; i < s.length; ++i) {
+        if (s[i] === ':') {
+            parts.push(currentPart);
+            currentPart = '';
+        }
+        else if (s[i] === '"') {
+            i++;
+            for (; i < s.length && s[i] != '"'; ++i) {
+                currentPart += s[i];
+            }
+        }
+        else {
+            currentPart += s[i];
+        }
+    }
+    parts.push(currentPart);
+    return parts;
+}
+exports.splitByColons = splitByColons;

package/src/utils/strip-indents.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Removes indents, which is useful for printing warning and messages.
+ *
+ * Example:
+ *
+ * ```typescript
+ * stripIndents`
+ *  Options:
+ *  - option1
+ *  - option2
+ * `
+ * ```
+ */
+export declare function stripIndents(strings: TemplateStringsArray, ...values: any[]): string;

package/src/utils/strip-indents.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripIndents = void 0;
+/**
+ * Removes indents, which is useful for printing warning and messages.
+ *
+ * Example:
+ *
+ * ```typescript
+ * stripIndents`
+ *  Options:
+ *  - option1
+ *  - option2
+ * `
+ * ```
+ */
+function stripIndents(strings, ...values) {
+    return String.raw(strings, ...values)
+        .split('\n')
+        .map((line) => line.trim())
+        .join('\n')
+        .trim();
+}
+exports.stripIndents = stripIndents;

package/src/utils/typescript.d.ts

@@ -0,0 +1 @@
+export * from '../plugins/js/utils/typescript';

package/src/utils/typescript.js

@@ -0,0 +1,5 @@
+"use strict";
+// TODO(v19): Nx Devkit 15 depends on this file. Remove this when we no longer support Nx Devkit 15
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("../plugins/js/utils/typescript"), exports);

package/src/utils/update-nxw.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '../generators/tree';
+export declare function updateNxw(tree: Tree): void;

package/src/utils/update-nxw.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNxw = void 0;
+const add_nx_scripts_1 = require("../command-line/init/implementation/dot-nx/add-nx-scripts");
+const path_1 = require("../utils/path");
+function updateNxw(tree) {
+    const wrapperPath = (0, path_1.normalizePath)((0, add_nx_scripts_1.nxWrapperPath)());
+    if (tree.exists(wrapperPath)) {
+        tree.write(wrapperPath, (0, add_nx_scripts_1.getNxWrapperContents)());
+    }
+}
+exports.updateNxw = updateNxw;

package/src/utils/versions.d.ts

@@ -0,0 +1 @@
+export declare const nxVersion: any;

package/src/utils/versions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;

package/src/utils/workspace-configuration-check.d.ts

@@ -0,0 +1 @@
+export declare function workspaceConfigurationCheck(): void;

package/src/utils/workspace-configuration-check.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceConfigurationCheck = void 0;
+const workspace_root_1 = require("./workspace-root");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const output_1 = require("./output");
+const fileutils_1 = require("../utils/fileutils");
+//TODO: vsavkin remove after Nx 19
+function workspaceConfigurationCheck() {
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'workspace.json'))) {
+        output_1.output.warn({
+            title: 'workspace.json is ignored',
+            bodyLines: [
+                'Nx no longer reads configuration from workspace.json.',
+                'Run "nx g @nx/workspace:fix-configuration" to split workspace.json into individual project.json files.',
+            ],
+        });
+        return;
+    }
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'angular.json'))) {
+        const angularJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(workspace_root_1.workspaceRoot, 'angular.json'));
+        const v2Props = Object.values(angularJson.projects).find((p) => !!p.targets);
+        if (angularJson.version === 2 || v2Props) {
+            output_1.output.error({
+                title: 'angular.json format is incorrect',
+                bodyLines: [
+                    'Nx no longer supports the v2 format of angular.json.',
+                    'Run "nx g @nx/workspace:fix-configuration" to split angular.json into individual project.json files. (Recommended)',
+                    'If you want to preserve angular.json, run "nx g @nx/workspace:fix-configuration --reformat"',
+                ],
+            });
+            process.exit(1);
+        }
+    }
+}
+exports.workspaceConfigurationCheck = workspaceConfigurationCheck;

package/src/utils/workspace-context.d.ts

@@ -0,0 +1,10 @@
+import type { NxWorkspaceFilesExternals } from '../native';
+export declare function setupWorkspaceContext(workspaceRoot: string): void;
+export declare function getNxWorkspaceFilesFromContext(workspaceRoot: string, projectRootMap: Record<string, string>): import("../native").NxWorkspaceFiles;
+export declare function globWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): string[];
+export declare function hashWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): string;
+export declare function updateFilesInContext(updatedFiles: string[], deletedFiles: string[]): Record<string, string>;
+export declare function getAllFileDataInContext(workspaceRoot: string): import("../native").FileData[];
+export declare function getFilesInDirectoryUsingContext(workspaceRoot: string, dir: string): string[];
+export declare function updateProjectFiles(projectRootMappings: Record<string, string>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): import("../native").UpdatedWorkspaceFiles;
+export declare function resetWorkspaceContext(): void;