@zokugun/artifact 0.5.2 → 0.6.1

package/lib/steps/unmerge-text-files.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unmergeTextFiles = unmergeTextFiles;
+const path_1 = __importDefault(require("path"));
+const cli_utils_1 = require("@zokugun/cli-utils");
+const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
+const is_it_type_1 = require("@zokugun/is-it-type");
+const xtry_1 = require("@zokugun/xtry");
+const compose_js_1 = require("../compositors/compose.js");
+const fork_js_1 = require("../compositors/fork.js");
+const json_js_1 = require("../compositors/json.js");
+const yaml_js_1 = require("../compositors/yaml.js");
+const index_js_1 = require("../routes/index.js");
+const build_travel_plan_js_1 = require("../utils/build-travel-plan.js");
+const mainRoute = (0, compose_js_1.compose)({
+    $$default: (0, fork_js_1.fork)([is_it_type_1.isArray, async ({ current }) => current], [is_it_type_1.isRecord, index_js_1.mapDelete], async ({ current }) => current),
+});
+const jsonRoute = (0, json_js_1.json)(mainRoute);
+const yamlRoute = (0, yaml_js_1.yaml)(mainRoute);
+const travelPlan = (0, build_travel_plan_js_1.buildTravelPlan)([/\.json$/, jsonRoute], [/\.ya?ml$/, yamlRoute]);
+async function unmergeTextFiles({ targetPath, textFiles, mergedTextFiles, options }) {
+    for (const file of textFiles) {
+        if (options.verbose) {
+            cli_utils_1.logger.debug(`${file.name} is going to be unmerged`);
+        }
+        const filePath = path_1.default.join(targetPath, file.name);
+        if (!await async_1.default.isExisting(filePath)) {
+            continue;
+        }
+        const current = await async_1.default.readFile(filePath, 'utf8');
+        if (current.fails) {
+            return (0, xtry_1.err)((0, xtry_1.stringifyError)(current.error));
+        }
+        const travel = travelPlan(file.name);
+        if (travel) {
+            if (options.verbose) {
+                cli_utils_1.logger.debug(`${file.name}, an unmerger has been found`);
+            }
+            const data = await travel({
+                current: current.value,
+                incoming: file.data,
+            });
+            mergedTextFiles.push({
+                name: file.name,
+                data,
+                finalNewLine: file.finalNewLine,
+                indent: file.indent,
+                mode: file.mode,
+            });
+            if (options.verbose) {
+                cli_utils_1.logger.debug(`${file.name} has been unmerged`);
+            }
+        }
+        else {
+            if (options.verbose) {
+                cli_utils_1.logger.debug(`${file.name}, no unmerger has been found`);
+            }
+        }
+    }
+    return xtry_1.OK;
+}

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

@@ -0,0 +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>;

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

@@ -1,13 +1,15 @@
 "use strict";
 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 }) {
     if (options.force) {
-        return;
+        return xtry_1.OK;
     }
     const artifact = config.artifacts[incomingPackage.name];
     if (artifact) {
-        return !(0, semver_1.gt)(incomingPackage.version, artifact.version);
+        return (0, xtry_1.ok)(!(0, semver_1.gt)(incomingPackage.version, artifact.version));
     }
+    return xtry_1.OK;
 }

package/lib/steps/validate-not-present-package.d.ts

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

package/lib/steps/validate-not-present-package.js

@@ -1,21 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateNotPresentPackage = validateNotPresentPackage;
+const cli_utils_1 = require("@zokugun/cli-utils");
+const xtry_1 = require("@zokugun/xtry");
 async function validateNotPresentPackage({ incomingPackage, config, options }) {
     if (options.force) {
-        return;
+        return xtry_1.OK;
     }
     const { name } = incomingPackage;
     const artifact = config.artifacts[name];
     if (artifact) {
         if (options.skip) {
             if (options.verbose) {
-                console.log('The incoming artifact is already present, skipping...');
+                cli_utils_1.logger.debug('The incoming artifact is already present, skipping...');
             }
-            return true;
+            return xtry_1.OK_TRUE;
         }
         else {
-            throw new Error('The incoming artifact has already been added.');
+            return (0, xtry_1.err)('The incoming artifact has already been added.');
         }
     }
+    return xtry_1.OK;
 }

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePresentPackage = validatePresentPackage;
+const cli_utils_1 = require("@zokugun/cli-utils");
+const xtry_1 = require("@zokugun/xtry");
+async function validatePresentPackage({ incomingPackage, config, options }) {
+    if (options.force) {
+        return xtry_1.OK;
+    }
+    const { name } = incomingPackage;
+    const artifact = config.artifacts[name];
+    if (!artifact) {
+        if (options.skip) {
+            if (options.verbose) {
+                cli_utils_1.logger.debug('The outgoing artifact is already absent, skipping...');
+            }
+            return xtry_1.OK_TRUE;
+        }
+        else {
+            return (0, xtry_1.err)('The outgoing artifact has already been removed.');
+        }
+    }
+    return xtry_1.OK;
+}

package/lib/steps/write-text-files.d.ts

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

package/lib/steps/write-text-files.js

@@ -5,25 +5,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeTextFiles = writeTextFiles;
 const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-async function writeTextFiles({ mergedTextFiles, targetPath, options }) {
+const cli_utils_1 = require("@zokugun/cli-utils");
+const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
+const xtry_1 = require("@zokugun/xtry");
+async function writeTextFiles({ mergedTextFiles, options, targetPath, transformedFiles }) {
     if (options.dryRun) {
         if (options.verbose) {
             for (const file of mergedTextFiles) {
-                console.log(`${file.name} has been written as a text file`);
+                cli_utils_1.logger.debug(`${file.name} has been written as a text file`);
             }
         }
     }
     else {
-        for (const file of mergedTextFiles) {
+        for (const file of [...mergedTextFiles, ...transformedFiles]) {
             const filePath = path_1.default.join(targetPath, file.name);
-            await fs_extra_1.default.outputFile(filePath, file.data, 'utf-8');
+            const result = await async_1.default.outputFile(filePath, file.data, 'utf8');
+            if (result.fails) {
+                return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
+            }
             if (file.mode) {
-                await fs_extra_1.default.chmod(filePath, file.mode);
+                const result = await async_1.default.chmod(filePath, file.mode);
+                if (result.fails) {
+                    return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
+                }
             }
             if (options.verbose) {
-                console.log(`${file.name} has been written as a text file`);
+                cli_utils_1.logger.debug(`${file.name} has been written as a text file`);
             }
         }
     }
+    return xtry_1.OK;
 }

package/lib/types/binary-file.d.ts

@@ -0,0 +1,4 @@
+export type BinaryFile = {
+    source: string;
+    target: string;
+};

package/lib/types/command.d.ts

@@ -0,0 +1,5 @@
+export type Command = {
+    args: string[];
+    env: string[];
+    separator?: string;
+};

package/lib/types/config.d.ts

@@ -0,0 +1,59 @@
+import { type Indent } from './format.js';
+export type Request = {
+    name: string;
+    variant?: string;
+};
+export type PackageManifest = {
+    name: string;
+    version: string;
+};
+export type PackageConfig = {
+    constants: Record<string, string>;
+    extends?: string;
+    install: InstallFileConfig[];
+    orphan: boolean;
+    uninstall: UninstallFileConfig[];
+    update: false | UpdateFileConfig[];
+    variables: Record<string, string>;
+    variants: Record<string, string>;
+};
+export type Artifact = {
+    version: string;
+    provides?: string[];
+    requires?: string[];
+};
+export type ArtifactResult = Artifact & {
+    name: string;
+};
+export type InstallConfig = {
+    artifacts: Record<string, Artifact>;
+    constants: Record<string, string>;
+    install: Record<string, InstallFileConfig>;
+    update: false | Record<string, UpdateFileConfig>;
+    variables: Record<string, string>;
+};
+export type FileConfig<E> = {
+    ifExists: E;
+    pattern: string;
+    transforms: FileTransform[];
+};
+export type AlwaysFileConfig = FileConfig<'force-merge' | 'merge' | 'overwrite' | 'remove' | 'skip'>;
+export type InstallFileConfig = UpsertFileConfig;
+export type UninstallFileConfig = FileConfig<'remove' | 'skip' | 'unmerge'>;
+export type UpdateFileConfig = UpsertFileConfig;
+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

@@ -0,0 +1,62 @@
+import { type AsyncDResult } from '@zokugun/xtry';
+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';
+export type ExistingAction = 'merge' | 'overwrite' | 'skip';
+export type MissingAction = 'continue' | 'skip';
+export type RenameAction = {
+    from: string;
+    to: string;
+};
+export type Context = {
+    binaryFiles: BinaryFile[];
+    blocks: Block[];
+    commonFlow: CommonFlow;
+    config: InstallConfig;
+    filters: (file: string) => string[] | undefined;
+    formats: Format[];
+    incomingName?: string;
+    incomingVersion?: string;
+    incomingVariant?: string;
+    incomingBranch?: string;
+    incomingConfig?: PackageConfig;
+    incomingPackage?: PackageManifest;
+    incomingPath: string;
+    mergedTextFiles: TextFile[];
+    onExisting: (file: string) => ExistingAction;
+    onMissing: (file: string) => MissingAction;
+    options: Options;
+    packagePath: string;
+    removedPatterns: string[];
+    renamedPatterns: RenameAction[];
+    request: Request;
+    result?: ArtifactResult;
+    routes: (file: string) => Journey | undefined;
+    targetPath: string;
+    textFiles: TextFile[];
+    transformedFiles: TextFile[];
+    transforms: (file: string) => FileTransform[] | undefined;
+};
+export type MainFlow = (targetPath: string, incomingPath: string, request: Request, config: InstallConfig, 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;
+    skip: boolean;
+    verbose: boolean;
+    dryRun: boolean;
+};
+export type Block = {
+    name: string;
+    version: string;
+    variant?: string;
+    branch?: string;
+    incomingPath: string;
+};
+export type TextFile = {
+    data: string;
+    finalNewLine: boolean;
+    indent?: Indent;
+    mode?: number;
+    name: string;
+};

package/lib/types/context.js

@@ -1,2 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// export type OutputTextFile = {
+// 	data: string;
+// 	name: string;
+// };

package/lib/types/format.d.ts

@@ -0,0 +1,14 @@
+export declare enum IndentStyle {
+    SPACE = "space",
+    TAB = "tab"
+}
+export type Format = {
+    glob: string;
+    indentStyle: IndentStyle;
+    indentSize: number;
+    insertFinalNewline: boolean;
+};
+export type Indent = {
+    style: IndentStyle;
+    size: number;
+};

package/lib/types/step.d.ts

@@ -0,0 +1,3 @@
+import { type AsyncDResult } from '@zokugun/xtry';
+import { type Context } from './context.js';
+export type Step = (context: Context) => AsyncDResult<boolean | void>;

package/lib/types/travel.d.ts

@@ -0,0 +1,14 @@
+import { type FileTransform } from './config.js';
+export type Args<T> = {
+    current: T | undefined;
+    incoming: T | undefined;
+    filters?: string[];
+    ignores?: string[];
+    transforms?: FileTransform[];
+};
+export type Route<T> = (args: Args<T>) => Promise<T>;
+export type TravelPlan = (basename: string) => Route<string> | undefined;
+export type Journey = {
+    alias?: string;
+    travel: Route<string>;
+};

package/lib/utils/apply-transforms.d.ts

@@ -0,0 +1,2 @@
+import { type FileTransform } from '../types/config.js';
+export declare function applyTransforms(transforms: FileTransform[] | undefined): (data: Record<string, unknown>) => Promise<Record<string, unknown>>;

package/lib/utils/apply-transforms.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTransforms = applyTransforms;
+const jq = __importStar(require("jq-wasm"));
+function applyTransforms(transforms) {
+    if (!transforms) {
+        return async (data) => data;
+    }
+    return async (data) => {
+        for (const transform of transforms) {
+            data = await jq.json(data, transform.jq);
+        }
+        return data;
+    };
+}

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

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

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

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

package/lib/utils/build-route.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRoute = buildRoute;
+const is_it_type_1 = require("@zokugun/is-it-type");
+const xtry_1 = require("@zokugun/xtry");
+const fork_js_1 = require("../compositors/fork.js");
+const index_js_1 = require("../compositors/index.js");
+const index_js_2 = require("../routes/index.js");
+function buildRoute(route) {
+    if (Array.isArray(route) && route.length > 0) {
+        const buildResult = buildRoute(route[0]);
+        if (buildResult.fails) {
+            return buildResult;
+        }
+        let result = buildResult.value;
+        for (let i = 1; i < route.length; i++) {
+            if (route[i] === 'mapSort') {
+                result = (0, index_js_1.mapSort)(result);
+            }
+            else {
+                return (0, xtry_1.err)('Can\'t build 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) {
+            const map = {};
+            for (const [name, route] of Object.entries(rtCompose)) {
+                const result = buildRoute(route);
+                if (result.fails) {
+                    return result;
+                }
+                map[name] = result.value;
+            }
+            return (0, xtry_1.ok)((0, index_js_1.compose)(map));
+        }
+        else if (rtFork) {
+            const map = [];
+            if (rtFork.array) {
+                const result = buildRoute(rtFork.array);
+                if (result.fails) {
+                    return result;
+                }
+                map.push([Array.isArray, result.value]);
+            }
+            if (rtFork.object) {
+                const result = buildRoute(rtFork.object);
+                if (result.fails) {
+                    return result;
+                }
+                map.push([is_it_type_1.isRecord, result.value]);
+            }
+            if (rtFork.default) {
+                const result = buildRoute(rtFork.default);
+                if (result.fails) {
+                    return result;
+                }
+                map.push(result.value);
+            }
+            return (0, xtry_1.ok)((0, fork_js_1.fork)(...map));
+        }
+        else if (rtMapSort) {
+            const result = buildRoute(rtMapSort);
+            if (result.fails) {
+                return result;
+            }
+            return (0, xtry_1.ok)((0, index_js_1.mapSort)(result.value));
+        }
+    }
+    else if (route === 'command') {
+        return (0, xtry_1.ok)(index_js_2.command);
+    }
+    else if (route === 'linesConcat') {
+        return (0, xtry_1.ok)(index_js_2.linesConcat);
+    }
+    else if (route === 'listConcat') {
+        return (0, xtry_1.ok)(index_js_2.listConcat);
+    }
+    else if (route === 'mapConcat') {
+        return (0, xtry_1.ok)(index_js_2.mapConcat);
+    }
+    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');
+} // }}}

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

@@ -0,0 +1,2 @@
+import { type Route, type TravelPlan } from '../types/travel.js';
+export declare function buildTravelPlan(...mappers: Array<[RegExp | string, Route<string>]>): TravelPlan;

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

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

package/lib/utils/build-travel.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTravel = buildTravel;
+const xtry_1 = require("@zokugun/xtry");
+const index_js_1 = require("../compositors/index.js");
+const build_route_js_1 = require("./build-route.js");
+function buildTravel(route) {
+    if (route.json) {
+        const result = (0, build_route_js_1.buildRoute)(route.json);
+        if (result.fails) {
+            return result;
+        }
+        return (0, xtry_1.ok)((0, index_js_1.json)(result.value));
+    }
+    else if (route.rc) {
+        const result = (0, build_route_js_1.buildRoute)(route.rc);
+        if (result.fails) {
+            return result;
+        }
+        return (0, xtry_1.ok)((0, index_js_1.rc)(result.value));
+    }
+    else if (route.yaml) {
+        const result = (0, build_route_js_1.buildRoute)(route.yaml);
+        if (result.fails) {
+            return result;
+        }
+        return (0, xtry_1.ok)((0, index_js_1.yaml)(result.value));
+    }
+    else {
+        return (0, xtry_1.err)('Can\'t build route');
+    }
+} // }}}

package/lib/utils/command/dedupe-strings.d.ts

@@ -0,0 +1 @@
+export declare function dedupeStrings(items: string[]): string[];

package/lib/utils/command/index.d.ts

@@ -0,0 +1,8 @@
+export type { Command } from '../../types/command.js';
+export { joinCommand } from './join-command.js';
+export { mergeAndChains } from './merge-and-chains.js';
+export { mergeCommandRecords } from './merge-command-records.js';
+export { mergeOrSegments } from './merge-or-segments.js';
+export { mergeSemicolonSegments } from './merge-semicolon-segments.js';
+export { mergeWithSemicolonMix } from './merge-with-semicolon-mix.js';
+export { splitCommand } from './split-command.js';

package/lib/utils/command/index.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitCommand = exports.mergeWithSemicolonMix = exports.mergeSemicolonSegments = exports.mergeOrSegments = exports.mergeCommandRecords = exports.mergeAndChains = exports.joinCommand = void 0;
-var join_command_1 = require("./join-command");
-Object.defineProperty(exports, "joinCommand", { enumerable: true, get: function () { return join_command_1.joinCommand; } });
-var merge_and_chains_1 = require("./merge-and-chains");
-Object.defineProperty(exports, "mergeAndChains", { enumerable: true, get: function () { return merge_and_chains_1.mergeAndChains; } });
-var merge_command_records_1 = require("./merge-command-records");
-Object.defineProperty(exports, "mergeCommandRecords", { enumerable: true, get: function () { return merge_command_records_1.mergeCommandRecords; } });
-var merge_or_segments_1 = require("./merge-or-segments");
-Object.defineProperty(exports, "mergeOrSegments", { enumerable: true, get: function () { return merge_or_segments_1.mergeOrSegments; } });
-var merge_semicolon_segments_1 = require("./merge-semicolon-segments");
-Object.defineProperty(exports, "mergeSemicolonSegments", { enumerable: true, get: function () { return merge_semicolon_segments_1.mergeSemicolonSegments; } });
-var merge_with_semicolon_mix_1 = require("./merge-with-semicolon-mix");
-Object.defineProperty(exports, "mergeWithSemicolonMix", { enumerable: true, get: function () { return merge_with_semicolon_mix_1.mergeWithSemicolonMix; } });
-var split_command_1 = require("./split-command");
-Object.defineProperty(exports, "splitCommand", { enumerable: true, get: function () { return split_command_1.splitCommand; } });
+var join_command_js_1 = require("./join-command.js");
+Object.defineProperty(exports, "joinCommand", { enumerable: true, get: function () { return join_command_js_1.joinCommand; } });
+var merge_and_chains_js_1 = require("./merge-and-chains.js");
+Object.defineProperty(exports, "mergeAndChains", { enumerable: true, get: function () { return merge_and_chains_js_1.mergeAndChains; } });
+var merge_command_records_js_1 = require("./merge-command-records.js");
+Object.defineProperty(exports, "mergeCommandRecords", { enumerable: true, get: function () { return merge_command_records_js_1.mergeCommandRecords; } });
+var merge_or_segments_js_1 = require("./merge-or-segments.js");
+Object.defineProperty(exports, "mergeOrSegments", { enumerable: true, get: function () { return merge_or_segments_js_1.mergeOrSegments; } });
+var merge_semicolon_segments_js_1 = require("./merge-semicolon-segments.js");
+Object.defineProperty(exports, "mergeSemicolonSegments", { enumerable: true, get: function () { return merge_semicolon_segments_js_1.mergeSemicolonSegments; } });
+var merge_with_semicolon_mix_js_1 = require("./merge-with-semicolon-mix.js");
+Object.defineProperty(exports, "mergeWithSemicolonMix", { enumerable: true, get: function () { return merge_with_semicolon_mix_js_1.mergeWithSemicolonMix; } });
+var split_command_js_1 = require("./split-command.js");
+Object.defineProperty(exports, "splitCommand", { enumerable: true, get: function () { return split_command_js_1.splitCommand; } });

package/lib/utils/command/join-command.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from '../../types/command.js';
+export declare function joinCommand(commands: Record<string, Command[]>): string;

package/lib/utils/command/merge-and-chains.d.ts

@@ -0,0 +1 @@
+export declare function mergeAndChains(current: string, incoming: string): string | undefined;