@zokugun/artifact 0.8.0 → 0.9.0

package/lib/types/context.d.ts

@@ -1,9 +1,10 @@
 import { type Primitive } from '@zokugun/is-it-type';
-import { type AsyncDResult } from '@zokugun/xtry';
+import { type DResult, type AsyncDResult } from '@zokugun/xtry';
+import { type Transform } from '../parsers/jsonc/transform.js';
 import { type BinaryFile } from './binary-file.js';
 import { type Request, type InstallConfig, type PackageConfig, type ArtifactResult, type PackageManifest, type FileTransform } from './config.js';
 import { type Indent, type Format } from './format.js';
-import { type Journey } from './travel.js';
+import { type JourneyPlan, type Route, type Journey } from './travel.js';
 export type ExistingAction = 'merge' | 'overwrite' | 'skip';
 export type MissingAction = 'continue' | 'skip';
 export type RenameAction = {
@@ -17,6 +18,7 @@ export type Context = {
     config: InstallConfig;
     filters: (file: string) => string[] | undefined;
     formats: Format[];
+    global: Global;
     incomingName?: string;
     incomingVersion?: string;
     incomingVariant?: string;
@@ -25,6 +27,7 @@ export type Context = {
     incomingPackage?: PackageManifest;
     incomingPath: string;
     mergedTextFiles: TextFile[];
+    mode: Mode;
     onExisting: (file: string) => ExistingAction;
     onMissing: (file: string) => MissingAction;
     options: Options;
@@ -39,7 +42,16 @@ export type Context = {
     transformedFiles: TextFile[];
     transforms: (file: string) => FileTransform[] | undefined;
 };
-export type MainFlow = (targetPath: string, incomingPath: string, request: Request, config: InstallConfig, options: Options) => AsyncDResult<Context | undefined>;
+export declare enum Mode {
+    Default = 0,
+    Overwritten = 1
+}
+export type Global = {
+    journeys: Record<string, JourneyPlan>;
+    overwrittenTextFiles: string[];
+    routes: Record<string, Route<any>>;
+};
+export type MainFlow = (targetPath: string, incomingPath: string, request: Request, config: InstallConfig, global: Global, options: Options) => AsyncDResult<Context | undefined>;
 export type CommonFlow = (name: string, version: string, variant: string | undefined, branch: string | undefined, incomingPath: string, commonContext: Context) => AsyncDResult<Context | undefined>;
 export type Options = {
     force: boolean;
@@ -62,3 +74,11 @@ export type TextFile = {
     mode?: number;
     name: string;
 };
+export type ParseResult = DResult<{
+    data: Record<string, unknown>;
+    transform?: Transform;
+}>;
+export type Codec = {
+    parse: (data: string) => ParseResult;
+    stringify: (data: Record<string, unknown>, transform?: Transform) => string;
+};

package/lib/types/context.js

@@ -1,2 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mode = void 0;
+var Mode;
+(function (Mode) {
+    Mode[Mode["Default"] = 0] = "Default";
+    Mode[Mode["Overwritten"] = 1] = "Overwritten";
+})(Mode || (exports.Mode = Mode = {}));

package/lib/types/travel.d.ts

@@ -12,3 +12,4 @@ export type Journey = {
     alias?: string;
     travel: Route<string>;
 };
+export type JourneyPlan = (basename: string) => Journey | undefined;

package/lib/utils/build-journey-plan.d.ts

@@ -1,2 +1,2 @@
-import { type Journey, type TravelPlan } from '../types/travel.js';
-export declare function buildJourneyPlan(plan: TravelPlan, alias?: string): (basename: string) => Journey | undefined;
+import { type JourneyPlan, type TravelPlan } from '../types/travel.js';
+export declare function buildJourneyPlan(plan: TravelPlan, alias?: string): JourneyPlan;

package/lib/utils/build-route.d.ts

@@ -1,3 +1,3 @@
 import { type DResult } from '@zokugun/xtry';
 import { type Route } from '../types/travel.js';
-export declare function buildRoute(route: any): DResult<Route<any>>;
+export declare function buildRoute(route: unknown): DResult<Route<any>>;

package/lib/utils/build-route.js

@@ -18,43 +18,54 @@ function buildRoute(route) {
                 result = (0, index_js_1.mapSort)(result);
             }
             else {
-                return (0, xtry_1.err)('Can\'t build route');
+                return (0, xtry_1.err)(`Cannot build route "${JSON.stringify(route)}"`);
             }
         }
         return (0, xtry_1.ok)(result);
     }
     else if ((0, is_it_type_1.isRecord)(route)) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const { compose: rtCompose, fork: rtFork, mapSort: rtMapSort } = route;
-        if (rtCompose) {
+        if ((0, is_it_type_1.isRecord)(route.compose)) {
             const map = {};
-            for (const [name, route] of Object.entries(rtCompose)) {
-                const result = buildRoute(route);
-                if (result.fails) {
-                    return result;
+            const entries = Object.entries(route.compose);
+            for (const [name, route] of entries) {
+                if (name === '$$ignore' || name === '$$remove') {
+                    map[name] = route;
+                }
+                else {
+                    const result = buildRoute(route);
+                    if (result.fails) {
+                        return result;
+                    }
+                    map[name] = result.value;
                 }
-                map[name] = result.value;
             }
             return (0, xtry_1.ok)((0, index_js_1.compose)(map));
         }
-        else if (rtFork) {
+        else if ((0, is_it_type_1.isRecord)(route.fork)) {
             const map = [];
-            if (rtFork.array) {
-                const result = buildRoute(rtFork.array);
+            if (route.fork.array) {
+                const result = buildRoute(route.fork.array);
                 if (result.fails) {
                     return result;
                 }
                 map.push([Array.isArray, result.value]);
             }
-            if (rtFork.object) {
-                const result = buildRoute(rtFork.object);
+            if (route.fork.object) {
+                const result = buildRoute(route.fork.object);
                 if (result.fails) {
                     return result;
                 }
                 map.push([is_it_type_1.isRecord, result.value]);
             }
-            if (rtFork.default) {
-                const result = buildRoute(rtFork.default);
+            if (route.fork.default) {
+                const result = buildRoute(route.fork.default);
+                if (result.fails) {
+                    return result;
+                }
+                map.push(result.value);
+            }
+            else if (route.fork.$$default) {
+                const result = buildRoute(route.fork.$$default);
                 if (result.fails) {
                     return result;
                 }
@@ -62,13 +73,27 @@ function buildRoute(route) {
             }
             return (0, xtry_1.ok)((0, fork_js_1.fork)(...map));
         }
-        else if (rtMapSort) {
-            const result = buildRoute(rtMapSort);
+        else if (route.json) {
+            const result = buildRoute(route.json);
+            if (result.fails) {
+                return result;
+            }
+            return (0, xtry_1.ok)((0, index_js_1.json)(result.value));
+        }
+        else if (route.mapSort) {
+            const result = buildRoute(route.mapSort);
             if (result.fails) {
                 return result;
             }
             return (0, xtry_1.ok)((0, index_js_1.mapSort)(result.value));
         }
+        else if (route.yaml) {
+            const result = buildRoute(route.yaml);
+            if (result.fails) {
+                return result;
+            }
+            return (0, xtry_1.ok)((0, index_js_1.yaml)(result.value));
+        }
     }
     else if (route === 'command') {
         return (0, xtry_1.ok)(index_js_2.command);
@@ -79,14 +104,20 @@ function buildRoute(route) {
     else if (route === 'listConcat') {
         return (0, xtry_1.ok)(index_js_2.listConcat);
     }
+    else if (route === 'listConcatAfter') {
+        return (0, xtry_1.ok)(index_js_2.listConcatAfter);
+    }
     else if (route === 'mapConcat') {
         return (0, xtry_1.ok)(index_js_2.mapConcat);
     }
+    else if (route === 'mergeDotJs') {
+        return (0, xtry_1.ok)(index_js_2.mergeDotJs);
+    }
     else if (route === 'overwrite') {
         return (0, xtry_1.ok)(index_js_2.overwrite);
     }
     else if (route === 'primitive') {
         return (0, xtry_1.ok)(index_js_2.primitive);
     }
-    return (0, xtry_1.err)('Can\'t build route');
+    return (0, xtry_1.err)(`Cannot build route "${JSON.stringify(route)}"`);
 } // }}}

package/lib/utils/build-travel-plan.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildTravelPlan = buildTravelPlan;
+// import { fnmatch } from './fnmatch.js';
 function buildTravelPlan(...mappers) {
     return (basename) => {
         const mapper = mappers.find((mapper) => {

package/lib/utils/command/merge-and-chains.js

@@ -23,7 +23,7 @@ function mergeAndChains(current, incoming) {
     if (!positionalMatch) {
         // Merge by matching prefixes across current segments, append unmatched incoming segments.
         const merged = (0, merge_parts_by_prefix_js_1.mergePartsByPrefix)(currentAnd, incomingAnd);
-        return merged.join('; ');
+        return merged.join(' && ');
     }
     // Positional merge: iterate positions, merge flags when prefixes equal, otherwise
     // decide ordering: if incoming's semicolon tail contains current segment, prefer incoming in chain and move current to tail;

package/lib/utils/command/merge-command-records.js

@@ -25,7 +25,7 @@ async function mergeCommandRecords(currentCommand, incomingCommand, currentStrin
                     };
                     const currentPrefix = getPrefix(currentInstance.args);
                     const incomingPrefix = getPrefix(instance.args);
-                    const shouldMerge = currentPrefix && incomingPrefix && currentPrefix === incomingPrefix && (hasFlags(currentInstance.args) || hasFlags(instance.args) || (currentInstance.env.length > 0) || (instance.env.length > 0));
+                    const shouldMerge = (currentPrefix === incomingPrefix) && (hasFlags(currentInstance.args) || hasFlags(instance.args) || (currentInstance.env.length > 0) || (instance.env.length > 0));
                     if (shouldMerge) {
                         // replace with merged instance
                         result[name][index] = {

package/lib/utils/command/merge-parts-by-prefix.js

@@ -5,6 +5,8 @@ const merge_flag_tokens_js_1 = require("./merge-flag-tokens.js");
 const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function mergePartsByPrefix(currentParts, incomingParts) {
     const result = [...currentParts];
+    // Track the index of the last position where we merged or inserted an incoming part
+    let lastIndex = null;
     for (const incomingPart of incomingParts) {
         const incomingPrefix = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingPart);
         let merged = false;
@@ -14,11 +16,20 @@ function mergePartsByPrefix(currentParts, incomingParts) {
                 const mergedFlags = (0, merge_flag_tokens_js_1.mergeFlagTokens)(currentPrefix.flags, incomingPrefix.flags);
                 result[k] = currentPrefix.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : '');
                 merged = true;
+                lastIndex = k;
                 break;
             }
         }
         if (!merged) {
-            result.push(incomingPart);
+            // If we previously merged or inserted, place the new incoming part immediately after that position
+            if (lastIndex === null) {
+                result.push(incomingPart);
+                lastIndex = result.length - 1;
+            }
+            else {
+                result.splice(lastIndex + 1, 0, incomingPart);
+                lastIndex += 1;
+            }
         }
     }
     return result;

package/lib/utils/command/merge-semicolon-segments.js

@@ -11,7 +11,13 @@ const split_segments_js_1 = require("./split-segments.js");
 function mergeSemicolonSegments(current, incoming) {
     let currentSegments = (0, split_segments_js_1.splitSegments)(current);
     const incomingSegments = (0, split_segments_js_1.splitSegments)(incoming);
-    for (const incomingSegment of incomingSegments) {
+    // Pre-scan incoming segments to find which ones match existing current segments by prefix
+    const initialMatchedIndices = incomingSegments.map((seg) => {
+        const p = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(seg).prefix;
+        return currentSegments.findIndex((cs) => (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(cs).prefix === p);
+    });
+    for (let incomingIndex = 0; incomingIndex < incomingSegments.length; incomingIndex++) {
+        const incomingSegment = incomingSegments[incomingIndex];
         // If the incoming segment is itself a chain (&& or ||), merge subparts accordingly
         if (incomingSegment.includes('||')) {
             const incomingParts = incomingSegment.split('||').map((s) => s.trim()).filter(Boolean);
@@ -38,7 +44,58 @@ function mergeSemicolonSegments(current, incoming) {
                 }
             }
             if (!mergedIntoCurrent) {
-                currentSegments.push(incomingSegment);
+                // Determine insertion position based on matched incoming segments context
+                let previousMatch = -1;
+                for (let j = incomingIndex - 1; j >= 0; j--) {
+                    const mi = initialMatchedIndices[j];
+                    if (mi >= 0) {
+                        const pref = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegments[j]).prefix;
+                        const pos = currentSegments.findIndex((cs) => (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(cs).prefix === pref);
+                        if (pos !== -1) {
+                            previousMatch = pos;
+                            break;
+                        }
+                    }
+                }
+                let nextMatch = -1;
+                for (let j = incomingIndex + 1; j < incomingSegments.length; j++) {
+                    const mi = initialMatchedIndices[j];
+                    if (mi >= 0) {
+                        const pref = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegments[j]).prefix;
+                        const pos = currentSegments.findIndex((cs) => (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(cs).prefix === pref);
+                        if (pos !== -1) {
+                            nextMatch = pos;
+                            break;
+                        }
+                    }
+                }
+                const incomingBase = ((0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegment).prefix || incomingSegment).split(' ')[0];
+                let basePos = null;
+                for (let k = currentSegments.length - 1; k >= 0; k--) {
+                    const cp = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentSegments[k]).prefix || currentSegments[k];
+                    const cpBase = cp.split(' ')[0];
+                    if (cpBase === incomingBase) {
+                        basePos = k;
+                        break;
+                    }
+                }
+                let insertPos;
+                if ((previousMatch >= 0) && (nextMatch >= 0)) {
+                    insertPos = previousMatch + 1;
+                }
+                else if ((basePos !== null) && (nextMatch < 0)) {
+                    insertPos = basePos + 1;
+                }
+                else if (previousMatch >= 0) {
+                    insertPos = previousMatch + 1;
+                }
+                else if (nextMatch >= 0) {
+                    insertPos = nextMatch + 1;
+                }
+                else {
+                    insertPos = currentSegments.length;
+                }
+                currentSegments.splice(insertPos, 0, incomingSegment);
             }
             continue;
         }
@@ -95,7 +152,57 @@ function mergeSemicolonSegments(current, incoming) {
                 }
             }
             if (!mergedIntoCurrent) {
-                currentSegments.push(incomingSegment);
+                let previousMatch = -1;
+                for (let j = incomingIndex - 1; j >= 0; j--) {
+                    const mi = initialMatchedIndices[j];
+                    if (mi >= 0) {
+                        const pref = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegments[j]).prefix;
+                        const pos = currentSegments.findIndex((cs) => (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(cs).prefix === pref);
+                        if (pos !== -1) {
+                            previousMatch = pos;
+                            break;
+                        }
+                    }
+                }
+                let nextMatch = -1;
+                for (let j = incomingIndex + 1; j < incomingSegments.length; j++) {
+                    const mi = initialMatchedIndices[j];
+                    if (mi >= 0) {
+                        const pref = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegments[j]).prefix;
+                        const pos = currentSegments.findIndex((cs) => (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(cs).prefix === pref);
+                        if (pos !== -1) {
+                            nextMatch = pos;
+                            break;
+                        }
+                    }
+                }
+                const incomingBase = ((0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegment).prefix || incomingSegment).split(' ')[0];
+                let basePos = null;
+                for (let k = currentSegments.length - 1; k >= 0; k--) {
+                    const cp = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentSegments[k]).prefix || currentSegments[k];
+                    const cpBase = cp.split(' ')[0];
+                    if (cpBase === incomingBase) {
+                        basePos = k;
+                        break;
+                    }
+                }
+                let insertPos;
+                if ((previousMatch >= 0) && (nextMatch >= 0)) {
+                    insertPos = previousMatch + 1;
+                }
+                else if ((basePos !== null) && (nextMatch < 0)) {
+                    insertPos = basePos + 1;
+                }
+                else if (previousMatch >= 0) {
+                    insertPos = previousMatch + 1;
+                }
+                else if (nextMatch >= 0) {
+                    insertPos = nextMatch + 1;
+                }
+                else {
+                    insertPos = currentSegments.length;
+                }
+                currentSegments.splice(insertPos, 0, incomingSegment);
             }
             continue;
         }
@@ -110,7 +217,57 @@ function mergeSemicolonSegments(current, incoming) {
             }
         }
         if (!matched) {
-            currentSegments.push(incomingSegment);
+            let previousMatch = -1;
+            for (let j = incomingIndex - 1; j >= 0; j--) {
+                const mi = initialMatchedIndices[j];
+                if (mi >= 0) {
+                    const pref = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegments[j]).prefix;
+                    const pos = currentSegments.findIndex((cs) => (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(cs).prefix === pref);
+                    if (pos !== -1) {
+                        previousMatch = pos;
+                        break;
+                    }
+                }
+            }
+            let nextMatch = -1;
+            for (let j = incomingIndex + 1; j < incomingSegments.length; j++) {
+                const mi = initialMatchedIndices[j];
+                if (mi >= 0) {
+                    const pref = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegments[j]).prefix;
+                    const pos = currentSegments.findIndex((cs) => (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(cs).prefix === pref);
+                    if (pos !== -1) {
+                        nextMatch = pos;
+                        break;
+                    }
+                }
+            }
+            const incomingBase = (incomingPartsObject.prefix || incomingSegment).split(' ')[0];
+            let basePos = null;
+            for (let k = currentSegments.length - 1; k >= 0; k--) {
+                const cp = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentSegments[k]).prefix || currentSegments[k];
+                const cpBase = cp.split(' ')[0];
+                if (cpBase === incomingBase) {
+                    basePos = k;
+                    break;
+                }
+            }
+            let insertPos;
+            if ((previousMatch >= 0) && (nextMatch >= 0)) {
+                insertPos = previousMatch + 1;
+            }
+            else if ((basePos !== null) && (nextMatch < 0)) {
+                insertPos = basePos + 1;
+            }
+            else if (previousMatch >= 0) {
+                insertPos = previousMatch + 1;
+            }
+            else if (nextMatch >= 0) {
+                insertPos = nextMatch + 1;
+            }
+            else {
+                insertPos = currentSegments.length;
+            }
+            currentSegments.splice(insertPos, 0, incomingSegment);
         }
     }
     // Deduplicate top-level semicolon segments by prefix, preserving first occurrence

package/lib/utils/fnmatch.d.ts

@@ -0,0 +1 @@
+export declare function fnmatch(filepath: string, glob: string): boolean;

package/lib/utils/fnmatch.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnmatch = fnmatch;
+const fnmatch_1 = __importDefault(require("editorconfig/src/lib/fnmatch"));
+function fnmatch(filepath, glob) {
+    const matchOptions = { matchBase: true, dot: true, noext: true };
+    return (0, fnmatch_1.default)(filepath, glob, matchOptions);
+} // }}}

package/lib/utils/get-format.js

@@ -1,17 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFormat = getFormat;
-const fnmatch_1 = __importDefault(require("editorconfig/src/lib/fnmatch"));
-function fnmatch(filepath, glob) {
-    const matchOptions = { matchBase: true, dot: true, noext: true };
-    return (0, fnmatch_1.default)(filepath, glob, matchOptions);
-} // }}}
+const fnmatch_js_1 = require("./fnmatch.js");
 function getFormat(name, formats) {
     for (const format of formats) {
-        if (fnmatch(name, format.glob)) {
+        if ((0, fnmatch_js_1.fnmatch)(name, format.glob)) {
             return format;
         }
     }

package/lib/utils/load-package.d.ts

@@ -0,0 +1,6 @@
+import { type Spinner } from '@zokugun/cli-utils/logger';
+export declare function loadPackage(spec: string, spinner: Spinner, options: {
+    force?: boolean;
+    skip?: boolean;
+    verbose?: boolean;
+}): Promise<string | null>;

package/lib/utils/load-package.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPackage = loadPackage;
+const cli_utils_1 = require("@zokugun/cli-utils");
+const pacote_1 = __importDefault(require("pacote"));
+const tempy_1 = __importDefault(require("tempy"));
+async function loadPackage(spec, spinner, options) {
+    const dir = tempy_1.default.directory();
+    const pkgResult = await pacote_1.default.extract(spec, dir);
+    if (!pkgResult.resolved) {
+        if (options.force || options.skip) {
+            spinner.fail();
+            if (options.verbose) {
+                cli_utils_1.logger.warn(`The artifact '${spec}' couldn't be found, skipping...`);
+            }
+            return null;
+        }
+        else {
+            cli_utils_1.logger.fatal(pkgResult.from);
+        }
+    }
+    return dir;
+}

package/lib/utils/template.js

@@ -46,7 +46,6 @@ const utc_1 = __importDefault(require("dayjs/plugin/utc"));
 const git_url_parse_1 = __importDefault(require("git-url-parse"));
 const lodash_es_1 = require("lodash-es");
 const YAML = __importStar(require("../parsers/yaml.js"));
-const try_json_js_1 = require("./try-json.js");
 dayjs_1.default.extend(utc_1.default);
 const EXPRESSION_REGEX = /#\[\[(.*?)]]/g;
 const PATH_PROPERTY_REGEX = /^(\w+?)(?:\.|$)(.*)$/;
@@ -157,7 +156,7 @@ class TemplateEngine {
                 return (0, xtry_1.ok)(YAML.parse(content));
             }
             else {
-                return (0, xtry_1.ok)((0, try_json_js_1.tryJSON)(content) ?? YAML.parse(content));
+                return (0, xtry_1.ok)(JSON.parse(content) ?? YAML.parse(content));
             }
         }
         catch (parseError) {
@@ -197,7 +196,6 @@ class TemplateEngine {
             if (readResult.fails) {
                 return readResult;
             }
-            // const getValueResult = this.getValueByPath(readResult.value, propertyPath);
             const evalResult = this.evaluateExpression(propertyPath, readResult.value);
             if (evalResult.fails) {
                 return evalResult;