nx 14.3.6 → 14.4.0-beta.2

package/src/hasher/hasher.js

@@ -1,24 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hasher = void 0;
+exports.expandNamedInput = exports.splitInputsIntoSelfAndDependencies = exports.Hasher = void 0;
 const tslib_1 = require("tslib");
-const workspaces_1 = require("../config/workspaces");
 const child_process_1 = require("child_process");
-const fs_1 = require("fs");
 const minimatch = require("minimatch");
-const path_1 = require("path");
-const perf_hooks_1 = require("perf_hooks");
+const fs_1 = require("fs");
 const typescript_1 = require("../utils/typescript");
-const workspace_root_1 = require("../utils/workspace-root");
-const file_utils_1 = require("../project-graph/file-utils");
 const hashing_impl_1 = require("./hashing-impl");
 const fileutils_1 = require("../utils/fileutils");
+const path_1 = require("../utils/path");
+const workspace_root_1 = require("../utils/workspace-root");
+const path_2 = require("path");
 /**
  * The default hasher used by executors.
  */
 class Hasher {
     constructor(projectGraph, nxJson, options, hashing = undefined) {
-        var _a;
+        var _a, _b;
         this.projectGraph = projectGraph;
         this.nxJson = nxJson;
         this.options = options;
@@ -29,34 +27,56 @@ class Hasher {
             // this is only used for testing
             this.hashing = hashing;
         }
-        this.projectHashes = new ProjectHasher(this.projectGraph, this.hashing, {
-            selectivelyHashTsConfig: (_a = this.options.selectivelyHashTsConfig) !== null && _a !== void 0 ? _a : false,
-        });
+        const legacyRuntimeInputs = (this.options && this.options.runtimeCacheInputs
+            ? this.options.runtimeCacheInputs
+            : []).map((r) => ({ runtime: r }));
+        const legacyFilesetInputs = [
+            ...Object.keys((_a = this.nxJson.implicitDependencies) !== null && _a !== void 0 ? _a : {}),
+            'nx.json',
+            //TODO: vsavkin move the special cases into explicit ts support
+            'package-lock.json',
+            'yarn.lock',
+            'pnpm-lock.yaml',
+            // ignore files will change the set of inputs to the hasher
+            '.gitignore',
+            '.nxignore',
+        ].map((d) => ({ fileset: `{workspaceRoot}/${d}` }));
+        this.taskHasher = new TaskHasher(nxJson, legacyRuntimeInputs, legacyFilesetInputs, this.projectGraph, this.readTsConfig(), this.hashing, { selectivelyHashTsConfig: (_b = this.options.selectivelyHashTsConfig) !== null && _b !== void 0 ? _b : false });
     }
-    hashTaskWithDepsAndContext(task, filter = 'all-files') {
+    hashTask(task) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const res = yield this.taskHasher.hashTask(task, [task.target.project]);
             const command = this.hashCommand(task);
-            const values = (yield Promise.all([
-                this.projectHashes.hashProject(task.target.project, [task.target.project], filter),
-                this.implicitDepsHash(),
-                this.runtimeInputsHash(),
-            ]));
-            const value = this.hashing.hashArray([
-                Hasher.version,
-                command,
-                ...values.map((v) => v.value),
-            ]);
             return {
-                value,
+                value: this.hashArray([res.value, command]),
                 details: {
                     command,
-                    nodes: values[0].nodes,
-                    implicitDeps: values[1].files,
-                    runtime: values[2].runtime,
+                    nodes: res.details,
+                    implicitDeps: {},
+                    runtime: {},
                 },
             };
         });
     }
+    /**
+     * @deprecated use hashTask instead
+     */
+    hashTaskWithDepsAndContext(task) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return this.hashTask(task);
+        });
+    }
+    /**
+     * @deprecated hashTask will hash runtime inputs and global files
+     */
+    hashContext() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return {
+                implicitDeps: '',
+                runtime: '',
+            };
+        });
+    }
     hashCommand(task) {
         var _a, _b, _c;
         const overrides = Object.assign({}, task.overrides);
@@ -72,21 +92,13 @@ class Hasher {
             JSON.stringify(sortedOverrides),
         ]);
     }
-    hashContext() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const values = (yield Promise.all([
-                this.implicitDepsHash(),
-                this.runtimeInputsHash(),
-            ]));
-            return {
-                implicitDeps: values[0],
-                runtime: values[1],
-            };
-        });
-    }
+    /**
+     * @deprecated use hashTask
+     */
     hashSource(task) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return this.projectHashes.hashProjectNodeSource(task.target.project, 'all-files');
+            const hash = yield this.taskHasher.hashTask(task, [task.target.project]);
+            return hash.details[`${task.target.project}:$filesets`];
         });
     }
     hashArray(values) {
@@ -95,277 +107,330 @@ class Hasher {
     hashFile(path) {
         return this.hashing.hashFile(path);
     }
-    runtimeInputsHash() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (this.runtimeInputs)
-                return this.runtimeInputs;
-            perf_hooks_1.performance.mark('hasher:runtime inputs hash:start');
-            this.runtimeInputs = new Promise((res, rej) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                const inputs = this.options && this.options.runtimeCacheInputs
-                    ? this.options.runtimeCacheInputs
-                    : [];
-                if (inputs.length > 0) {
-                    try {
-                        const values = (yield Promise.all(inputs.map((input) => new Promise((res, rej) => {
-                            (0, child_process_1.exec)(input, (err, stdout, stderr) => {
-                                if (err) {
-                                    rej(err);
-                                }
-                                else {
-                                    res({ input, value: `${stdout}${stderr}`.trim() });
-                                }
-                            });
-                        }))));
-                        const value = this.hashing.hashArray(values.map((v) => v.value));
-                        const runtime = values.reduce((m, c) => ((m[c.input] = c.value), m), {});
-                        perf_hooks_1.performance.mark('hasher:runtime inputs hash:end');
-                        perf_hooks_1.performance.measure('hasher:runtime inputs hash', 'hasher:runtime inputs hash:start', 'hasher:runtime inputs hash:end');
-                        res({ value, runtime });
-                    }
-                    catch (e) {
-                        rej(new Error(`Nx failed to execute runtimeCacheInputs defined in nx.json failed:\n${e.message}`));
-                    }
-                }
-                else {
-                    res({ value: '', runtime: {} });
-                }
-            }));
-            return this.runtimeInputs;
-        });
-    }
-    implicitDepsHash() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (this.implicitDependencies)
-                return this.implicitDependencies;
-            perf_hooks_1.performance.mark('hasher:implicit deps hash:start');
-            this.implicitDependencies = new Promise((res) => {
-                var _a, _b;
-                const implicitDeps = Object.keys((_a = this.nxJson.implicitDependencies) !== null && _a !== void 0 ? _a : {});
-                const filesWithoutPatterns = implicitDeps.filter((p) => p.indexOf('*') === -1);
-                const patterns = implicitDeps.filter((p) => p.indexOf('*') !== -1);
-                const implicitDepsFromPatterns = patterns.length > 0
-                    ? ((_b = this.projectGraph.allWorkspaceFiles) !== null && _b !== void 0 ? _b : [])
-                        .filter((f) => !!patterns.find((pattern) => minimatch(f.file, pattern)))
-                        .map((f) => f.file)
-                    : [];
-                const fileNames = [
-                    ...filesWithoutPatterns,
-                    ...implicitDepsFromPatterns,
-                    //TODO: vsavkin move the special cases into explicit ts support
-                    'package-lock.json',
-                    'yarn.lock',
-                    'pnpm-lock.yaml',
-                    // ignore files will change the set of inputs to the hasher
-                    '.gitignore',
-                    '.nxignore',
-                ];
-                const fileHashes = [
-                    ...fileNames
-                        .map((maybeRelativePath) => {
-                        // Normalize the path to always be absolute and starting with workspaceRoot so we can check it exists
-                        if (!maybeRelativePath.startsWith(workspace_root_1.workspaceRoot)) {
-                            return (0, path_1.join)(workspace_root_1.workspaceRoot, maybeRelativePath);
-                        }
-                        return maybeRelativePath;
-                    })
-                        .filter((file) => (0, fs_1.existsSync)(file))
-                        .map((file) => {
-                        // we should use default file hasher here
-                        const hash = this.hashing.hashFile(file);
-                        return { file, hash };
-                    }),
-                    ...this.hashNxJson(),
-                ];
-                const combinedHash = this.hashing.hashArray(fileHashes.map((v) => v.hash));
-                perf_hooks_1.performance.mark('hasher:implicit deps hash:end');
-                perf_hooks_1.performance.measure('hasher:implicit deps hash', 'hasher:implicit deps hash:start', 'hasher:implicit deps hash:end');
-                res({
-                    value: combinedHash,
-                    files: fileHashes.reduce((m, c) => ((m[c.file] = c.hash), m), {}),
-                });
-            });
-            return this.implicitDependencies;
-        });
-    }
-    hashNxJson() {
-        const nxJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'nx.json');
-        if (!(0, fs_1.existsSync)(nxJsonPath)) {
-            return [];
-        }
-        let nxJsonContents = '{}';
+    readTsConfig() {
+        var _a;
+        var _b;
         try {
-            const nxJson = (0, fileutils_1.readJsonFile)(nxJsonPath);
-            delete nxJson.projects;
-            nxJsonContents = JSON.stringify(nxJson);
+            const res = (0, fileutils_1.readJsonFile)((0, typescript_1.getRootTsConfigFileName)());
+            (_a = (_b = res.compilerOptions).paths) !== null && _a !== void 0 ? _a : (_b.paths = {});
+            return res;
+        }
+        catch (_c) {
+            return {
+                compilerOptions: { paths: {} },
+            };
         }
-        catch (_a) { }
-        return [
-            {
-                hash: this.hashing.hashArray([nxJsonContents]),
-                file: 'nx.json',
-            },
-        ];
     }
 }
 exports.Hasher = Hasher;
-Hasher.version = '2.0';
-class ProjectHasher {
-    constructor(projectGraph, hashing, options) {
+Hasher.version = '3.0';
+const DEFAULT_INPUTS = [
+    {
+        projects: 'self',
+        fileset: 'default',
+    },
+    {
+        projects: 'dependencies',
+        input: 'default',
+    },
+];
+class TaskHasher {
+    constructor(nxJson, legacyRuntimeInputs, legacyFilesetInputs, projectGraph, tsConfigJson, hashing, options) {
+        this.nxJson = nxJson;
+        this.legacyRuntimeInputs = legacyRuntimeInputs;
+        this.legacyFilesetInputs = legacyFilesetInputs;
         this.projectGraph = projectGraph;
+        this.tsConfigJson = tsConfigJson;
         this.hashing = hashing;
         this.options = options;
-        this.sourceHashes = {};
-        this.workspaceJson = this.readWorkspaceConfigFile((0, file_utils_1.workspaceFileName)());
-        this.nxJson = this.readNxJsonConfigFile('nx.json');
-        this.tsConfigJson = this.readTsConfig();
+        this.filesetHashes = {};
+        this.runtimeHashes = {};
     }
-    hashProject(projectName, visited, filter) {
+    hashTask(task, visited) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             return Promise.resolve().then(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 var _a;
-                const deps = (_a = this.projectGraph.dependencies[projectName]) !== null && _a !== void 0 ? _a : [];
-                const depHashes = (yield Promise.all(deps.map((d) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const projectNode = this.projectGraph.nodes[task.target.project];
+                if (!projectNode) {
+                    return this.hashExternalDependency(task);
+                }
+                const projectGraphDeps = (_a = this.projectGraph.dependencies[task.target.project]) !== null && _a !== void 0 ? _a : [];
+                const { selfInputs, depsInputs } = this.inputs(task, projectNode);
+                const self = yield this.hashSelfInputs(task, selfInputs);
+                const deps = yield this.hashDepsTasks(depsInputs, projectGraphDeps, visited);
+                let details = {};
+                for (const s of self) {
+                    details = Object.assign(Object.assign({}, details), s.details);
+                }
+                for (const s of deps) {
+                    details = Object.assign(Object.assign({}, details), s.details);
+                }
+                const value = this.hashing.hashArray([
+                    ...self.map((d) => d.value),
+                    ...deps.map((d) => d.value),
+                ]);
+                return { value, details };
+            }));
+        });
+    }
+    hashDepsTasks(inputs, projectGraphDeps, visited) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(inputs.map((input) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                return yield Promise.all(projectGraphDeps.map((d) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                     if (visited.indexOf(d.target) > -1) {
                         return null;
                     }
                     else {
                         visited.push(d.target);
-                        return yield this.hashProject(d.target, visited, filter);
+                        return yield this.hashTask({
+                            id: `${d.target}:$input:${input.input}`,
+                            target: {
+                                project: d.target,
+                                target: '$input',
+                                configuration: input.input,
+                            },
+                            overrides: {},
+                        }, visited);
                     }
-                })))).filter((r) => !!r);
-                const filterForProject = filter === 'all-files'
-                    ? 'all-files'
-                    : filter === 'exclude-tests-of-deps' && visited[0] === projectName
-                        ? 'all-files'
-                        : 'exclude-tests';
-                const projectHash = yield this.hashProjectNodeSource(projectName, filterForProject);
-                const nodes = depHashes.reduce((m, c) => {
-                    return Object.assign(Object.assign({}, m), c.nodes);
-                }, { [projectName]: projectHash });
-                const value = this.hashing.hashArray([
-                    ...depHashes.map((d) => d.value),
-                    projectHash,
-                ]);
-                return { value, nodes };
-            }));
+                })));
+            }))))
+                .flat()
+                .filter((r) => !!r);
+        });
+    }
+    inputs(task, projectNode) {
+        if (task.target.target === '$input') {
+            return {
+                depsInputs: [{ input: task.target.configuration }],
+                selfInputs: expandNamedInput(task.target.configuration, Object.assign(Object.assign({}, this.nxJson.namedInputs), projectNode.data.namedInputs)),
+            };
+        }
+        else {
+            const targetData = projectNode.data.targets[task.target.target];
+            const targetDefaults = (this.nxJson.targetDefaults || {})[task.target.target];
+            // task from TaskGraph can be added here
+            return splitInputsIntoSelfAndDependencies(targetData.inputs || (targetDefaults === null || targetDefaults === void 0 ? void 0 : targetDefaults.inputs) || DEFAULT_INPUTS, Object.assign(Object.assign({}, this.nxJson.namedInputs), projectNode.data.namedInputs));
+        }
+    }
+    hashExternalDependency(task) {
+        var _a;
+        const n = this.projectGraph.externalNodes[task.target.project];
+        const version = (_a = n === null || n === void 0 ? void 0 : n.data) === null || _a === void 0 ? void 0 : _a.version;
+        let hash;
+        if (version) {
+            hash = this.hashing.hashArray([version]);
+        }
+        else {
+            // unknown dependency
+            // this may occur if a file has a dependency to a npm package
+            // which is not directly registestered in package.json
+            // but only indirectly through dependencies of registered
+            // npm packages
+            // when it is at a later stage registered in package.json
+            // the cache project graph will not know this module but
+            // the new project graph will know it
+            // The actual checksum added here is of no importance as
+            // the version is unknown and may only change when some
+            // other change occurs in package.json and/or package-lock.json
+            hash = `__${task.target.project}__`;
+        }
+        return {
+            value: hash,
+            details: {
+                [task.target.project]: version || hash,
+            },
+        };
+    }
+    hashSelfInputs(task, inputs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const filesets = inputs
+                .filter((r) => !!r['fileset'])
+                .map((r) => r['fileset']);
+            const projectFilesets = filesets.filter((r) => !r.startsWith('{workspaceRoot}'));
+            const rootFilesets = filesets.filter((r) => r.startsWith('{workspaceRoot}/'));
+            return Promise.all([
+                this.hashTaskFileset(task, projectFilesets),
+                ...[
+                    ...rootFilesets,
+                    ...this.legacyFilesetInputs.map((r) => r.fileset),
+                ].map((fileset) => this.hashRootFileset(fileset)),
+                ...[...inputs, ...this.legacyRuntimeInputs]
+                    .filter((r) => !r['fileset'])
+                    .map((r) => r['runtime'] ? this.hashRuntime(r['runtime']) : this.hashEnv(r['env'])),
+            ]);
         });
     }
-    hashProjectNodeSource(projectName, filter) {
+    hashRootFileset(fileset) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const mapKey = `${projectName}-${filter}`;
-            if (!this.sourceHashes[mapKey]) {
-                this.sourceHashes[mapKey] = new Promise((res) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    var _a, _b;
-                    const p = this.projectGraph.nodes[projectName];
-                    if (!p) {
-                        const n = this.projectGraph.externalNodes[projectName];
-                        const version = (_a = n === null || n === void 0 ? void 0 : n.data) === null || _a === void 0 ? void 0 : _a.version;
-                        let hash;
-                        if (version) {
-                            hash = this.hashing.hashArray([version]);
-                        }
-                        else {
-                            // unknown dependency
-                            // this may occur if a file has a dependency to a npm package
-                            // which is not directly registestered in package.json
-                            // but only indirectly through dependencies of registered
-                            // npm packages
-                            // when it is at a later stage registered in package.json
-                            // the cache project graph will not know this module but
-                            // the new project graph will know it
-                            // The actual checksum added here is of no importance as
-                            // the version is unknown and may only change when some
-                            // other change occurs in package.json and/or package-lock.json
-                            hash = `__${projectName}__`;
+            const mapKey = fileset;
+            const withoutWorkspaceRoot = fileset.substring(16);
+            if (!this.filesetHashes[mapKey]) {
+                this.filesetHashes[mapKey] = new Promise((res) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    const parts = [];
+                    if (fileset.indexOf('*') > -1) {
+                        this.projectGraph.allWorkspaceFiles
+                            .filter((f) => minimatch(f.file, withoutWorkspaceRoot))
+                            .forEach((f) => {
+                            parts.push(this.hashing.hashFile((0, path_2.join)(workspace_root_1.workspaceRoot, f.file)));
+                        });
+                    }
+                    else {
+                        if ((0, fs_1.existsSync)((0, path_2.join)(workspace_root_1.workspaceRoot, withoutWorkspaceRoot))) {
+                            parts.push(this.hashing.hashFile((0, path_2.join)(workspace_root_1.workspaceRoot, withoutWorkspaceRoot)));
                         }
-                        res(hash);
-                        return;
                     }
-                    const filteredFiles = filter === 'all-files'
-                        ? p.data.files
-                        : p.data.files.filter((f) => !this.isSpec(f.file));
+                    const value = this.hashing.hashArray(parts);
+                    res({
+                        value,
+                        details: { [mapKey]: value },
+                    });
+                }));
+            }
+            return this.filesetHashes[mapKey];
+        });
+    }
+    hashTaskFileset(task, filesetPatterns) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const mapKey = `${task.target.project}:$filesets`;
+            if (!this.filesetHashes[mapKey]) {
+                this.filesetHashes[mapKey] = new Promise((res) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    const p = this.projectGraph.nodes[task.target.project];
+                    const filteredFiles = this.filterFiles(p.data.files, filesetPatterns);
                     const fileNames = filteredFiles.map((f) => f.file);
                     const values = filteredFiles.map((f) => f.hash);
-                    const workspaceJson = JSON.stringify((_b = this.workspaceJson.projects[projectName]) !== null && _b !== void 0 ? _b : '');
                     let tsConfig;
-                    if (this.options.selectivelyHashTsConfig) {
-                        tsConfig = this.removeOtherProjectsPathRecords(projectName);
-                    }
-                    else {
-                        tsConfig = JSON.stringify(this.tsConfigJson);
-                    }
-                    res(this.hashing.hashArray([
+                    tsConfig = this.hashTsConfig(p);
+                    const value = this.hashing.hashArray([
                         ...fileNames,
                         ...values,
-                        workspaceJson,
+                        JSON.stringify(Object.assign(Object.assign({}, p.data), { files: undefined })),
                         tsConfig,
-                    ]));
+                    ]);
+                    res({
+                        value,
+                        details: { [mapKey]: value },
+                    });
                 }));
             }
-            return this.sourceHashes[mapKey];
+            return this.filesetHashes[mapKey];
+        });
+    }
+    hashRuntime(runtime) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const mapKey = `runtime:${runtime}`;
+            if (!this.runtimeHashes[mapKey]) {
+                this.runtimeHashes[mapKey] = new Promise((res, rej) => {
+                    (0, child_process_1.exec)(runtime, (err, stdout, stderr) => {
+                        if (err) {
+                            rej(new Error(`Nx failed to execute {runtime: '${runtime}'}. ${err}.`));
+                        }
+                        else {
+                            const value = `${stdout}${stderr}`.trim();
+                            res({
+                                details: { [`runtime:${runtime}`]: value },
+                                value,
+                            });
+                        }
+                    });
+                });
+            }
+            return this.runtimeHashes[mapKey];
         });
     }
-    isSpec(file) {
-        return (file.endsWith('.spec.tsx') ||
-            file.endsWith('.test.tsx') ||
-            file.endsWith('-test.tsx') ||
-            file.endsWith('-spec.tsx') ||
-            file.endsWith('.spec.ts') ||
-            file.endsWith('.test.ts') ||
-            file.endsWith('-test.ts') ||
-            file.endsWith('-spec.ts') ||
-            file.endsWith('.spec.js') ||
-            file.endsWith('.test.js') ||
-            file.endsWith('-test.js') ||
-            file.endsWith('-spec.js'));
+    hashEnv(envVarName) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const value = this.hashing.hashArray([process.env[envVarName]]);
+            return {
+                details: { [`runtime:${envVarName}`]: value },
+                value,
+            };
+        });
     }
-    removeOtherProjectsPathRecords(projectName) {
-        var _a;
-        const _b = this.tsConfigJson.compilerOptions, { paths } = _b, compilerOptions = tslib_1.__rest(_b, ["paths"]);
-        const rootPath = this.workspaceJson.projects[projectName].root.split('/');
+    filterFiles(files, patterns) {
+        patterns = patterns.filter((p) => p !== 'default');
+        if (patterns.length === 0)
+            return files;
+        return files.filter((f) => !!patterns.find((pattern) => minimatch(f.file, pattern)));
+    }
+    hashTsConfig(p) {
+        if (this.options.selectivelyHashTsConfig) {
+            return this.removeOtherProjectsPathRecords(p);
+        }
+        else {
+            return JSON.stringify(this.tsConfigJson);
+        }
+    }
+    removeOtherProjectsPathRecords(p) {
+        var _a, _b;
+        const _c = this.tsConfigJson.compilerOptions, { paths } = _c, compilerOptions = tslib_1.__rest(_c, ["paths"]);
+        const rootPath = p.data.root.split('/');
         rootPath.shift();
-        const pathAlias = `@${this.nxJson.npmScope}/${rootPath.join('/')}`;
+        const pathAlias = (0, path_1.getImportPath)((_a = this.nxJson) === null || _a === void 0 ? void 0 : _a.npmScope, rootPath.join('/'));
         return JSON.stringify({
             compilerOptions: Object.assign(Object.assign({}, compilerOptions), { paths: {
-                    [pathAlias]: (_a = paths[pathAlias]) !== null && _a !== void 0 ? _a : [],
+                    [pathAlias]: (_b = paths[pathAlias]) !== null && _b !== void 0 ? _b : [],
                 } }),
         });
     }
-    readTsConfig() {
-        var _a;
-        var _b;
-        try {
-            const res = (0, fileutils_1.readJsonFile)((0, typescript_1.getRootTsConfigFileName)());
-            (_a = (_b = res.compilerOptions).paths) !== null && _a !== void 0 ? _a : (_b.paths = {});
-            return res;
-        }
-        catch (_c) {
-            return {
-                compilerOptions: { paths: {} },
-            };
-        }
-    }
-    readWorkspaceConfigFile(path) {
-        var _a;
-        try {
-            const res = (0, fileutils_1.readJsonFile)(path);
-            (_a = res.projects) !== null && _a !== void 0 ? _a : (res.projects = {});
-            return (0, workspaces_1.resolveNewFormatWithInlineProjects)(res);
+}
+function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
+    const depsInputs = [];
+    const selfInputs = [];
+    for (const d of inputs) {
+        if (typeof d === 'string') {
+            if (d.startsWith('^')) {
+                depsInputs.push({ input: d.substring(1) });
+            }
+            else {
+                selfInputs.push(d);
+            }
         }
-        catch (_b) {
-            return { projects: {}, version: 2 };
+        else {
+            if (d.projects === 'dependencies') {
+                depsInputs.push(d);
+            }
+            else {
+                selfInputs.push(d);
+            }
         }
     }
-    readNxJsonConfigFile(path) {
-        var _a;
-        try {
-            const res = (0, fileutils_1.readJsonFile)(path);
-            (_a = res.projects) !== null && _a !== void 0 ? _a : (res.projects = {});
-            return res;
+    return { depsInputs, selfInputs: expandSelfInputs(selfInputs, namedInputs) };
+}
+exports.splitInputsIntoSelfAndDependencies = splitInputsIntoSelfAndDependencies;
+function expandSelfInputs(inputs, namedInputs) {
+    const expanded = [];
+    for (const d of inputs) {
+        if (typeof d === 'string') {
+            if (d.startsWith('^'))
+                throw new Error(`namedInputs definitions cannot start with ^`);
+            if (namedInputs[d]) {
+                expanded.push(...expandNamedInput(d, namedInputs));
+            }
+            else {
+                expanded.push({ fileset: d });
+            }
         }
-        catch (_b) {
-            return {};
+        else {
+            if (d.projects === 'dependencies') {
+                throw new Error(`namedInputs definitions cannot contain any inputs with projects == 'dependencies'`);
+            }
+            if (d.fileset || d.env || d.runtime) {
+                expanded.push(d);
+            }
+            else {
+                expanded.push(...expandNamedInput(d.input, namedInputs));
+            }
         }
     }
+    return expanded;
+}
+function expandNamedInput(input, namedInputs) {
+    if (input === 'default')
+        return [{ fileset: 'default' }];
+    namedInputs || (namedInputs = {});
+    if (!namedInputs[input])
+        throw new Error(`Input '${input}' is not defined`);
+    return expandSelfInputs(namedInputs[input], namedInputs);
 }
+exports.expandNamedInput = expandNamedInput;
 //# sourceMappingURL=hasher.js.map