@zokugun/artifact 0.3.1 → 0.4.1

package/lib/steps/configure-install-file-actions.js

@@ -0,0 +1,151 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureInstallFileActions = configureInstallFileActions;
+const lodash_1 = require("lodash");
+const micromatch_1 = require("micromatch");
+const compositors_1 = require("../compositors");
+const routes_1 = require("../routes");
+function buildRoute(route) {
+    if (Array.isArray(route) && route.length > 0) {
+        let result = buildRoute(route[0]);
+        for (let i = 1; i < route.length; i++) {
+            if (route[i] === 'mapSort') {
+                result = (0, compositors_1.mapSort)(result);
+            }
+            else {
+                throw new Error('Can\'t build route');
+            }
+        }
+        return result;
+    }
+    else if ((0, lodash_1.isPlainObject)(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)) {
+                map[name] = buildRoute(route);
+            }
+            return (0, compositors_1.compose)(map);
+        }
+        else if (rtFork) {
+            const map = [];
+            if (rtFork.array) {
+                map.push([Array.isArray, buildRoute(rtFork.array)]);
+            }
+            if (rtFork.object) {
+                map.push([lodash_1.isPlainObject, buildRoute(rtFork.object)]);
+            }
+            if (rtFork.default) {
+                map.push(buildRoute(rtFork.default));
+            }
+            return (0, compositors_1.fork)(...map);
+        }
+        else if (rtMapSort) {
+            return (0, compositors_1.mapSort)(buildRoute(rtMapSort));
+        }
+    }
+    else if (route === 'command') {
+        return routes_1.command;
+    }
+    else if (route === 'linesConcat') {
+        return routes_1.linesConcat;
+    }
+    else if (route === 'listConcat') {
+        return routes_1.listConcat;
+    }
+    else if (route === 'mapConcat') {
+        return routes_1.mapConcat;
+    }
+    else if (route === 'overwrite') {
+        return routes_1.overwrite;
+    }
+    else if (route === 'primitive') {
+        return routes_1.primitive;
+    }
+    throw new Error('Can\'t build route');
+} // }}}
+function buildTravel(route) {
+    if (route.json) {
+        return (0, compositors_1.json)(buildRoute(route.json));
+    }
+    else if (route.rc) {
+        return (0, compositors_1.rc)(buildRoute(route.json));
+    }
+    else if (route.yaml) {
+        return (0, compositors_1.yaml)(buildRoute(route.json));
+    }
+    else {
+        throw new Error('Can\'t build route');
+    }
+} // }}}
+function configureInstallFileActions(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { install } = context.incomingConfig;
+        if (!install) {
+            return;
+        }
+        const overwritings = [];
+        const filters = {};
+        const routes = {};
+        for (const [file, fileUpdate] of Object.entries(install)) {
+            const { overwrite, remove, filter, route } = fileUpdate;
+            if (remove) {
+                context.removedPatterns.push(file);
+                continue;
+            }
+            if (overwrite) {
+                overwritings.push(file);
+            }
+            if (filter) {
+                filters[file] = filter;
+            }
+            if (route) {
+                const { alias } = route;
+                if (alias) {
+                    routes[file] = {
+                        alias,
+                        travel: buildTravel(route),
+                    };
+                }
+                else {
+                    routes[file] = {
+                        travel: buildTravel(route),
+                    };
+                }
+            }
+        }
+        if (overwritings.length > 0) {
+            context.onExisting = (file) => (0, micromatch_1.isMatch)(file, overwritings) ? 'overwrite' : 'merge';
+        }
+        if (!(0, lodash_1.isEmpty)(filters)) {
+            context.filters = (file) => {
+                for (const [pattern, value] of Object.entries(filters)) {
+                    if ((0, micromatch_1.isMatch)(file, pattern)) {
+                        return value;
+                    }
+                }
+                return undefined;
+            };
+        }
+        if (!(0, lodash_1.isEmpty)(routes)) {
+            context.routes = (file) => {
+                for (const [pattern, route] of Object.entries(routes)) {
+                    if ((0, micromatch_1.isMatch)(file, pattern)) {
+                        return route;
+                    }
+                }
+                return undefined;
+            };
+        }
+    });
+}

package/lib/steps/{validate-updatability.js → configure-update-file-actions.js}

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateUpdatability = void 0;
+exports.configureUpdateFileActions = configureUpdateFileActions;
 const lodash_1 = require("lodash");
 const micromatch_1 = require("micromatch");
 const compositors_1 = require("../compositors");
@@ -88,18 +88,18 @@ function buildTravel(route) {
         throw new Error('Can\'t build route');
     }
 } // }}}
-function validateUpdatability(context) {
+function configureUpdateFileActions(context) {
     return __awaiter(this, void 0, void 0, function* () {
         const { update } = context.incomingConfig;
         if (typeof update === 'boolean') {
             if (!update) {
-                context.onMissing = () => true;
-                context.onUpdate = () => true;
+                context.onExisting = () => 'skip';
+                context.onMissing = () => 'skip';
             }
         }
         else if ((0, lodash_1.isPlainObject)(update)) {
+            const existings = [];
             const missings = [];
-            const updates = [];
             const filters = {};
             const routes = {};
             for (const [file, fileUpdate] of Object.entries(update)) {
@@ -108,7 +108,7 @@ function validateUpdatability(context) {
                     missings.push(file);
                 }
                 if (update === false) {
-                    updates.push(file);
+                    existings.push(file);
                 }
                 if (filter) {
                     filters[file] = filter;
@@ -129,10 +129,10 @@ function validateUpdatability(context) {
                 }
             }
             if (missings.length > 0) {
-                context.onMissing = (file) => (0, micromatch_1.isMatch)(file, missings);
+                context.onMissing = (file) => (0, micromatch_1.isMatch)(file, missings) ? 'skip' : 'continue';
             }
-            if (updates.length > 0) {
-                context.onUpdate = (file) => (0, micromatch_1.isMatch)(file, updates);
+            if (existings.length > 0) {
+                context.onExisting = (file) => (0, micromatch_1.isMatch)(file, existings) ? 'skip' : 'merge';
             }
             if (!(0, lodash_1.isEmpty)(filters)) {
                 context.filters = (file) => {
@@ -157,4 +157,3 @@ function validateUpdatability(context) {
         }
     });
 }
-exports.validateUpdatability = validateUpdatability;

package/lib/steps/copy-binary-files.js

@@ -12,26 +12,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyBinaryFiles = void 0;
+exports.copyBinaryFiles = copyBinaryFiles;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-function copyBinaryFiles({ binaryFiles, incomingPath, targetPath, onMissing, onUpdate, options }) {
-    return __awaiter(this, void 0, void 0, function* () {
+function copyBinaryFiles(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ binaryFiles, incomingPath, targetPath, onExisting, onMissing, options }) {
         const cwd = path_1.default.join(incomingPath, 'configs');
         for (const file of binaryFiles) {
-            try {
-                yield fs_extra_1.default.access(path_1.default.join(targetPath, file.source));
-                if (onUpdate(file.source)) {
-                    continue;
+            const source = path_1.default.join(cwd, file.source);
+            const target = path_1.default.join(targetPath, file.target);
+            const exists = yield fs_extra_1.default.pathExists(target);
+            if (exists) {
+                switch (onExisting(file.source)) {
+                    case 'merge':
+                        break;
+                    case 'overwrite':
+                        break;
+                    case 'skip':
+                        continue;
                 }
             }
-            catch (_a) {
-                if (onMissing(file.source)) {
-                    continue;
+            else {
+                switch (onMissing(file.source)) {
+                    case 'continue':
+                        break;
+                    case 'skip':
+                        continue;
                 }
             }
-            const source = path_1.default.join(cwd, file.source);
-            const target = path_1.default.join(targetPath, file.target);
+            yield fs_extra_1.default.ensureFile(target);
             yield fs_extra_1.default.copyFile(source, target);
             if (options.verbose) {
                 console.log(`${file.target} has been written as a binary file`);
@@ -39,4 +48,3 @@ function copyBinaryFiles({ binaryFiles, incomingPath, targetPath, onMissing, onU
         }
     });
 }
-exports.copyBinaryFiles = copyBinaryFiles;

package/lib/steps/execute-first-block.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFirstBlock = executeFirstBlock;
+const node_path_1 = __importDefault(require("node:path"));
+const lodash_1 = require("lodash");
+const configs_1 = require("../configs");
+function executeFirstBlock(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const { name, version } = context.incomingPackage;
+        const root = String((_b = (_a = context.incomingConfig.variants) === null || _a === void 0 ? void 0 : _a.root) !== null && _b !== void 0 ? _b : '');
+        if (context.incomingVariant) {
+            let variant;
+            let alias;
+            if ((0, lodash_1.isNil)(context.incomingConfig.variants[context.incomingVariant])) {
+                variant = context.incomingVariant;
+                alias = false;
+            }
+            else {
+                variant = String(context.incomingConfig.variants[context.incomingVariant]);
+                alias = true;
+            }
+            const variantPath = node_path_1.default.join(context.packagePath, 'variants', variant);
+            const variantConfig = yield (0, configs_1.readPackageConfig)(variantPath);
+            if (variantConfig.orphan) {
+                pushToResult(name, version, variant, alias, context);
+                context.incomingConfig = variantConfig;
+                yield context.commonFlow(name, version, variant, undefined, variantPath, context);
+            }
+            else if (variantConfig.extends) {
+                context.blocks.unshift({
+                    name,
+                    version,
+                    variant,
+                    incomingPath: node_path_1.default.join(context.packagePath, 'variants', variant),
+                });
+                pushToResult(name, version, variant, alias, context);
+                const extend = String((_c = context.incomingConfig.variants[variantConfig.extends]) !== null && _c !== void 0 ? _c : variantConfig.extends);
+                context.incomingVariant = extend;
+                return executeFirstBlock(context);
+            }
+            else {
+                if (root.length === 0) {
+                    throw new Error('No root variant has been defined');
+                }
+                if (root === variant) {
+                    pushToResult(name, version, variant, alias, context);
+                    context.incomingConfig = variantConfig;
+                    yield context.commonFlow(name, version, variant, undefined, variantPath, context);
+                }
+                else {
+                    const variant = String((_d = context.incomingConfig.variants[context.request.variant]) !== null && _d !== void 0 ? _d : context.request.variant);
+                    context.blocks.unshift({
+                        name,
+                        version,
+                        variant,
+                        incomingPath: node_path_1.default.join(context.packagePath, 'variants', variant),
+                    });
+                    pushToResult(name, version, variant, alias, context);
+                    const incomingPath = node_path_1.default.join(context.packagePath, 'variants', root);
+                    context.incomingConfig = undefined;
+                    yield context.commonFlow(name, version, root, undefined, incomingPath, context);
+                }
+            }
+        }
+        else if (root.length > 0) {
+            context.result = {
+                name,
+                version,
+                provides: [root],
+            };
+            const incomingPath = node_path_1.default.join(context.packagePath, 'variants', root);
+            context.incomingConfig = undefined;
+            yield context.commonFlow(name, version, root, undefined, incomingPath, context);
+        }
+        else {
+            context.result = { name, version };
+            yield context.commonFlow(name, version, undefined, undefined, context.incomingPath, context);
+        }
+    });
+}
+function pushToResult(name, version, variant, alias, context) {
+    var _a, _b;
+    var _c;
+    (_a = context.result) !== null && _a !== void 0 ? _a : (context.result = {
+        name,
+        version,
+        requires: [context.request.variant],
+    });
+    const provider = context.incomingVariant !== context.request.variant;
+    if (provider || alias) {
+        (_b = (_c = context.result).provides) !== null && _b !== void 0 ? _b : (_c.provides = []);
+        if (provider) {
+            context.result.provides.unshift(context.incomingVariant);
+        }
+        if (alias) {
+            context.result.provides.unshift(variant);
+        }
+    }
+}

package/lib/steps/execute-next-block.js

@@ -0,0 +1,22 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeNextBlock = executeNextBlock;
+const lodash_1 = require("lodash");
+function executeNextBlock(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const block = context.blocks.shift();
+        if (!(0, lodash_1.isNil)(block)) {
+            const { name, version, variant, branch, incomingPath } = block;
+            yield context.commonFlow(name, version, variant, branch, incomingPath, context);
+        }
+    });
+}

package/lib/steps/index.js

@@ -9,53 +9,70 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeSteps = exports.steps = void 0;
+exports.steps = void 0;
+exports.composeSteps = composeSteps;
 const apply_formatting_1 = require("./apply-formatting");
+const configure_branches_1 = require("./configure-branches");
+const configure_install_file_actions_1 = require("./configure-install-file-actions");
+const configure_update_file_actions_1 = require("./configure-update-file-actions");
 const copy_binary_files_1 = require("./copy-binary-files");
+const execute_first_block_1 = require("./execute-first-block");
+const execute_next_block_1 = require("./execute-next-block");
 const insert_final_new_line_1 = require("./insert-final-new-line");
 const merge_text_files_1 = require("./merge-text-files");
 const read_editor_config_1 = require("./read-editor-config");
 const read_files_1 = require("./read-files");
 const read_incoming_config_1 = require("./read-incoming-config");
 const read_incoming_package_1 = require("./read-incoming-package");
+const remove_files_1 = require("./remove-files");
 const replace_templates_1 = require("./replace-templates");
 const validate_newer_package_1 = require("./validate-newer-package");
 const validate_not_present_package_1 = require("./validate-not-present-package");
-const validate_updatability_1 = require("./validate-updatability");
 const write_text_files_1 = require("./write-text-files");
 exports.steps = {
     applyFormatting: apply_formatting_1.applyFormatting,
+    configureBranches: configure_branches_1.configureBranches,
+    configureInstallFileActions: configure_install_file_actions_1.configureInstallFileActions,
+    configureUpdateFileActions: configure_update_file_actions_1.configureUpdateFileActions,
     copyBinaryFiles: copy_binary_files_1.copyBinaryFiles,
+    executeFirstBlock: execute_first_block_1.executeFirstBlock,
+    executeNextBlock: execute_next_block_1.executeNextBlock,
     insertFinalNewLine: insert_final_new_line_1.insertFinalNewLine,
     mergeTextFiles: merge_text_files_1.mergeTextFiles,
     readEditorConfig: read_editor_config_1.readEditorConfig,
     readFiles: read_files_1.readFiles,
     readIncomingConfig: read_incoming_config_1.readIncomingConfig,
     readIncomingPackage: read_incoming_package_1.readIncomingPackage,
+    removeFiles: remove_files_1.removeFiles,
     replaceTemplates: replace_templates_1.replaceTemplates,
     validateNewerPackage: validate_newer_package_1.validateNewerPackage,
     validateNotPresentPackage: validate_not_present_package_1.validateNotPresentPackage,
-    validateUpdatability: validate_updatability_1.validateUpdatability,
     writeTextFiles: write_text_files_1.writeTextFiles,
 };
-function composeSteps(...steps) {
-    return (targetPath, incomingPath, config, options) => __awaiter(this, void 0, void 0, function* () {
+function composeSteps(validations, processes) {
+    const mainFlow = (targetPath, incomingPath, request, config, options) => __awaiter(this, void 0, void 0, function* () {
         const context = {
+            packagePath: incomingPath,
+            request,
             targetPath,
             incomingPath,
-            onMissing: () => false,
-            onUpdate: () => false,
+            incomingVariant: request.variant,
+            onExisting: () => 'merge',
+            onMissing: () => 'continue',
             filters: () => undefined,
             routes: () => undefined,
             binaryFiles: [],
             textFiles: [],
             mergedTextFiles: [],
+            removedPatterns: [],
             formats: [],
             config,
             options,
+            commonFlow,
+            blocks: [],
         };
         let skipped = false;
-        for (const step of steps) {
+        for (const step of validations) {
             if (yield step(context)) {
                 skipped = true;
                 break;
@@ -63,5 +80,26 @@ function composeSteps(...steps) {
         }
         return skipped ? undefined : context;
     });
+    const commonFlow = (name, version, variant, branch, incomingPath, mainContext) => __awaiter(this, void 0, void 0, function* () {
+        if (mainContext.options.verbose) {
+            let message = `\n---> ${name} version=${version}`;
+            if (variant) {
+                message += ` variant=${variant}`;
+            }
+            if (branch) {
+                message += ` branch=${branch}`;
+            }
+            console.log(message);
+        }
+        const context = Object.assign(Object.assign({}, mainContext), { incomingPath, incomingName: name, incomingVersion: version, incomingVariant: variant, incomingBranch: branch, incomingConfig: undefined, onExisting: () => 'merge', onMissing: () => 'continue', filters: () => undefined, routes: () => undefined, binaryFiles: [], textFiles: [], mergedTextFiles: [], formats: [] });
+        let skipped = false;
+        for (const step of processes) {
+            if (yield step(context)) {
+                skipped = true;
+                break;
+            }
+        }
+        return skipped ? undefined : context;
+    });
+    return { mainFlow, commonFlow };
 }
-exports.composeSteps = composeSteps;

package/lib/steps/insert-final-new-line.js

@@ -9,9 +9,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.insertFinalNewLine = void 0;
-function insertFinalNewLine({ mergedTextFiles }) {
-    return __awaiter(this, void 0, void 0, function* () {
+exports.insertFinalNewLine = insertFinalNewLine;
+function insertFinalNewLine(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ mergedTextFiles }) {
         for (const file of mergedTextFiles) {
             if (file.finalNewLine) {
                 const withFinalNewLine = file.data.endsWith('\n');
@@ -22,4 +22,3 @@ function insertFinalNewLine({ mergedTextFiles }) {
         }
     });
 }
-exports.insertFinalNewLine = insertFinalNewLine;

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

@@ -12,67 +12,96 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeTextFiles = void 0;
+exports.mergeTextFiles = mergeTextFiles;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const journeys_1 = require("../journeys");
-function mergeTextFiles({ targetPath, textFiles, mergedTextFiles, onMissing, onUpdate, filters, routes, options }) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
+function mergeTextFiles(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ targetPath, textFiles, mergedTextFiles, onExisting, onMissing, filters, routes, options }) {
+        var _b;
         for (const file of textFiles) {
             if (options.verbose) {
                 console.log(`${file.name} is going to be merged`);
             }
-            const journey = (_a = routes(file.name)) !== null && _a !== void 0 ? _a : (0, journeys_1.getJourney)(file.name);
+            const journey = (_b = routes(file.name)) !== null && _b !== void 0 ? _b : (0, journeys_1.getJourney)(file.name);
             if (!journey) {
                 if (options.verbose) {
                     console.log(`${file.name}, no merger has been found`);
                 }
-                try {
-                    yield fs_extra_1.default.access(path_1.default.join(targetPath, file.name));
-                    if (onUpdate(file.name)) {
-                        continue;
+                const filePath = path_1.default.join(targetPath, file.name);
+                const exists = yield fs_extra_1.default.pathExists(filePath);
+                if (exists) {
+                    switch (onExisting(file.name)) {
+                        case 'merge':
+                            break;
+                        case 'overwrite':
+                            break;
+                        case 'skip':
+                            continue;
                     }
                 }
-                catch (_b) {
-                    if (onMissing(file.name)) {
-                        continue;
+                else {
+                    switch (onMissing(file.name)) {
+                        case 'continue':
+                            break;
+                        case 'skip':
+                            continue;
                     }
                 }
                 mergedTextFiles.push(file);
+                if (options.verbose) {
+                    console.log(`${file.name} has been copied`);
+                }
                 continue;
             }
             if (options.verbose) {
                 console.log(`${file.name}, a merger has been found`);
             }
-            const name = journey.alias ? path_1.default.join(path_1.default.dirname(file.name), journey.alias) : file.name;
-            let currentData;
-            try {
-                currentData = yield fs_extra_1.default.readFile(path_1.default.join(targetPath, name), 'utf-8');
-                if (onUpdate(name)) {
-                    continue;
+            const fileName = journey.alias ? path_1.default.join(path_1.default.dirname(file.name), journey.alias) : file.name;
+            const filePath = path_1.default.join(targetPath, fileName);
+            const exists = yield fs_extra_1.default.pathExists(filePath);
+            if (exists) {
+                switch (onExisting(file.name)) {
+                    case 'merge': {
+                        const currentData = yield fs_extra_1.default.readFile(filePath, 'utf-8');
+                        const data = journey.travel({
+                            current: currentData,
+                            incoming: file.data,
+                            filters: filters(file.name),
+                        });
+                        mergedTextFiles.push({
+                            name: fileName,
+                            data,
+                            finalNewLine: file.finalNewLine,
+                            mode: file.mode,
+                        });
+                        if (options.verbose) {
+                            console.log(`${file.name} has been merged`);
+                        }
+                        break;
+                    }
+                    case 'overwrite':
+                        mergedTextFiles.push(file);
+                        if (options.verbose) {
+                            console.log(`${file.name} has been overwritten`);
+                        }
+                        continue;
+                    case 'skip':
+                        continue;
                 }
             }
-            catch (_c) {
-                if (onMissing(name)) {
-                    continue;
+            else {
+                switch (onMissing(file.name)) {
+                    case 'continue':
+                        mergedTextFiles.push(Object.assign(Object.assign({}, file), { name: fileName }));
+                        if (options.verbose) {
+                            console.log(`${file.name} has been copied`);
+                        }
+                        continue;
+                    case 'skip':
+                        continue;
                 }
             }
-            const data = journey.travel({
-                current: currentData,
-                incoming: file.data,
-                filters: filters(file.name),
-            });
-            mergedTextFiles.push({
-                name,
-                data,
-                finalNewLine: file.finalNewLine,
-                mode: file.mode,
-            });
-            if (options.verbose) {
-                console.log(`${file.name} has been merged`);
-            }
         }
     });
 }
-exports.mergeTextFiles = mergeTextFiles;