@zokugun/artifact 0.5.2 → 0.6.0

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

@@ -38,50 +38,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEditorConfig = readEditorConfig;
 const path_1 = __importDefault(require("path"));
+const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
+const xtry_1 = require("@zokugun/xtry");
 const editorconfig = __importStar(require("editorconfig"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const format_1 = require("../types/format");
+const format_js_1 = require("../types/format.js");
 function buildFullGlob(glob) {
     switch (glob.indexOf('/')) {
-        case -1:
+        case -1: {
             glob = '**/' + glob;
             break;
-        case 0:
+        }
+        case 0: {
             glob = glob.slice(1);
             break;
-        default:
+        }
+        default: {
             break;
+        }
     }
-    return glob.replace(/\*\*/g, '{*,**/**/**}');
+    return glob.replaceAll('**', '{*,**/**/**}');
 } // }}}
 async function readEditorConfig({ incomingPath, targetPath, formats }) {
-    let data;
-    try {
-        const dir = path_1.default.join(incomingPath, 'configs');
-        const file = path_1.default.join(dir, '.editorconfig');
-        data = await fs_extra_1.default.readFile(file, 'utf-8');
-    }
-    catch {
-    }
-    if (!data) {
-        try {
-            const file = path_1.default.join(targetPath, '.editorconfig');
-            data = await fs_extra_1.default.readFile(file, 'utf-8');
-        }
-        catch {
-        }
+    const incomingFile = path_1.default.join(incomingPath, 'configs', '.editorconfig');
+    let readResult = await async_1.default.readFile(incomingFile, 'utf8');
+    if (readResult.fails) {
+        const targetFile = path_1.default.join(targetPath, '.editorconfig');
+        readResult = await async_1.default.readFile(targetFile, 'utf8');
     }
-    if (!data) {
-        return;
+    if (readResult.fails) {
+        return xtry_1.OK;
     }
-    const rules = editorconfig.parseString(data);
+    const rules = editorconfig.parseString(readResult.value);
     for (const [glob, rule] of rules) {
         if (!glob) {
             continue;
         }
         const indentStyle = (rule.indent_style || 'space');
         const indentSize = (rule.indent_size && Number.parseInt(rule.indent_size, 10)) || 2;
-        const insertFinalNewline = typeof rule.insert_final_newline === 'undefined' ? true : rule.insert_final_newline === 'true';
+        const insertFinalNewline = rule.insert_final_newline === undefined ? true : rule.insert_final_newline === 'true';
         formats.push({
             glob: buildFullGlob(glob),
             indentStyle,
@@ -91,9 +85,10 @@ async function readEditorConfig({ incomingPath, targetPath, formats }) {
     }
     formats.push({
         glob: buildFullGlob('{*.yml,*.yaml}'),
-        indentStyle: format_1.IndentStyle.SPACE,
+        indentStyle: format_js_1.IndentStyle.SPACE,
         indentSize: 2,
         insertFinalNewline: true,
     });
     formats.reverse();
+    return xtry_1.OK;
 }

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

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

package/lib/steps/read-files.js

@@ -5,10 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFiles = readFiles;
 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");
 const globby_1 = __importDefault(require("globby"));
 const istextorbinary_1 = require("istextorbinary");
-const read_buffer_1 = require("../utils/read-buffer");
+const read_buffer_js_1 = require("../utils/read-buffer.js");
 async function readFiles({ incomingPath, textFiles, binaryFiles, options }) {
     const cwd = path_1.default.join(incomingPath, 'configs');
     const files = await (0, globby_1.default)(['**/*', '!**/*.lock', '!**/*-lock.*'], {
@@ -18,12 +20,20 @@ async function readFiles({ incomingPath, textFiles, binaryFiles, options }) {
     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_1.readBuffer)(filePath, 24)) === 'utf8') {
-            const data = await fs_extra_1.default.readFile(filePath, 'utf-8');
+        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 = data.endsWith('\n');
             if (data.startsWith('#!')) {
                 // the text file might be executable
-                const { mode } = await fs_extra_1.default.stat(filePath);
+                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,
@@ -31,7 +41,7 @@ async function readFiles({ incomingPath, textFiles, binaryFiles, options }) {
                     finalNewLine,
                 });
                 if (options.verbose) {
-                    console.log(`${file} is a shebang file`);
+                    cli_utils_1.logger.debug(`${file} is a shebang file`);
                 }
             }
             else {
@@ -41,7 +51,7 @@ async function readFiles({ incomingPath, textFiles, binaryFiles, options }) {
                     finalNewLine,
                 });
                 if (options.verbose) {
-                    console.log(`${file} is a text file`);
+                    cli_utils_1.logger.debug(`${file} is a text file`);
                 }
             }
         }
@@ -51,8 +61,9 @@ async function readFiles({ incomingPath, textFiles, binaryFiles, options }) {
                 target: file,
             });
             if (options.verbose) {
-                console.log(`${file} is a binary file`);
+                cli_utils_1.logger.debug(`${file} is a binary file`);
             }
         }
     }
+    return xtry_1.OK;
 }

package/lib/steps/read-incoming-config.d.ts

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

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

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readIncomingConfig = readIncomingConfig;
-const configs_1 = require("../configs");
+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, configs_1.readPackageConfig)(context.incomingPath);
-        if (!config) {
-            return true;
+        const config = await (0, index_js_1.readPackageConfig)(context.incomingPath);
+        if (config.fails) {
+            return config;
         }
-        context.incomingConfig = config;
+        context.incomingConfig = config.value;
     }
+    return xtry_1.OK;
 }

package/lib/steps/read-incoming-package.d.ts

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

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

@@ -5,18 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readIncomingPackage = readIncomingPackage;
 const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const lodash_1 = require("lodash");
+const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
+const xtry_1 = require("@zokugun/xtry");
+const lodash_es_1 = require("lodash-es");
 async function readIncomingPackage(context) {
     const filePath = path_1.default.resolve(context.incomingPath, './package.json');
-    const incomingPackage = await fs_extra_1.default.readJSON(filePath);
-    if (!isPackageManifest(incomingPackage)) {
-        throw new Error('The package of the incoming artifact can\'t be found.');
+    const result = await async_1.default.readJSON(filePath);
+    if (result.fails) {
+        return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
     }
-    context.incomingPackage = incomingPackage;
+    if (!isPackageManifest(result.value)) {
+        return (0, xtry_1.err)('The package of the incoming artifact can\'t be found.');
+    }
+    context.incomingPackage = result.value;
+    return xtry_1.OK;
 }
 function isPackageManifest(value) {
-    if ((0, lodash_1.isNil)(value) || !(0, lodash_1.isPlainObject)(value)) {
+    if ((0, lodash_es_1.isNil)(value) || !(0, lodash_es_1.isPlainObject)(value)) {
         return false;
     }
     const manifest = value;

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

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

package/lib/steps/remove-files.js

@@ -5,12 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeFiles = removeFiles;
 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");
 const globby_1 = __importDefault(require("globby"));
 const micromatch_1 = require("micromatch");
 async function removeFiles({ removedPatterns, targetPath, options }) {
     if (removedPatterns.length === 0) {
-        return;
+        return xtry_1.OK;
     }
     const cwd = path_1.default.join(targetPath);
     const files = await (0, globby_1.default)(['**/*', '!**/*.lock', '!**/*-lock.*', '!.git'], {
@@ -21,11 +23,15 @@ async function removeFiles({ removedPatterns, targetPath, options }) {
         if ((0, micromatch_1.isMatch)(file, removedPatterns)) {
             if (!options.dryRun) {
                 const filePath = path_1.default.join(cwd, file);
-                await fs_extra_1.default.unlink(filePath);
+                const result = await async_1.default.unlink(filePath);
+                if (result.fails) {
+                    return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
+                }
             }
             if (options.verbose) {
-                console.log(`${file} has been removed`);
+                cli_utils_1.logger.debug(`${file} has been removed`);
             }
         }
     }
+    return xtry_1.OK;
 }

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

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

package/lib/steps/rename-files.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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) {
+        return xtry_1.OK;
+    }
+    const cwd = path_1.default.join(targetPath);
+    for (const { from, to } of renamedPatterns) {
+        const fromPath = path_1.default.join(cwd, from);
+        if (await async_1.default.isExisting(fromPath)) {
+            const result = await async_1.default.rename(fromPath, path_1.default.join(cwd, to));
+            if (result.fails) {
+                return (0, xtry_1.err)((0, xtry_1.stringifyError)(result.error));
+            }
+        }
+    }
+    return xtry_1.OK;
+}

package/lib/steps/replace-templates.d.ts

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

package/lib/steps/replace-templates.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.replaceTemplates = replaceTemplates;
-const template_1 = require("../utils/template");
+const xtry_1 = require("@zokugun/xtry");
+const template_js_1 = require("../utils/template.js");
 async function replaceTemplates({ textFiles, binaryFiles, targetPath, config, incomingConfig }) {
     const variables = {
         ...incomingConfig?.variables,
@@ -9,12 +10,25 @@ async function replaceTemplates({ textFiles, binaryFiles, targetPath, config, in
         ...incomingConfig?.constants,
         ...config?.constants,
     };
-    const engine = new template_1.TemplateEngine(targetPath, variables);
+    const engine = new template_js_1.TemplateEngine(targetPath, variables);
     for (const file of textFiles) {
-        file.data = engine.render(file.data);
-        file.name = engine.render(file.name);
+        const dataResult = engine.render(file.data);
+        if (dataResult.fails) {
+            return dataResult;
+        }
+        const nameResult = engine.render(file.name);
+        if (nameResult.fails) {
+            return nameResult;
+        }
+        file.data = dataResult.value;
+        file.name = nameResult.value;
     }
     for (const file of binaryFiles) {
-        file.target = engine.render(file.target);
+        const targetResult = engine.render(file.target);
+        if (targetResult.fails) {
+            return targetResult;
+        }
+        file.target = targetResult.value;
     }
+    return xtry_1.OK;
 }

package/lib/steps/transform-untouched-files.d.ts

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

package/lib/steps/transform-untouched-files.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformUntouchedFiles = transformUntouchedFiles;
+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 globby_1 = __importDefault(require("globby"));
+const index_js_1 = require("../journeys/index.js");
+const detect_indent_js_1 = require("../utils/detect-indent.js");
+const get_format_js_1 = require("../utils/get-format.js");
+const has_final_new_line_js_1 = require("../utils/has-final-new-line.js");
+async function transformUntouchedFiles({ formats, options, routes, targetPath, textFiles, transformedFiles, transforms }) {
+    if (transforms.length === 0) {
+        return xtry_1.OK;
+    }
+    const cwd = path_1.default.join(targetPath);
+    const files = await (0, globby_1.default)(['**/*', '!**/*.lock', '!**/*-lock.*'], {
+        cwd,
+        dot: true,
+    });
+    for (const file of files) {
+        if (textFiles.some(({ name }) => name === file)) {
+            continue;
+        }
+        const transformations = transforms(file);
+        if (!transformations || (0, is_it_type_1.isEmptyArray)(transformations)) {
+            continue;
+        }
+        const journey = routes(file) ?? (0, index_js_1.getJourney)(file);
+        if (!journey) {
+            continue;
+        }
+        if (options.verbose) {
+            cli_utils_1.logger.debug(`${file} is going to be transformed`);
+        }
+        const filePath = path_1.default.join(cwd, file);
+        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 = data.endsWith('\n');
+        const transformed = await journey.travel({
+            current: data,
+            incoming: undefined,
+            transforms: transformations,
+        });
+        transformedFiles.push({
+            name: file,
+            data: transformed,
+            finalNewLine: finalNewLine,
+        });
+        if (options.verbose) {
+            cli_utils_1.logger.debug(`${file} has been transformed`);
+        }
+        const format = (0, get_format_js_1.getFormat)(file, formats);
+        if (!format) {
+            const indent = (0, detect_indent_js_1.detectIndent)(data);
+            formats.push({
+                glob: file,
+                indentStyle: indent.style,
+                indentSize: indent.size,
+                insertFinalNewline: (0, has_final_new_line_js_1.hasFinalNewLine)(data),
+            });
+        }
+    }
+    return xtry_1.OK;
+}

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

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

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

@@ -0,0 +1,63 @@
+"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,
+                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;
+};