@zokugun/artifact 0.3.1 → 0.4.0

package/lib/configs/install/read-install-config.js

@@ -0,0 +1,121 @@
+"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.readInstallConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const yaml_1 = __importDefault(require("yaml"));
+const places = [
+    {
+        name: '.artifactrc.yml',
+        type: 'yaml',
+    },
+    {
+        name: '.artifactrc.yaml',
+        type: 'yaml',
+    },
+    {
+        name: '.artifactrc.json',
+        type: 'json',
+    },
+    {
+        name: '.artifactrc',
+    },
+];
+function readInstallConfig(targetPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let content;
+        let name;
+        let type;
+        for (const place of places) {
+            try {
+                content = yield fs_extra_1.default.readFile(path_1.default.join(targetPath, place.name), 'utf-8');
+                name = place.name;
+                type = place.type;
+                break;
+            }
+            catch (_a) {
+            }
+        }
+        if (!content) {
+            return {
+                config: {
+                    artifacts: {},
+                    install: {},
+                    update: {},
+                },
+                configStats: {
+                    name: '.artifactrc.yml',
+                    type: 'yaml',
+                    finalNewLine: true,
+                },
+            };
+        }
+        const finalNewLine = content.endsWith('\n');
+        let data;
+        if (type === 'json') {
+            data = JSON.parse(content);
+        }
+        else if (type === 'yaml') {
+            data = yaml_1.default.parse(content);
+        }
+        else {
+            try {
+                data = JSON.parse(content);
+                type = 'json';
+            }
+            catch (_b) {
+                data = yaml_1.default.parse(content);
+                type = 'yaml';
+            }
+        }
+        if (typeof data.update === 'undefined') {
+            data.update = {};
+        }
+        if (isOldInstallConfig(data)) {
+            const config = {
+                artifacts: {},
+                install: data.install,
+                update: data.update,
+            };
+            for (const { name, version } of data.artifacts) {
+                config.artifacts[name] = {
+                    version,
+                };
+            }
+            return {
+                config,
+                configStats: {
+                    name: name,
+                    type,
+                    finalNewLine,
+                },
+            };
+        }
+        else {
+            return {
+                config: data,
+                configStats: {
+                    name: name,
+                    type,
+                    finalNewLine,
+                },
+            };
+        }
+    });
+}
+exports.readInstallConfig = readInstallConfig;
+function isOldInstallConfig(config) {
+    return Array.isArray(config.artifacts);
+}

package/lib/configs/install/update-install-config.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateInstallConfig = void 0;
+function updateInstallConfig(config, { name, version, provides, requires }) {
+    const artifact = {
+        version,
+    };
+    if (requires) {
+        artifact.requires = requires;
+    }
+    if (provides) {
+        artifact.provides = provides;
+    }
+    config.artifacts[name] = artifact;
+}
+exports.updateInstallConfig = updateInstallConfig;

package/lib/{config/write-config.js → configs/install/write-install-config.js}

@@ -12,20 +12,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeConfig = void 0;
+exports.writeInstallConfig = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const lodash_1 = require("lodash");
 const yaml_1 = __importDefault(require("yaml"));
-const apply_formatting_1 = require("../steps/apply-formatting");
-const insert_final_new_line_1 = require("../steps/insert-final-new-line");
-function writeConfig({ artifacts, update }, { name, finalNewLine, type }, formats, targetPath, options) {
+const apply_formatting_1 = require("../../steps/apply-formatting");
+const insert_final_new_line_1 = require("../../steps/insert-final-new-line");
+function writeInstallConfig(config, { name, finalNewLine, type }, formats, targetPath, options) {
     return __awaiter(this, void 0, void 0, function* () {
         const exported = {
-            artifacts: [...artifacts],
+            artifacts: config.artifacts,
         };
-        if (!(0, lodash_1.isPlainObject)(update) || !(0, lodash_1.isEmpty)(update)) {
-            exported.update = update;
+        if (!(0, lodash_1.isPlainObject)(config.update) || !(0, lodash_1.isEmpty)(config.update)) {
+            exported.update = config.update;
         }
         const file = {
             name,
@@ -41,4 +41,4 @@ function writeConfig({ artifacts, update }, { name, finalNewLine, type }, format
         }
     });
 }
-exports.writeConfig = writeConfig;
+exports.writeInstallConfig = writeInstallConfig;

package/lib/configs/package/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageConfig = void 0;
+var read_package_config_1 = require("./read-package-config");
+Object.defineProperty(exports, "readPackageConfig", { enumerable: true, get: function () { return read_package_config_1.readPackageConfig; } });

package/lib/{config/read-config.js → configs/package/read-package-config.js}

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readConfig = void 0;
+exports.readPackageConfig = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const yaml_1 = __importDefault(require("yaml"));
@@ -33,63 +33,46 @@ const places = [
         name: '.artifactrc',
     },
 ];
-function readConfig(targetPath) {
+function readPackageConfig(targetPath) {
     return __awaiter(this, void 0, void 0, function* () {
-        let data;
-        let name;
+        let content;
         let type;
         for (const place of places) {
             try {
-                data = yield fs_extra_1.default.readFile(path_1.default.join(targetPath, place.name), 'utf-8');
-                name = place.name;
+                content = yield fs_extra_1.default.readFile(path_1.default.join(targetPath, place.name), 'utf-8');
                 type = place.type;
                 break;
             }
             catch (_a) {
             }
         }
-        if (!data) {
-            return [
-                {
-                    artifacts: [],
-                    update: {},
-                },
-                {
-                    name: '.artifactrc.yml',
-                    type: 'yaml',
-                    finalNewLine: true,
-                },
-            ];
+        if (!content) {
+            return {
+                install: {},
+                update: {},
+            };
         }
-        const finalNewLine = data.endsWith('\n');
         let config;
         if (type === 'json') {
-            config = JSON.parse(data);
+            config = JSON.parse(content);
         }
         else if (type === 'yaml') {
-            config = yaml_1.default.parse(data);
+            config = yaml_1.default.parse(content);
         }
         else {
             try {
-                config = JSON.parse(data);
+                config = JSON.parse(content);
                 type = 'json';
             }
             catch (_b) {
-                config = yaml_1.default.parse(data);
+                config = yaml_1.default.parse(content);
                 type = 'yaml';
             }
         }
         if (typeof config.update === 'undefined') {
             config.update = {};
         }
-        return [
-            config,
-            {
-                name: name,
-                type,
-                finalNewLine,
-            },
-        ];
+        return config;
     });
 }
-exports.readConfig = readConfig;
+exports.readPackageConfig = readPackageConfig;

package/lib/journeys/config.ts/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const configdotts_merge_1 = require("@zokugun/configdotts-merge");
+const build_journey_plan_1 = require("../../utils/build-journey-plan");
+const build_travel_plan_1 = require("../../utils/build-travel-plan");
+function route({ current, incoming }) {
+    const data = (0, configdotts_merge_1.merge)(current, incoming);
+    return data;
+}
+const travelPlan = (0, build_travel_plan_1.buildTravelPlan)([/\.config\.ts/, route]);
+exports.default = (0, build_journey_plan_1.buildJourneyPlan)(travelPlan);

package/lib/journeys/index.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getJourney = void 0;
 const path_1 = __importDefault(require("path"));
 const commitlint_1 = __importDefault(require("./commitlint"));
+const config_ts_1 = __importDefault(require("./config.ts"));
 const default_1 = __importDefault(require("./default"));
 const fixpack_1 = __importDefault(require("./fixpack"));
 const gitignore_1 = __importDefault(require("./gitignore"));
@@ -23,6 +24,7 @@ const plans = [
     package_1.default,
     tsconfig_1.default,
     rc_1.default,
+    config_ts_1.default,
     default_1.default,
 ];
 function getJourney(filename) {

package/lib/journeys/package/index.js

@@ -39,7 +39,6 @@ const mainRoute = (0, compositors_1.compose)({
         'os',
         'cpu',
         'preferGlobal',
-        'private',
     ],
     $$default: (0, compositors_1.fork)([Array.isArray, routes_1.listConcat], [isPlainObject_1.default, routes_1.mapConcat], routes_1.primitive),
 });

package/lib/parsers/jsonc/parse.js

@@ -180,7 +180,7 @@ function parse(text) {
         },
         onError(error, _offset, _length, _startLine, _startCharacter) {
             // console.log('onError', error, _startLine, _startCharacter)
-            if ((error === 3 /* PropertyNameExpected */ || error === 4 /* ValueExpected */) && lastKid) {
+            if ((error === 3 /* ParseErrorCode.PropertyNameExpected */ || error === 4 /* ParseErrorCode.ValueExpected */) && lastKid) {
                 lastKid.separator = true;
             }
         },

package/lib/steps/apply-formatting.js

@@ -55,8 +55,8 @@ function indentWithSpace(data, size) {
     }
 } // }}}
 function indentWithTab(data) {
-    const { type, indent } = (0, detect_indent_1.default)(data);
-    if (type === 'space') {
+    const { type, indent, amount } = (0, detect_indent_1.default)(data);
+    if (type === 'space' && amount > 1) {
         return data.replace(new RegExp(indent, 'gm'), '\t');
     }
     else {

package/lib/steps/configure-branches.js

@@ -0,0 +1,70 @@
+"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.configureBranches = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const globby_1 = __importDefault(require("globby"));
+function configureBranches(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = node_path_1.default.join(context.incomingPath, 'branches');
+        if (yield fs_extra_1.default.pathExists(cwd)) {
+            const directories = yield (0, globby_1.default)('*', {
+                cwd,
+                onlyDirectories: true,
+            });
+            const bucket = [];
+            for (const directory of directories) {
+                const match = /^\[(@[\w-]+:[\w-]+|[\w-]+)(?::([\w-]+))?]$/.exec(directory);
+                if (match) {
+                    const [branch, name, variant] = match;
+                    const packageName = name.replace(/:/g, '/');
+                    const artifact = context.config.artifacts[packageName];
+                    let found = false;
+                    if (artifact) {
+                        if (variant) {
+                            if (Array.isArray(artifact.requires)) {
+                                if (artifact.requires.includes(variant)) {
+                                    found = true;
+                                }
+                            }
+                            else if (Array.isArray(artifact.provides)) {
+                                if (artifact.provides.includes(variant)) {
+                                    found = true;
+                                }
+                            }
+                            else {
+                                found = true;
+                            }
+                        }
+                        else {
+                            found = true;
+                        }
+                    }
+                    if (found) {
+                        bucket.push({
+                            name: context.incomingName,
+                            version: context.incomingVersion,
+                            variant: context.incomingVariant,
+                            branch,
+                            incomingPath: node_path_1.default.join(cwd, directory),
+                        });
+                    }
+                }
+            }
+            context.blocks.unshift(...bucket);
+        }
+    });
+}
+exports.configureBranches = configureBranches;

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

@@ -0,0 +1,152 @@
+"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 = void 0;
+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;
+            };
+        }
+    });
+}
+exports.configureInstallFileActions = configureInstallFileActions;

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 = void 0;
 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,4 @@ function validateUpdatability(context) {
         }
     });
 }
-exports.validateUpdatability = validateUpdatability;
+exports.configureUpdateFileActions = configureUpdateFileActions;

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

@@ -15,23 +15,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.copyBinaryFiles = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
-function copyBinaryFiles({ binaryFiles, incomingPath, targetPath, onMissing, onUpdate, options }) {
+function copyBinaryFiles({ binaryFiles, incomingPath, targetPath, onExisting, onMissing, options }) {
     return __awaiter(this, void 0, void 0, function* () {
         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`);