@zokugun/artifact 0.7.0 → 0.9.0

package/lib/steps/read-files.js

@@ -9,63 +9,77 @@ const cli_utils_1 = require("@zokugun/cli-utils");
 const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
 const xtry_1 = require("@zokugun/xtry");
 const istextorbinary_1 = require("istextorbinary");
+const context_js_1 = require("../types/context.js");
 const detect_indent_js_1 = require("../utils/detect-indent.js");
 const has_final_new_line_js_1 = require("../utils/has-final-new-line.js");
 const list_working_files_js_1 = require("../utils/list-working-files.js");
 const read_buffer_js_1 = require("../utils/read-buffer.js");
-async function readFiles({ incomingPath, textFiles, binaryFiles, options }) {
+async function readFiles({ incomingPath, textFiles, binaryFiles, mode, global, options }) {
     const cwd = path_1.default.join(incomingPath, 'configs');
     const files = await (0, list_working_files_js_1.listWorkingFiles)(cwd);
-    for (const file of files) {
-        const filePath = path_1.default.join(cwd, file);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        if ((0, istextorbinary_1.isText)(file) || (0, istextorbinary_1.getEncoding)(await (0, read_buffer_js_1.readBuffer)(filePath, 24)) === 'utf8') {
-            const result = await async_1.default.readFile(filePath, 'utf8');
-            if (result.fails) {
-                return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
-            }
-            const data = result.value;
-            const finalNewLine = (0, has_final_new_line_js_1.hasFinalNewLine)(data);
-            const indent = (0, detect_indent_js_1.detectIndent)(data);
-            if (data.startsWith('#!')) {
-                // the text file might be executable
-                const result = await async_1.default.stat(filePath);
-                if (result.fails) {
-                    return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
-                }
-                const { mode } = result.value;
-                textFiles.push({
-                    name: file,
-                    data,
-                    finalNewLine,
-                    indent,
-                    mode,
-                });
-                if (options.verbose) {
-                    cli_utils_1.logger.debug(`${file} is a shebang file`);
-                }
+    if (mode === context_js_1.Mode.Default) {
+        for (const file of files) {
+            const filePath = path_1.default.join(cwd, file);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            if ((0, istextorbinary_1.isText)(file) || (0, istextorbinary_1.getEncoding)(await (0, read_buffer_js_1.readBuffer)(filePath, 24)) === 'utf8') {
+                await readTextFile(file, filePath, textFiles, options);
             }
             else {
-                textFiles.push({
-                    name: file,
-                    data,
-                    finalNewLine,
-                    indent,
+                binaryFiles.push({
+                    source: file,
+                    target: file,
                 });
                 if (options.verbose) {
-                    cli_utils_1.logger.debug(`${file} is a text file`);
+                    cli_utils_1.logger.debug(`${file} is a binary file`);
                 }
             }
         }
-        else {
-            binaryFiles.push({
-                source: file,
-                target: file,
-            });
-            if (options.verbose) {
-                cli_utils_1.logger.debug(`${file} is a binary file`);
+    }
+    else {
+        for (const file of files) {
+            if (global.overwrittenTextFiles.includes(file)) {
+                const filePath = path_1.default.join(cwd, file);
+                await readTextFile(file, filePath, textFiles, options);
             }
         }
     }
     return xtry_1.OK;
 }
+async function readTextFile(file, filePath, textFiles, options) {
+    const result = await async_1.default.readFile(filePath, 'utf8');
+    if (result.fails) {
+        return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
+    }
+    const data = result.value;
+    const finalNewLine = (0, has_final_new_line_js_1.hasFinalNewLine)(data);
+    const indent = (0, detect_indent_js_1.detectIndent)(data);
+    if (data.startsWith('#!')) {
+        // the text file might be executable
+        const result = await async_1.default.stat(filePath);
+        if (result.fails) {
+            return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
+        }
+        const { mode } = result.value;
+        textFiles.push({
+            name: file,
+            data,
+            finalNewLine,
+            indent,
+            mode,
+        });
+        if (options.verbose) {
+            cli_utils_1.logger.debug(`${file} is a shebang file`);
+        }
+    }
+    else {
+        textFiles.push({
+            name: file,
+            data,
+            finalNewLine,
+            indent,
+        });
+        if (options.verbose) {
+            cli_utils_1.logger.debug(`${file} is a text file`);
+        }
+    }
+} // }}}

package/lib/steps/read-incoming-config.js

@@ -5,7 +5,7 @@ const xtry_1 = require("@zokugun/xtry");
 const index_js_1 = require("../configs/index.js");
 async function readIncomingConfig(context) {
     if (!context.incomingConfig) {
-        const config = await (0, index_js_1.readPackageConfig)(context.incomingPath);
+        const config = await (0, index_js_1.readPackageConfig)(context.incomingPath, context.global.routes);
         if (config.fails) {
             return config;
         }

package/lib/steps/remove-files.d.ts

@@ -1,3 +1,3 @@
 import { type AsyncDResult } from '@zokugun/xtry';
 import { type Context } from '../types/context.js';
-export declare function removeFiles({ removedPatterns, targetPath, options }: Context): AsyncDResult;
+export declare function removeFiles({ removedPatterns, targetPath, mode, options }: Context): AsyncDResult;

package/lib/steps/remove-files.js

@@ -9,9 +9,10 @@ const cli_utils_1 = require("@zokugun/cli-utils");
 const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
 const xtry_1 = require("@zokugun/xtry");
 const micromatch_1 = require("micromatch");
+const context_js_1 = require("../types/context.js");
 const list_working_files_js_1 = require("../utils/list-working-files.js");
-async function removeFiles({ removedPatterns, targetPath, options }) {
-    if (removedPatterns.length === 0) {
+async function removeFiles({ removedPatterns, targetPath, mode, options }) {
+    if (removedPatterns.length === 0 || mode !== context_js_1.Mode.Default) {
         return xtry_1.OK;
     }
     const cwd = path_1.default.join(targetPath);

package/lib/steps/rename-files.d.ts

@@ -1,3 +1,3 @@
 import { type AsyncDResult } from '@zokugun/xtry';
 import { type Context } from '../types/context.js';
-export declare function renameFiles({ renamedPatterns, targetPath }: Context): AsyncDResult;
+export declare function renameFiles({ renamedPatterns, targetPath, mode }: Context): AsyncDResult;

package/lib/steps/rename-files.js

@@ -7,8 +7,9 @@ exports.renameFiles = renameFiles;
 const path_1 = __importDefault(require("path"));
 const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
 const xtry_1 = require("@zokugun/xtry");
-async function renameFiles({ renamedPatterns, targetPath }) {
-    if (renamedPatterns.length === 0) {
+const context_js_1 = require("../types/context.js");
+async function renameFiles({ renamedPatterns, targetPath, mode }) {
+    if (renamedPatterns.length === 0 || mode !== context_js_1.Mode.Default) {
         return xtry_1.OK;
     }
     const cwd = path_1.default.join(targetPath);

package/lib/steps/validate-newer-package.d.ts

@@ -1,3 +1,3 @@
 import { type AsyncDResult } from '@zokugun/xtry';
 import { type Context } from '../types/context.js';
-export declare function validateNewerPackage({ incomingPackage, config, options }: Context): AsyncDResult<boolean | void>;
+export declare function validateNewerPackage(context: Context): AsyncDResult<boolean | void>;

package/lib/steps/validate-newer-package.js

@@ -3,13 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateNewerPackage = validateNewerPackage;
 const xtry_1 = require("@zokugun/xtry");
 const semver_1 = require("semver");
-async function validateNewerPackage({ incomingPackage, config, options }) {
+const context_js_1 = require("../types/context.js");
+async function validateNewerPackage(context) {
+    const { incomingPackage, config, global, options } = context;
     if (options.force) {
         return xtry_1.OK;
     }
     const artifact = config.artifacts[incomingPackage.name];
     if (artifact) {
-        return (0, xtry_1.ok)(!(0, semver_1.gt)(incomingPackage.version, artifact.version));
+        const newer = (0, semver_1.gt)(incomingPackage.version, artifact.version);
+        if (newer) {
+            return xtry_1.OK_FALSE;
+        }
+        else if (global.overwrittenTextFiles.length > 0) {
+            context.mode = context_js_1.Mode.Overwritten;
+        }
+        else {
+            return xtry_1.OK_TRUE;
+        }
     }
     return xtry_1.OK;
 }

package/lib/types/config.d.ts

@@ -1,5 +1,6 @@
 import { type Primitive } from '@zokugun/is-it-type';
 import { type Indent } from './format.js';
+import { type JourneyPlan, type Route } from './travel.js';
 export type Request = {
     name: string;
     variant?: string;
@@ -11,7 +12,9 @@ export type PackageManifest = {
 export type PackageConfig = {
     extends?: string;
     install: InstallFileConfig[];
+    journeys: Record<string, JourneyPlan>;
     orphan: boolean;
+    routes: Record<string, Route<any>>;
     uninstall: UninstallFileConfig[];
     update: false | UpdateFileConfig[];
     variables: Record<string, Primitive>;
@@ -26,8 +29,16 @@ export type ArtifactResult = Artifact & {
     name: string;
 };
 export type InstallConfig = {
+    file: {
+        name: string;
+        finalNewLine: boolean;
+        indent?: Indent;
+        type: string;
+    };
     artifacts: Record<string, Artifact>;
     install: Record<string, InstallFileConfig>;
+    journeys: Record<string, JourneyPlan>;
+    routes: Record<string, Route<any>>;
     update: false | Record<string, UpdateFileConfig>;
     variables: Record<string, Primitive>;
 };
@@ -44,15 +55,8 @@ export type UpsertFileConfig = AlwaysFileConfig & {
     filter?: string[];
     ifMissing: 'merge' | 'skip';
     rename?: string;
-    route?: Record<string, any>;
 };
 export type FileTransform = {
     description?: string;
     jq: string;
 };
-export type InstallConfigStats = {
-    name: string;
-    type: string;
-    finalNewLine: boolean;
-    indent?: Indent;
-};

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;