hammerkit 1.5.1 → 1.6.0-alpha.2

package/dist/planner/utils/{parse-work-node-mount.spec.js → parse-work-mount.spec.js}

@@ -1,59 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const parse_work_node_mount_1 = require("./parse-work-node-mount");
+const parse_work_mount_1 = require("./parse-work-mount");
 const path_1 = require("path");
 const os_1 = require("os");
 function normalizePath(val) {
     return val.split(path_1.posix.sep).join(path_1.sep);
 }
-describe('parse-work-node-mount', () => {
+describe('parse-work-mount', () => {
     it('should parse "subdir"', () => {
-        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', 'subdir')).toEqual({
+        expect((0, parse_work_mount_1.parseWorkMount)('/home/test', 'subdir')).toMatchObject({
             localPath: normalizePath('/home/test/subdir'),
             containerPath: normalizePath('/home/test/subdir'),
         });
     });
     it('should parse "./subdir"', () => {
-        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', './subdir')).toEqual({
+        expect((0, parse_work_mount_1.parseWorkMount)('/home/test', './subdir')).toMatchObject({
             localPath: normalizePath('/home/test/subdir'),
             containerPath: normalizePath('/home/test/subdir'),
         });
     });
     it('should parse "./subdir:./otherdir"', () => {
-        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', './subdir:./otherdir')).toEqual({
+        expect((0, parse_work_mount_1.parseWorkMount)('/home/test', './subdir:./otherdir')).toMatchObject({
             localPath: normalizePath('/home/test/subdir'),
             containerPath: normalizePath('/home/test/otherdir'),
         });
     });
     it('should parse "$PWD/subdir:/subdir"', () => {
-        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', '$PWD/subdir:/subdir')).toEqual({
+        expect((0, parse_work_mount_1.parseWorkMount)('/home/test', '$PWD/subdir:/subdir')).toMatchObject({
             localPath: (0, path_1.join)((0, os_1.homedir)(), 'subdir'),
             containerPath: '/subdir',
         });
     });
     it('should parse "$PWD/subdir:$PWD/subdir"', () => {
-        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', '$PWD/subdir:$PWD/subdir')).toEqual({
+        expect((0, parse_work_mount_1.parseWorkMount)('/home/test', '$PWD/subdir:$PWD/subdir')).toMatchObject({
             localPath: (0, path_1.join)((0, os_1.homedir)(), 'subdir'),
             containerPath: normalizePath('/home/test/subdir'),
         });
     });
     it('should parse "/subdir:/otherdir"', () => {
-        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', '/subdir:/otherdir')).toEqual({
+        expect((0, parse_work_mount_1.parseWorkMount)('/home/test', '/subdir:/otherdir')).toMatchObject({
             localPath: '/subdir',
             containerPath: '/otherdir',
         });
     });
     it('should parse "/subdir:otherdir"', () => {
-        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', '/subdir:otherdir')).toEqual({
+        expect((0, parse_work_mount_1.parseWorkMount)('/home/test', '/subdir:otherdir')).toMatchObject({
             localPath: '/subdir',
             containerPath: normalizePath('/home/test/otherdir'),
         });
     });
     it('should parse "subdir:/otherdir"', () => {
-        expect((0, parse_work_node_mount_1.parseWorkNodeMount)('/home/test', 'subdir:/otherdir')).toEqual({
+        expect((0, parse_work_mount_1.parseWorkMount)('/home/test', 'subdir:/otherdir')).toMatchObject({
             localPath: normalizePath('/home/test/subdir'),
             containerPath: '/otherdir',
         });
     });
+    it('throws for a mount string with more than two parts', () => {
+        expect(() => (0, parse_work_mount_1.parseWorkMount)('/home/test', 'a:b:c')).toThrow('invalid mount a:b:c');
+    });
 });
-//# sourceMappingURL=parse-work-node-mount.spec.js.map
+//# sourceMappingURL=parse-work-mount.spec.js.map

package/dist/planner/utils/parse-work-mounts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkMounts = void 0;
+const template_value_1 = require("./template-value");
+const parse_work_mount_1 = require("./parse-work-mount");
+function parseWorkMounts(cwd, schema, envs) {
+    if (!schema.mounts) {
+        return [];
+    }
+    return schema.mounts.map((m) => (0, template_value_1.templateValue)(m, envs)).map((m) => (0, parse_work_mount_1.parseWorkMount)(cwd, m));
+}
+exports.parseWorkMounts = parseWorkMounts;
+//# sourceMappingURL=parse-work-mounts.js.map

package/dist/planner/utils/parse-work-mounts.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_work_mounts_1 = require("./parse-work-mounts");
+const noEnvs = { variables: {}, replacements: [] };
+describe('parseWorkMounts', () => {
+    it('returns [] when no mounts are declared', () => {
+        expect((0, parse_work_mounts_1.parseWorkMounts)('/work', {}, noEnvs)).toEqual([]);
+    });
+    it('templates env vars and parses each mount against the cwd', () => {
+        const result = (0, parse_work_mounts_1.parseWorkMounts)('/work', { mounts: ['$PWD/.npm:/.npm', 'config:/etc/config'] }, {
+            variables: { PWD: '/home/x' },
+            replacements: [],
+        });
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({ containerPath: '/.npm' });
+        expect(result[1]).toMatchObject({ containerPath: '/etc/config' });
+    });
+});
+//# sourceMappingURL=parse-work-mounts.spec.js.map

package/dist/planner/utils/{parse-work-node-port.js → parse-work-port.js}

@@ -1,25 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWorkNodePort = void 0;
-function parseWorkNodePort(port) {
+exports.parseWorkPort = void 0;
+function parseWorkPort(port) {
     const parts = port.split(':');
     if (parts.length === 1) {
-        const port = parsePort(parts[0]);
+        const port = parsePort(parts[0], false);
         return { containerPort: port, hostPort: port };
     }
     else if (parts.length === 2) {
-        return { containerPort: parsePort(parts[1]), hostPort: parsePort(parts[0]) };
+        return { containerPort: parsePort(parts[1], false), hostPort: parsePort(parts[0], true) };
     }
     else {
         throw new Error(`invalid port ${port}`);
     }
 }
-exports.parseWorkNodePort = parseWorkNodePort;
-function parsePort(port) {
+exports.parseWorkPort = parseWorkPort;
+function parsePort(port, optional) {
     const result = parseInt(port);
     if (isNaN(result) || result === null || result === undefined) {
-        throw new Error(`invalid port ${port}`);
+        if (!optional) {
+            throw new Error(`invalid port ${port}`);
+        }
+        return null;
     }
     return result;
 }
-//# sourceMappingURL=parse-work-node-port.js.map
+//# sourceMappingURL=parse-work-port.js.map

package/dist/planner/utils/parse-work-port.spec.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_work_port_1 = require("./parse-work-port");
+describe('parse-work-port', () => {
+    it('should parse 5432', () => {
+        expect((0, parse_work_port_1.parseWorkPort)('5432')).toEqual({
+            hostPort: 5432,
+            containerPort: 5432,
+        });
+    });
+    it('should parse 5432:5433', () => {
+        expect((0, parse_work_port_1.parseWorkPort)('5432:5433')).toEqual({
+            hostPort: 5432,
+            containerPort: 5433,
+        });
+    });
+    it('throws for a port with more than two parts', () => {
+        expect(() => (0, parse_work_port_1.parseWorkPort)('1:2:3')).toThrow('invalid port 1:2:3');
+    });
+    it('throws for a non-numeric port', () => {
+        expect(() => (0, parse_work_port_1.parseWorkPort)('http')).toThrow('invalid port http');
+    });
+});
+//# sourceMappingURL=parse-work-port.spec.js.map

package/dist/planner/utils/parse-work-ports.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkPorts = void 0;
+const template_value_1 = require("./template-value");
+const parse_work_port_1 = require("./parse-work-port");
+function parseWorkPorts(schema, envs) {
+    return (schema.ports ?? []).map((m) => (0, template_value_1.templateValue)(`${m}`, envs)).map((m) => (0, parse_work_port_1.parseWorkPort)(m));
+}
+exports.parseWorkPorts = parseWorkPorts;
+//# sourceMappingURL=parse-work-ports.js.map

package/dist/planner/utils/parse-work-ports.spec.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_work_ports_1 = require("./parse-work-ports");
+const noEnvs = { variables: {}, replacements: [] };
+describe('parse-work-ports', () => {
+    it('returns an empty list when the service declares no ports', () => {
+        const schema = { image: 'postgres:12-alpine' };
+        expect((0, parse_work_ports_1.parseWorkPorts)(schema, noEnvs)).toEqual([]);
+    });
+    it('parses numeric and string ports', () => {
+        const schema = { image: 'node', ports: [5432, '8080:80'] };
+        expect((0, parse_work_ports_1.parseWorkPorts)(schema, noEnvs)).toEqual([
+            { hostPort: 5432, containerPort: 5432 },
+            { hostPort: 8080, containerPort: 80 },
+        ]);
+    });
+    it('templates env vars in port values', () => {
+        const schema = { image: 'node', ports: ['$PORT:80'] };
+        expect((0, parse_work_ports_1.parseWorkPorts)(schema, { variables: { PORT: '9090' }, replacements: [] })).toEqual([
+            { hostPort: 9090, containerPort: 80 },
+        ]);
+    });
+});
+//# sourceMappingURL=parse-work-ports.spec.js.map

package/dist/planner/utils/parse-work-source.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSource = exports.parseWorkSource = void 0;
+const minimatch_1 = require("minimatch");
+const path_1 = require("path");
+const template_value_1 = require("./template-value");
+// minimatch globs are always '/'-separated; on Windows path.join/relative yield
+// '\\', which minimatch treats as escape chars (so a native pattern never
+// matches). Normalize both the pattern and the candidate to posix before
+// matching. No-op on posix, where sep === posix.sep.
+const toPosix = (value) => (path_1.sep === path_1.posix.sep ? value : value.split(path_1.sep).join(path_1.posix.sep));
+function parseWorkSource(cwd, sources, envs) {
+    const result = [];
+    if (!sources) {
+        return result;
+    }
+    for (const source of sources) {
+        const wildcardIndex = source.indexOf('*');
+        if (wildcardIndex >= 0) {
+            if (wildcardIndex === 0) {
+                const absolutePath = cwd;
+                result.push({
+                    matcher: (file, cwd) => {
+                        const matcher = new minimatch_1.Minimatch(source, { dot: true });
+                        return matcher.match(toPosix((0, path_1.relative)(cwd, file)));
+                    },
+                    inherited: null,
+                    source,
+                    absolutePath,
+                    isFile: false,
+                });
+            }
+            else {
+                const prefixSource = source.substring(0, wildcardIndex);
+                const absolutePath = (0, path_1.join)(cwd, (0, template_value_1.templateValue)(prefixSource, envs));
+                result.push({
+                    matcher: (file, cwd) => {
+                        const matcher = new minimatch_1.Minimatch(toPosix((0, path_1.join)(cwd, source)), { dot: true });
+                        return matcher.match(toPosix(file));
+                    },
+                    inherited: null,
+                    source,
+                    absolutePath,
+                    isFile: false,
+                });
+            }
+        }
+        else {
+            const absolutePath = (0, path_1.join)(cwd, (0, template_value_1.templateValue)(source, envs));
+            result.push({
+                matcher: (file) => file.startsWith(absolutePath),
+                absolutePath,
+                source,
+                inherited: null,
+                isFile: (0, path_1.extname)(absolutePath).length > 1,
+            });
+        }
+    }
+    return result;
+}
+exports.parseWorkSource = parseWorkSource;
+function createSource(absolutePath) {
+    return {
+        matcher: (file) => file.startsWith(absolutePath),
+        absolutePath,
+        source: absolutePath,
+        inherited: null,
+        isFile: (0, path_1.extname)(absolutePath).length > 1,
+    };
+}
+exports.createSource = createSource;
+//# sourceMappingURL=parse-work-source.js.map

package/dist/planner/utils/parse-work-source.spec.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const parse_work_source_1 = require("./parse-work-source");
+const noEnvs = { variables: {}, replacements: [] };
+// parseWorkSource builds absolutePath via path.join and the no-wildcard matcher
+// compares with String.startsWith, so both are native-separated. Author the
+// expectations in posix and convert to the host separator. No-op on posix.
+const toNative = (value) => value.split(path_1.posix.sep).join(path_1.sep);
+describe('parse-work-source', () => {
+    it('returns an empty list for null/undefined sources', () => {
+        expect((0, parse_work_source_1.parseWorkSource)('/proj', null, noEnvs)).toEqual([]);
+        expect((0, parse_work_source_1.parseWorkSource)('/proj', undefined, noEnvs)).toEqual([]);
+    });
+    describe('without a wildcard', () => {
+        it('treats a path with an extension as a file', () => {
+            const [src] = (0, parse_work_source_1.parseWorkSource)('/proj', ['dist/app.js'], noEnvs);
+            expect(src.absolutePath).toBe(toNative('/proj/dist/app.js'));
+            expect(src.isFile).toBe(true);
+            expect(src.matcher(toNative('/proj/dist/app.js'), '/proj')).toBe(true);
+            expect(src.matcher(toNative('/proj/dist/other.js'), '/proj')).toBe(false);
+        });
+        it('treats a path without an extension as a directory', () => {
+            const [src] = (0, parse_work_source_1.parseWorkSource)('/proj', ['src'], noEnvs);
+            expect(src.absolutePath).toBe(toNative('/proj/src'));
+            expect(src.isFile).toBe(false);
+            expect(src.matcher(toNative('/proj/src/index.ts'), '/proj')).toBe(true);
+        });
+    });
+    describe('with a leading wildcard', () => {
+        it('anchors the absolute path to cwd and matches relative paths', () => {
+            const [src] = (0, parse_work_source_1.parseWorkSource)('/proj', ['*.spec.ts'], noEnvs);
+            expect(src.absolutePath).toBe('/proj');
+            expect(src.isFile).toBe(false);
+            expect(src.matcher('/proj/a.spec.ts', '/proj')).toBe(true);
+            expect(src.matcher('/proj/a.ts', '/proj')).toBe(false);
+        });
+    });
+    describe('with a mid-string wildcard', () => {
+        it('uses the prefix for the absolute path and globs against the full path', () => {
+            const [src] = (0, parse_work_source_1.parseWorkSource)('/proj', ['src/*.ts'], noEnvs);
+            expect(src.absolutePath).toBe(toNative('/proj/src/'));
+            expect(src.isFile).toBe(false);
+            expect(src.matcher('/proj/src/a.ts', '/proj')).toBe(true);
+            expect(src.matcher('/proj/src/sub/a.ts', '/proj')).toBe(false);
+        });
+    });
+    describe('createSource', () => {
+        it('builds a prefix matcher from an absolute path', () => {
+            const src = (0, parse_work_source_1.createSource)('/proj/dist');
+            expect(src.absolutePath).toBe('/proj/dist');
+            expect(src.source).toBe('/proj/dist');
+            expect(src.matcher('/proj/dist/app.js', '/proj')).toBe(true);
+            expect(src.matcher('/proj/other', '/proj')).toBe(false);
+        });
+    });
+});
+//# sourceMappingURL=parse-work-source.spec.js.map

package/dist/planner/utils/parse-work-volume.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkVolumes = exports.parseWorkVolume = void 0;
+const normalize_path_1 = require("./normalize-path");
+const plan_work_volume_1 = require("./plan-work-volume");
+const template_value_1 = require("./template-value");
+function parseWorkVolume(cwd, volume, envs) {
+    if (typeof volume === 'string') {
+        const parts = volume.split(':');
+        if (parts.length === 2) {
+            return parseVolume(cwd, parts[0], parts[1]);
+        }
+        else {
+            throw new Error(`invalid volume ${volume}`);
+        }
+    }
+    else {
+        const path = (0, template_value_1.templateValue)(volume.path, envs);
+        return {
+            containerPath: path,
+            export: volume.export ?? false,
+            name: volume.name ? (0, template_value_1.templateValue)(volume.name, envs) : (0, plan_work_volume_1.getVolumeName)(path),
+            inherited: null,
+            resetOnChange: volume.resetOnChange ?? false,
+        };
+    }
+}
+exports.parseWorkVolume = parseWorkVolume;
+function parseWorkVolumes(cwd, volumes, envs) {
+    if (!volumes) {
+        return [];
+    }
+    return volumes.map((v) => parseWorkVolume(cwd, v, envs));
+}
+exports.parseWorkVolumes = parseWorkVolumes;
+function parseVolume(cwd, name, containerPath) {
+    return {
+        name,
+        resetOnChange: false,
+        containerPath: (0, normalize_path_1.normalizePath)(cwd, cwd, containerPath),
+        inherited: null,
+        export: false,
+    };
+}
+//# sourceMappingURL=parse-work-volume.js.map

package/dist/planner/utils/parse-work-volume.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parse_work_volume_1 = require("./parse-work-volume");
+describe('parse-work-volume', () => {
+    it('should parse projdata:/usr/data', () => {
+        expect((0, parse_work_volume_1.parseWorkVolume)('/home/user/proj', 'projdata:/usr/data', { replacements: [], variables: {} })).toEqual({
+            name: 'projdata',
+            containerPath: '/usr/data',
+            resetOnChange: false,
+            export: false,
+            inherited: null,
+        });
+    });
+    it('throws for a volume string that is not name:path', () => {
+        expect(() => (0, parse_work_volume_1.parseWorkVolume)('/home/user/proj', 'a:b:c', { replacements: [], variables: {} })).toThrow('invalid volume a:b:c');
+    });
+});
+//# sourceMappingURL=parse-work-volume.spec.js.map

package/dist/planner/utils/plan-work-tasks.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasError = exports.hasErrorService = exports.hasErrorTask = exports.iterateWorkTasks = exports.iterateWorkServices = void 0;
+function* iterateWorkServices(workTree) {
+    for (const service of Object.values(workTree.services)) {
+        yield service;
+    }
+}
+exports.iterateWorkServices = iterateWorkServices;
+function* iterateWorkTasks(workTree) {
+    for (const task of Object.values(workTree.tasks)) {
+        yield task;
+    }
+}
+exports.iterateWorkTasks = iterateWorkTasks;
+function hasErrorTask(workTree) {
+    for (const task of iterateWorkTasks(workTree)) {
+        if (task.state.current.type === 'error') {
+            return true;
+        }
+    }
+    return false;
+}
+exports.hasErrorTask = hasErrorTask;
+function hasErrorService(workTree) {
+    for (const task of iterateWorkServices(workTree)) {
+        if (task.state.current.type === 'error') {
+            return true;
+        }
+    }
+    return false;
+}
+exports.hasErrorService = hasErrorService;
+function hasError(workTree) {
+    if (hasErrorService(workTree)) {
+        return true;
+    }
+    return hasErrorTask(workTree);
+}
+exports.hasError = hasError;
+//# sourceMappingURL=plan-work-tasks.js.map

package/dist/planner/utils/plan-work-tasks.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plan_work_tasks_1 = require("./plan-work-tasks");
+const ok = { state: { current: { type: 'completed' } } };
+const err = { state: { current: { type: 'error' } } };
+const tree = (services, tasks) => ({ services, tasks });
+describe('plan-work-tasks iterators and error helpers', () => {
+    it('iterateWorkServices yields every service value', () => {
+        const t = tree({ a: { id: 'A' }, b: { id: 'B' } }, {});
+        expect([...(0, plan_work_tasks_1.iterateWorkServices)(t)].map((s) => s.id)).toEqual(['A', 'B']);
+    });
+    it('iterateWorkTasks yields every task value', () => {
+        const t = tree({}, { a: { id: 'A' } });
+        expect([...(0, plan_work_tasks_1.iterateWorkTasks)(t)].map((s) => s.id)).toEqual(['A']);
+    });
+    it('hasErrorTask is true iff a task is in error', () => {
+        expect((0, plan_work_tasks_1.hasErrorTask)(tree({}, { a: ok }))).toBe(false);
+        expect((0, plan_work_tasks_1.hasErrorTask)(tree({}, { a: ok, b: err }))).toBe(true);
+    });
+    it('hasErrorService is true iff a service is in error', () => {
+        expect((0, plan_work_tasks_1.hasErrorService)(tree({ a: ok }, {}))).toBe(false);
+        expect((0, plan_work_tasks_1.hasErrorService)(tree({ a: err }, {}))).toBe(true);
+    });
+    it('hasError covers both services and tasks', () => {
+        expect((0, plan_work_tasks_1.hasError)(tree({}, {}))).toBe(false);
+        expect((0, plan_work_tasks_1.hasError)(tree({ a: err }, {}))).toBe(true);
+        expect((0, plan_work_tasks_1.hasError)(tree({}, { a: err }))).toBe(true);
+    });
+});
+//# sourceMappingURL=plan-work-tasks.spec.js.map

package/dist/planner/utils/plan-work-volume.js

@@ -23,6 +23,7 @@ function getContainerVolumes(task, mounts) {
             name,
             containerPath: generate.path,
             inherited: generate.inherited,
+            export: generate.export,
         });
     }
     return volumes;

package/dist/planner/utils/plan-work-volume.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plan_work_volume_1 = require("./plan-work-volume");
+describe('plan-work-volume', () => {
+    describe('generateId / getVolumeName', () => {
+        it('hashes the input deterministically (sha1)', () => {
+            expect((0, plan_work_volume_1.generateId)('a')).toBe((0, plan_work_volume_1.generateId)('a'));
+            expect((0, plan_work_volume_1.generateId)('a')).not.toBe((0, plan_work_volume_1.generateId)('b'));
+            expect((0, plan_work_volume_1.getVolumeName)('x')).toMatch(/^hammerkit-[a-f0-9]{40}$/);
+        });
+    });
+    describe('getContainerVolumes', () => {
+        const task = {
+            generates: [
+                { path: '/out/a', volumeName: 'na', inherited: null, resetOnChange: true, export: false, isFile: false },
+                { path: '/out/b', volumeName: 'nb', inherited: null, resetOnChange: false, export: true, isFile: false },
+            ],
+        };
+        it('emits a named volume for every generate that has no matching mount', () => {
+            const volumes = (0, plan_work_volume_1.getContainerVolumes)(task, []);
+            expect(volumes.map((v) => v.containerPath)).toEqual(['/out/a', '/out/b']);
+            expect(volumes[0].resetOnChange).toBe(true);
+            expect(volumes[1].export).toBe(true);
+            expect(volumes[0].name).toMatch(/^hammerkit-/);
+        });
+        it('skips a generate whose path is already mounted (mount wins)', () => {
+            const mounts = [{ containerPath: '/out/a' }];
+            const volumes = (0, plan_work_volume_1.getContainerVolumes)(task, mounts);
+            expect(volumes.map((v) => v.containerPath)).toEqual(['/out/b']);
+        });
+    });
+});
+//# sourceMappingURL=plan-work-volume.spec.js.map

package/dist/planner/utils/split-name.js

@@ -4,10 +4,10 @@ exports.splitName = void 0;
 function splitName(name) {
     const index = name.indexOf(':');
     if (index > 0) {
-        return { prefix: name.substr(0, index), taskName: name.substr(index + 1) };
+        return { prefix: name.substring(0, index), name: name.substring(index + 1) };
     }
     else {
-        return { taskName: name };
+        return { name };
     }
 }
 exports.splitName = splitName;

package/dist/planner/utils/split-name.spec.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const split_name_1 = require("./split-name");
+describe('split-name', () => {
+    it('should split test:bar', () => {
+        const result = (0, split_name_1.splitName)('test:bar');
+        expect(result.name).toEqual('bar');
+        expect(result.prefix).toEqual('test');
+    });
+    it('should not split test', () => {
+        const result = (0, split_name_1.splitName)('test');
+        expect(result.name).toEqual('test');
+        expect(result.prefix).toEqual(undefined);
+    });
+});
+//# sourceMappingURL=split-name.spec.js.map

package/dist/planner/utils/template-value.js

@@ -6,8 +6,7 @@ function templateValue(value, envs) {
         return value;
     }
     let result = value;
-    for (const key of Object.keys(envs)) {
-        const envValue = envs[key];
+    for (const [key, envValue] of Object.entries(envs.variables)) {
         result = result.replace(new RegExp(`\\$${key}`, 'gi'), envValue);
     }
     return result;

package/dist/planner/utils/template-value.spec.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const template_value_1 = require("./template-value");
+describe('template-value', () => {
+    it('should template string value', () => {
+        const value = (0, template_value_1.templateValue)('echo $VAR', { variables: { VAR: 'hello' }, replacements: [] });
+        expect(value).toEqual('echo hello');
+    });
+    it('should leave missing envs', () => {
+        const value = (0, template_value_1.templateValue)('echo $VAR', { variables: {}, replacements: [] });
+        expect(value).toEqual('echo $VAR');
+    });
+});
+//# sourceMappingURL=template-value.spec.js.map