@zokugun/artifact 0.5.2 → 0.6.1

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

@@ -1,134 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configureUpdateFileActions = configureUpdateFileActions;
-const lodash_1 = require("lodash");
+const is_it_type_1 = require("@zokugun/is-it-type");
+const xtry_1 = require("@zokugun/xtry");
 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.rc));
-    }
-    else if (route.yaml) {
-        return (0, compositors_1.yaml)(buildRoute(route.yaml));
-    }
-    else {
-        throw new Error('Can\'t build route');
-    }
-} // }}}
+const build_travel_js_1 = require("../utils/build-travel.js");
 async function configureUpdateFileActions(context) {
     const { update } = context.incomingConfig;
-    if (typeof update === 'boolean') {
-        if (!update) {
-            context.onExisting = () => 'skip';
-            context.onMissing = () => 'skip';
-        }
+    if (update === false) {
+        context.onExisting = () => 'skip';
+        context.onMissing = () => 'skip';
     }
-    else if ((0, lodash_1.isPlainObject)(update)) {
-        const overwriteExistings = [];
-        const skipExistings = [];
+    else {
+        const existingActions = [];
         const skipMissings = [];
         const filters = {};
         const routes = {};
-        for (const [file, fileUpdate] of Object.entries(update)) {
-            const { missing, update, overwrite, filter, route } = fileUpdate;
-            if (missing === false) {
-                skipMissings.push(file);
+        const transformations = {};
+        for (const file of update) {
+            const { filter, ifExists, ifMissing, pattern, rename, route, transforms } = file;
+            if (rename) {
+                context.renamedPatterns.push({
+                    from: pattern,
+                    to: rename,
+                });
+                continue;
             }
-            if (update === false) {
-                skipExistings.push(file);
+            if (ifMissing === 'skip') {
+                skipMissings.push(pattern);
             }
-            else if (overwrite) {
-                overwriteExistings.push(file);
+            if (ifExists === 'force-merge') {
+                existingActions.push({ pattern, action: 'merge' });
+            }
+            else if (ifExists === 'overwrite') {
+                existingActions.push({ pattern, action: 'overwrite' });
+            }
+            else if (ifExists === 'remove') {
+                context.removedPatterns.push(pattern);
+                continue;
+            }
+            else if (ifExists === 'skip') {
+                existingActions.push({ pattern, action: 'skip' });
             }
             if (filter) {
-                filters[file] = filter;
+                filters[pattern] = filter;
             }
             if (route) {
                 const { alias } = route;
+                const travel = (0, build_travel_js_1.buildTravel)(route);
+                if (travel.fails) {
+                    return travel;
+                }
                 if (alias) {
-                    routes[file] = {
+                    routes[pattern] = {
                         alias,
-                        travel: buildTravel(route),
+                        travel: travel.value,
                     };
                 }
                 else {
-                    routes[file] = {
-                        travel: buildTravel(route),
+                    routes[pattern] = {
+                        travel: travel.value,
                     };
                 }
             }
+            if (transforms) {
+                transformations[pattern] = transforms;
+            }
         }
         if (skipMissings.length > 0) {
             context.onMissing = (file) => (0, micromatch_1.isMatch)(file, skipMissings) ? 'skip' : 'continue';
         }
-        if (skipExistings.length > 0 || overwriteExistings.length > 0) {
-            context.onExisting = (file) => (0, micromatch_1.isMatch)(file, skipExistings) ? 'skip' : ((0, micromatch_1.isMatch)(file, overwriteExistings) ? 'overwrite' : 'merge');
+        if (existingActions.length > 0) {
+            context.onExisting = (file) => {
+                for (const { pattern, action } of existingActions) {
+                    if ((0, micromatch_1.isMatch)(file, pattern)) {
+                        return action;
+                    }
+                }
+                return 'merge';
+            };
         }
-        if (!(0, lodash_1.isEmpty)(filters)) {
+        if ((0, is_it_type_1.isNonEmptyRecord)(filters)) {
             context.filters = (file) => {
                 for (const [pattern, value] of Object.entries(filters)) {
                     if ((0, micromatch_1.isMatch)(file, pattern)) {
@@ -138,7 +90,7 @@ async function configureUpdateFileActions(context) {
                 return undefined;
             };
         }
-        if (!(0, lodash_1.isEmpty)(routes)) {
+        if ((0, is_it_type_1.isNonEmptyRecord)(routes)) {
             context.routes = (file) => {
                 for (const [pattern, route] of Object.entries(routes)) {
                     if ((0, micromatch_1.isMatch)(file, pattern)) {
@@ -148,5 +100,16 @@ async function configureUpdateFileActions(context) {
                 return undefined;
             };
         }
+        if ((0, is_it_type_1.isNonEmptyRecord)(transformations)) {
+            context.transforms = (file) => {
+                for (const [pattern, transforms] of Object.entries(transformations)) {
+                    if ((0, micromatch_1.isMatch)(file, pattern)) {
+                        return transforms;
+                    }
+                }
+                return undefined;
+            };
+        }
     }
+    return xtry_1.OK;
 }

package/lib/steps/copy-binary-files.d.ts

@@ -0,0 +1,3 @@
+import { type AsyncDResult } from '@zokugun/xtry';
+import { type Context } from '../types/context.js';
+export declare function copyBinaryFiles({ binaryFiles, incomingPath, targetPath, onExisting, onMissing, options }: Context): AsyncDResult;

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

@@ -5,37 +5,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.copyBinaryFiles = copyBinaryFiles;
 const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
+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 copyBinaryFiles({ binaryFiles, incomingPath, targetPath, onExisting, onMissing, options }) {
     const cwd = path_1.default.join(incomingPath, 'configs');
     for (const file of binaryFiles) {
         const source = path_1.default.join(cwd, file.source);
         const target = path_1.default.join(targetPath, file.target);
-        const exists = await fs_extra_1.default.pathExists(target);
-        if (exists) {
+        if (await async_1.default.isExisting(target)) {
             switch (onExisting(file.source)) {
-                case 'merge':
+                case 'merge': {
                     break;
-                case 'overwrite':
+                }
+                case 'overwrite': {
                     break;
-                case 'skip':
+                }
+                case 'skip': {
                     continue;
+                }
             }
         }
         else {
             switch (onMissing(file.source)) {
-                case 'continue':
+                case 'continue': {
                     break;
-                case 'skip':
+                }
+                case 'skip': {
                     continue;
+                }
             }
         }
         if (!options.dryRun) {
-            await fs_extra_1.default.ensureFile(target);
-            await fs_extra_1.default.copyFile(source, target);
+            const ensureResult = await async_1.default.ensureFile(target);
+            if (ensureResult.fails) {
+                return (0, xtry_1.err)((0, xtry_1.stringifyError)(ensureResult.error));
+            }
+            const copyResult = await async_1.default.copyFile(source, target);
+            if (copyResult.fails) {
+                return (0, xtry_1.err)((0, xtry_1.stringifyError)(copyResult.error));
+            }
         }
         if (options.verbose) {
-            console.log(`${file.target} has been written as a binary file`);
+            cli_utils_1.logger.debug(`${file.target} has been written as a binary file`);
         }
     }
+    return xtry_1.OK;
 }

package/lib/steps/execute-first-block.d.ts

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

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

@@ -5,28 +5,36 @@ var __importDefault = (this && this.__importDefault) || function (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");
+const xtry_1 = require("@zokugun/xtry");
+const lodash_es_1 = require("lodash-es");
+const index_js_1 = require("../configs/index.js");
 async function executeFirstBlock(context) {
     const { name, version } = context.incomingPackage;
     const root = String(context.incomingConfig.variants?.root ?? '');
     if (context.incomingVariant) {
         let variant;
         let alias;
-        if ((0, lodash_1.isNil)(context.incomingConfig.variants[context.incomingVariant])) {
+        if ((0, lodash_es_1.isNil)(context.incomingConfig.variants[context.incomingVariant])) {
             variant = context.incomingVariant;
             alias = false;
         }
         else {
-            variant = String(context.incomingConfig.variants[context.incomingVariant]);
+            variant = context.incomingConfig.variants[context.incomingVariant];
             alias = true;
         }
         const variantPath = node_path_1.default.join(context.packagePath, 'variants', variant);
-        const variantConfig = await (0, configs_1.readPackageConfig)(variantPath);
+        const configResult = await (0, index_js_1.readPackageConfig)(variantPath);
+        if (configResult.fails) {
+            return configResult;
+        }
+        const variantConfig = configResult.value;
         if (variantConfig.orphan) {
             pushToResult(name, version, variant, alias, context);
             context.incomingConfig = variantConfig;
-            await context.commonFlow(name, version, variant, undefined, variantPath, context);
+            const result = await context.commonFlow(name, version, variant, undefined, variantPath, context);
+            if (result.fails) {
+                return result;
+            }
         }
         else if (variantConfig.extends) {
             context.blocks.unshift({
@@ -36,21 +44,24 @@ async function executeFirstBlock(context) {
                 incomingPath: node_path_1.default.join(context.packagePath, 'variants', variant),
             });
             pushToResult(name, version, variant, alias, context);
-            const extend = String(context.incomingConfig.variants[variantConfig.extends] ?? variantConfig.extends);
+            const extend = context.incomingConfig.variants[variantConfig.extends] ?? variantConfig.extends;
             context.incomingVariant = extend;
             return executeFirstBlock(context);
         }
         else {
             if (root.length === 0) {
-                throw new Error('No root variant has been defined');
+                return (0, xtry_1.err)('No root variant has been defined');
             }
             if (root === variant) {
                 pushToResult(name, version, variant, alias, context);
                 context.incomingConfig = variantConfig;
-                await context.commonFlow(name, version, variant, undefined, variantPath, context);
+                const result = await context.commonFlow(name, version, variant, undefined, variantPath, context);
+                if (result.fails) {
+                    return result;
+                }
             }
             else {
-                const variant = String(context.incomingConfig.variants[context.request.variant] ?? context.request.variant);
+                const variant = context.incomingConfig.variants[context.request.variant] ?? context.request.variant;
                 context.blocks.unshift({
                     name,
                     version,
@@ -60,7 +71,10 @@ async function executeFirstBlock(context) {
                 pushToResult(name, version, variant, alias, context);
                 const incomingPath = node_path_1.default.join(context.packagePath, 'variants', root);
                 context.incomingConfig = undefined;
-                await context.commonFlow(name, version, root, undefined, incomingPath, context);
+                const result = await context.commonFlow(name, version, root, undefined, incomingPath, context);
+                if (result.fails) {
+                    return result;
+                }
             }
         }
     }
@@ -68,16 +82,23 @@ async function executeFirstBlock(context) {
         context.result = {
             name,
             version,
-            provides: [root],
+            requires: [root],
         };
         const incomingPath = node_path_1.default.join(context.packagePath, 'variants', root);
         context.incomingConfig = undefined;
-        await context.commonFlow(name, version, root, undefined, incomingPath, context);
+        const result = await context.commonFlow(name, version, root, undefined, incomingPath, context);
+        if (result.fails) {
+            return result;
+        }
     }
     else {
         context.result = { name, version };
-        await context.commonFlow(name, version, undefined, undefined, context.incomingPath, context);
+        const result = await context.commonFlow(name, version, undefined, undefined, context.incomingPath, context);
+        if (result.fails) {
+            return result;
+        }
     }
+    return xtry_1.OK;
 }
 function pushToResult(name, version, variant, alias, context) {
     context.result ??= {

package/lib/steps/execute-next-block.d.ts

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

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

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeNextBlock = executeNextBlock;
-const lodash_1 = require("lodash");
+const xtry_1 = require("@zokugun/xtry");
+const lodash_es_1 = require("lodash-es");
 async function executeNextBlock(context) {
     const block = context.blocks.shift();
-    if (!(0, lodash_1.isNil)(block)) {
+    if (!(0, lodash_es_1.isNil)(block)) {
         const { name, version, variant, branch, incomingPath } = block;
-        await context.commonFlow(name, version, variant, branch, incomingPath, context);
+        const result = await context.commonFlow(name, version, variant, branch, incomingPath, context);
+        if (result.fails) {
+            return result;
+        }
     }
+    return xtry_1.OK;
 }

package/lib/steps/index.d.ts

@@ -0,0 +1,54 @@
+import { type CommonFlow, type MainFlow } from '../types/context.js';
+import { type Step } from '../types/step.js';
+import { applyFormatting } from './apply-formatting.js';
+import { configureBranches } from './configure-branches.js';
+import { configureInstallFileActions } from './configure-install-file-actions.js';
+import { configureUninstallFileActions } from './configure-uninstall-file-actions.js';
+import { configureUpdateFileActions } from './configure-update-file-actions.js';
+import { copyBinaryFiles } from './copy-binary-files.js';
+import { executeFirstBlock } from './execute-first-block.js';
+import { executeNextBlock } from './execute-next-block.js';
+import { insertFinalNewLine } from './insert-final-new-line.js';
+import { mergeTextFiles } from './merge-text-files.js';
+import { readEditorConfig } from './read-editor-config.js';
+import { readFiles } from './read-files.js';
+import { readIncomingConfig } from './read-incoming-config.js';
+import { readIncomingPackage } from './read-incoming-package.js';
+import { removeFiles } from './remove-files.js';
+import { renameFiles } from './rename-files.js';
+import { replaceTemplates } from './replace-templates.js';
+import { transformUntouchedFiles } from './transform-untouched-files.js';
+import { unmergeTextFiles } from './unmerge-text-files.js';
+import { validateNewerPackage } from './validate-newer-package.js';
+import { validateNotPresentPackage } from './validate-not-present-package.js';
+import { validatePresentPackage } from './validate-present-package.js';
+import { writeTextFiles } from './write-text-files.js';
+export declare const steps: {
+    applyFormatting: typeof applyFormatting;
+    configureBranches: typeof configureBranches;
+    configureInstallFileActions: typeof configureInstallFileActions;
+    configureUninstallFileActions: typeof configureUninstallFileActions;
+    configureUpdateFileActions: typeof configureUpdateFileActions;
+    copyBinaryFiles: typeof copyBinaryFiles;
+    executeFirstBlock: typeof executeFirstBlock;
+    executeNextBlock: typeof executeNextBlock;
+    insertFinalNewLine: typeof insertFinalNewLine;
+    mergeTextFiles: typeof mergeTextFiles;
+    readEditorConfig: typeof readEditorConfig;
+    readFiles: typeof readFiles;
+    readIncomingConfig: typeof readIncomingConfig;
+    readIncomingPackage: typeof readIncomingPackage;
+    removeFiles: typeof removeFiles;
+    renameFiles: typeof renameFiles;
+    replaceTemplates: typeof replaceTemplates;
+    transformUntouchedFiles: typeof transformUntouchedFiles;
+    unmergeTextFiles: typeof unmergeTextFiles;
+    validateNewerPackage: typeof validateNewerPackage;
+    validateNotPresentPackage: typeof validateNotPresentPackage;
+    validatePresentPackage: typeof validatePresentPackage;
+    writeTextFiles: typeof writeTextFiles;
+};
+export declare function composeSteps(validations: Step[], processes: Step[]): {
+    mainFlow: MainFlow;
+    commonFlow: CommonFlow;
+};

package/lib/steps/index.js

@@ -2,75 +2,93 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.steps = void 0;
 exports.composeSteps = composeSteps;
-const ansi_colors_1 = require("ansi-colors");
-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 write_text_files_1 = require("./write-text-files");
+const cli_utils_1 = require("@zokugun/cli-utils");
+const xtry_1 = require("@zokugun/xtry");
+const apply_formatting_js_1 = require("./apply-formatting.js");
+const configure_branches_js_1 = require("./configure-branches.js");
+const configure_install_file_actions_js_1 = require("./configure-install-file-actions.js");
+const configure_uninstall_file_actions_js_1 = require("./configure-uninstall-file-actions.js");
+const configure_update_file_actions_js_1 = require("./configure-update-file-actions.js");
+const copy_binary_files_js_1 = require("./copy-binary-files.js");
+const execute_first_block_js_1 = require("./execute-first-block.js");
+const execute_next_block_js_1 = require("./execute-next-block.js");
+const insert_final_new_line_js_1 = require("./insert-final-new-line.js");
+const merge_text_files_js_1 = require("./merge-text-files.js");
+const read_editor_config_js_1 = require("./read-editor-config.js");
+const read_files_js_1 = require("./read-files.js");
+const read_incoming_config_js_1 = require("./read-incoming-config.js");
+const read_incoming_package_js_1 = require("./read-incoming-package.js");
+const remove_files_js_1 = require("./remove-files.js");
+const rename_files_js_1 = require("./rename-files.js");
+const replace_templates_js_1 = require("./replace-templates.js");
+const transform_untouched_files_js_1 = require("./transform-untouched-files.js");
+const unmerge_text_files_js_1 = require("./unmerge-text-files.js");
+const validate_newer_package_js_1 = require("./validate-newer-package.js");
+const validate_not_present_package_js_1 = require("./validate-not-present-package.js");
+const validate_present_package_js_1 = require("./validate-present-package.js");
+const write_text_files_js_1 = require("./write-text-files.js");
 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,
-    writeTextFiles: write_text_files_1.writeTextFiles,
+    applyFormatting: apply_formatting_js_1.applyFormatting,
+    configureBranches: configure_branches_js_1.configureBranches,
+    configureInstallFileActions: configure_install_file_actions_js_1.configureInstallFileActions,
+    configureUninstallFileActions: configure_uninstall_file_actions_js_1.configureUninstallFileActions,
+    configureUpdateFileActions: configure_update_file_actions_js_1.configureUpdateFileActions,
+    copyBinaryFiles: copy_binary_files_js_1.copyBinaryFiles,
+    executeFirstBlock: execute_first_block_js_1.executeFirstBlock,
+    executeNextBlock: execute_next_block_js_1.executeNextBlock,
+    insertFinalNewLine: insert_final_new_line_js_1.insertFinalNewLine,
+    mergeTextFiles: merge_text_files_js_1.mergeTextFiles,
+    readEditorConfig: read_editor_config_js_1.readEditorConfig,
+    readFiles: read_files_js_1.readFiles,
+    readIncomingConfig: read_incoming_config_js_1.readIncomingConfig,
+    readIncomingPackage: read_incoming_package_js_1.readIncomingPackage,
+    removeFiles: remove_files_js_1.removeFiles,
+    renameFiles: rename_files_js_1.renameFiles,
+    replaceTemplates: replace_templates_js_1.replaceTemplates,
+    transformUntouchedFiles: transform_untouched_files_js_1.transformUntouchedFiles,
+    unmergeTextFiles: unmerge_text_files_js_1.unmergeTextFiles,
+    validateNewerPackage: validate_newer_package_js_1.validateNewerPackage,
+    validateNotPresentPackage: validate_not_present_package_js_1.validateNotPresentPackage,
+    validatePresentPackage: validate_present_package_js_1.validatePresentPackage,
+    writeTextFiles: write_text_files_js_1.writeTextFiles,
 };
 function composeSteps(validations, processes) {
     const mainFlow = async (targetPath, incomingPath, request, config, options) => {
         const context = {
-            packagePath: incomingPath,
-            request,
-            targetPath,
+            binaryFiles: [],
+            blocks: [],
+            commonFlow,
+            config,
+            filters: () => undefined,
+            formats: [],
             incomingPath,
             incomingVariant: request.variant,
+            mergedTextFiles: [],
             onExisting: () => 'merge',
             onMissing: () => 'continue',
-            filters: () => undefined,
+            options,
+            packagePath: incomingPath,
+            removedPatterns: [],
+            renamedPatterns: [],
+            request,
             routes: () => undefined,
-            binaryFiles: [],
+            targetPath,
             textFiles: [],
-            mergedTextFiles: [],
-            removedPatterns: [],
-            formats: [],
-            config,
-            options,
-            commonFlow,
-            blocks: [],
+            transformedFiles: [],
+            transforms: () => undefined,
         };
         let skipped = false;
         for (const step of validations) {
-            if (await step(context)) {
+            const result = await step(context);
+            if (result.fails) {
+                return result;
+            }
+            if (result.value) {
                 skipped = true;
                 break;
             }
         }
-        return skipped ? undefined : context;
+        return skipped ? xtry_1.OK_UNDEFINED : (0, xtry_1.ok)(context);
     };
     const commonFlow = async (name, version, variant, branch, incomingPath, mainContext) => {
         if (mainContext.options.verbose) {
@@ -81,7 +99,7 @@ function composeSteps(validations, processes) {
             if (branch) {
                 message += ` branch=${branch}`;
             }
-            console.log((0, ansi_colors_1.bgBlue)(`\n=== ${message} ===\n`));
+            cli_utils_1.logger.print(cli_utils_1.c.bgBlue(`\n=== ${message} ===\n`));
         }
         const context = {
             ...mainContext,
@@ -102,12 +120,16 @@ function composeSteps(validations, processes) {
         };
         let skipped = false;
         for (const step of processes) {
-            if (await step(context)) {
+            const result = await step(context);
+            if (result.fails) {
+                return result;
+            }
+            if (result.value) {
                 skipped = true;
                 break;
             }
         }
-        return skipped ? undefined : context;
+        return skipped ? xtry_1.OK_UNDEFINED : (0, xtry_1.ok)(context);
     };
     return { mainFlow, commonFlow };
 }