nx 14.4.0-beta.0 → 14.4.0-beta.3

package/src/hasher/hasher.js

@@ -1,23 +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 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 hashing_impl_1 = require("./hashing-impl");
 const fileutils_1 = require("../utils/fileutils");
-const configuration_1 = require("../config/configuration");
+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;
@@ -28,53 +27,78 @@ class Hasher {
             // this is only used for testing
             this.hashing = hashing;
         }
-        this.taskHasher = new TaskHasher(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) {
+    hashTask(task) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const values = (yield Promise.all([
-                this.taskHasher.hashTask(task, [task.target.project]),
-                this.implicitDepsHash(),
-                this.runtimeInputsHash(),
-            ]));
-            const value = this.hashing.hashArray([
-                Hasher.version,
-                ...values.map((v) => v.value),
-            ]);
+            const res = yield this.taskHasher.hashTask(task, [task.target.project]);
+            const command = this.hashCommand(task);
             return {
-                value,
+                value: this.hashArray([res.value, command]),
                 details: {
-                    command: values[0].command,
-                    nodes: values[0].nodes,
-                    implicitDeps: values[1].files,
-                    runtime: values[2].runtime,
+                    command,
+                    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* () {
-            const values = (yield Promise.all([
-                this.implicitDepsHash(),
-                this.runtimeInputsHash(),
-            ]));
             return {
-                implicitDeps: values[0],
-                runtime: values[1],
+                implicitDeps: '',
+                runtime: '',
             };
         });
     }
     hashCommand(task) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (yield this.taskHasher.hashTask(task, [task.target.project]))
-                .command;
-        });
+        var _a, _b, _c;
+        const overrides = Object.assign({}, task.overrides);
+        delete overrides['__overrides_unparsed__'];
+        const sortedOverrides = {};
+        for (let k of Object.keys(overrides).sort()) {
+            sortedOverrides[k] = overrides[k];
+        }
+        return this.hashing.hashArray([
+            (_a = task.target.project) !== null && _a !== void 0 ? _a : '',
+            (_b = task.target.target) !== null && _b !== void 0 ? _b : '',
+            (_c = task.target.configuration) !== null && _c !== void 0 ? _c : '',
+            JSON.stringify(sortedOverrides),
+        ]);
     }
+    /**
+     * @deprecated use hashTask
+     */
     hashSource(task) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (yield this.taskHasher.hashTask(task, [task.target.project])).value;
+            const hash = yield this.taskHasher.hashTask(task, [task.target.project]);
+            return hash.details[`${task.target.project}:$filesets`];
         });
     }
     hashArray(values) {
@@ -83,119 +107,44 @@ 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,
-                    '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',
-                ];
-                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 };
-                    }),
-                ];
-                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;
-        });
+    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: {} },
+            };
+        }
     }
 }
 exports.Hasher = Hasher;
 Hasher.version = '3.0';
+const DEFAULT_INPUTS = [
+    {
+        projects: 'self',
+        fileset: 'default',
+    },
+    {
+        projects: 'dependencies',
+        input: 'default',
+    },
+];
 class TaskHasher {
-    constructor(projectGraph, hashing, options) {
+    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.DEFAULT_FILESET_CONFIG = [
-            {
-                projects: 'self',
-                fileset: 'default',
-            },
-            {
-                projects: 'dependencies',
-                fileset: 'default',
-            },
-        ];
         this.filesetHashes = {};
-        this.tsConfigJson = this.readTsConfig();
-        this.nxJson = (0, configuration_1.readNxJson)();
+        this.runtimeHashes = {};
     }
     hashTask(task, visited) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -206,28 +155,27 @@ class TaskHasher {
                     return this.hashExternalDependency(task);
                 }
                 const projectGraphDeps = (_a = this.projectGraph.dependencies[task.target.project]) !== null && _a !== void 0 ? _a : [];
-                const filesetConfigs = this.filesetConfigs(task, projectNode);
-                const self = yield this.hashSelfFilesets(filesetConfigs, projectNode);
-                const deps = yield this.hashDepsTasks(filesetConfigs, projectGraphDeps, visited);
-                const command = this.hashCommand(task);
-                const nodes = deps.reduce((m, c) => {
-                    return Object.assign(Object.assign({}, m), c.nodes);
-                }, {});
-                self.forEach((r) => (nodes[r.taskId] = r.value));
+                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([
-                    command,
                     ...self.map((d) => d.value),
                     ...deps.map((d) => d.value),
                 ]);
-                return { value, command, nodes };
+                return { value, details };
             }));
         });
     }
-    hashDepsTasks(config, projectGraphDeps, visited) {
+    hashDepsTasks(inputs, projectGraphDeps, visited) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (yield Promise.all(config
-                .filter((fileset) => fileset.projects === 'dependencies')
-                .map((fileset) => 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;
@@ -235,11 +183,11 @@ class TaskHasher {
                     else {
                         visited.push(d.target);
                         return yield this.hashTask({
-                            id: `${d.target}:$fileset:${fileset.fileset}`,
+                            id: `${d.target}:$input:${input.input}`,
                             target: {
                                 project: d.target,
-                                target: '$fileset',
-                                configuration: fileset.fileset,
+                                target: '$input',
+                                configuration: input.input,
                             },
                             overrides: {},
                         }, visited);
@@ -250,33 +198,18 @@ class TaskHasher {
                 .filter((r) => !!r);
         });
     }
-    hashSelfFilesets(config, projectNode) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return yield Promise.all(config
-                .filter((fileset) => fileset.projects === 'self')
-                .map((fileset) => this.hashFilesetSource(projectNode.name, fileset.fileset)));
-        });
-    }
-    filesetConfigs(task, projectNode) {
-        if (task.target.target === '$fileset') {
-            return [
-                {
-                    fileset: task.target.configuration,
-                    projects: 'self',
-                },
-                {
-                    fileset: task.target.configuration,
-                    projects: 'dependencies',
-                },
-            ];
+    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];
+            const targetDefaults = (this.nxJson.targetDefaults || {})[task.target.target];
             // task from TaskGraph can be added here
-            return expandFilesetConfigSyntaxSugar(targetData.dependsOnFilesets ||
-                (targetDefaults === null || targetDefaults === void 0 ? void 0 : targetDefaults.dependsOnFilesets) ||
-                this.DEFAULT_FILESET_CONFIG);
+            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) {
@@ -303,71 +236,120 @@ class TaskHasher {
         }
         return {
             value: hash,
-            command: '',
-            nodes: {
+            details: {
                 [task.target.project]: version || hash,
             },
         };
     }
-    hashCommand(task) {
-        var _a, _b, _c;
-        const overrides = Object.assign({}, task.overrides);
-        delete overrides['__overrides_unparsed__'];
-        const sortedOverrides = {};
-        for (let k of Object.keys(overrides).sort()) {
-            sortedOverrides[k] = overrides[k];
-        }
-        return this.hashing.hashArray([
-            (_a = task.target.project) !== null && _a !== void 0 ? _a : '',
-            (_b = task.target.target) !== null && _b !== void 0 ? _b : '',
-            (_c = task.target.configuration) !== null && _c !== void 0 ? _c : '',
-            JSON.stringify(sortedOverrides),
-        ]);
+    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'])),
+            ]);
+        });
+    }
+    hashRootFileset(fileset) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            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)));
+                        }
+                    }
+                    const value = this.hashing.hashArray(parts);
+                    res({
+                        value,
+                        details: { [mapKey]: value },
+                    });
+                }));
+            }
+            return this.filesetHashes[mapKey];
+        });
     }
-    hashFilesetSource(projectName, filesetName) {
+    hashTaskFileset(task, filesetPatterns) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const mapKey = `${projectName}:$fileset:${filesetName}`;
+            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[projectName];
-                    const filesetPatterns = this.selectFilesetPatterns(p, filesetName);
+                    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);
                     let tsConfig;
                     tsConfig = this.hashTsConfig(p);
+                    const value = this.hashing.hashArray([
+                        ...fileNames,
+                        ...values,
+                        JSON.stringify(Object.assign(Object.assign({}, p.data), { files: undefined })),
+                        tsConfig,
+                    ]);
                     res({
-                        taskId: mapKey,
-                        value: this.hashing.hashArray([
-                            ...fileNames,
-                            ...values,
-                            JSON.stringify(Object.assign(Object.assign({}, p.data), { files: undefined })),
-                            tsConfig,
-                        ]),
+                        value,
+                        details: { [mapKey]: value },
                     });
                 }));
             }
             return this.filesetHashes[mapKey];
         });
     }
-    selectFilesetPatterns(p, filesetName) {
-        if (filesetName == undefined) {
-            filesetName = 'default';
-        }
-        const projectFilesets = p.data.filesets
-            ? p.data.filesets[filesetName]
-            : null;
-        const defaultFilesets = this.nxJson.filesets
-            ? this.nxJson.filesets[filesetName]
-            : null;
-        if (projectFilesets)
-            return projectFilesets;
-        if (defaultFilesets)
-            return defaultFilesets;
-        return null;
+    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];
+        });
+    }
+    hashEnv(envVarName) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const value = this.hashing.hashArray([(_a = process.env[envVarName]) !== null && _a !== void 0 ? _a : '']);
+            return {
+                details: { [`env:${envVarName}`]: value },
+                value,
+            };
+        });
     }
     filterFiles(files, patterns) {
-        if (patterns === null)
+        patterns = patterns.filter((p) => p !== 'default');
+        if (patterns.length === 0)
             return files;
         return files.filter((f) => !!patterns.find((pattern) => minimatch(f.file, pattern)));
     }
@@ -380,45 +362,76 @@ class TaskHasher {
         }
     }
     removeOtherProjectsPathRecords(p) {
-        var _a;
-        const _b = this.tsConfigJson.compilerOptions, { paths } = _b, compilerOptions = tslib_1.__rest(_b, ["paths"]);
+        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;
+}
+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 (_c) {
-            return {
-                compilerOptions: { paths: {} },
-            };
+        else {
+            if (d.projects === 'dependencies') {
+                depsInputs.push(d);
+            }
+            else {
+                selfInputs.push(d);
+            }
         }
     }
+    return { depsInputs, selfInputs: expandSelfInputs(selfInputs, namedInputs) };
 }
-function expandFilesetConfigSyntaxSugar(deps) {
-    return deps.map((d) => {
+exports.splitInputsIntoSelfAndDependencies = splitInputsIntoSelfAndDependencies;
+function expandSelfInputs(inputs, namedInputs) {
+    const expanded = [];
+    for (const d of inputs) {
         if (typeof d === 'string') {
-            if (d.startsWith('^')) {
-                return { projects: 'dependencies', fileset: d.substring(1) };
+            if (d.startsWith('^'))
+                throw new Error(`namedInputs definitions cannot start with ^`);
+            if (namedInputs[d]) {
+                expanded.push(...expandNamedInput(d, namedInputs));
             }
             else {
-                return { projects: 'self', fileset: d };
+                expanded.push({ fileset: d });
             }
         }
         else {
-            return d;
+            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