@zokugun/artifact 0.1.0 → 0.2.2

package/lib/journeys/tsconfig/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const compositors_1 = require("../../compositors");
+const routes_1 = require("../../routes");
+const build_journey_plan_1 = require("../../utils/build-journey-plan");
+const build_travel_plan_1 = require("../../utils/build-travel-plan");
+const mainRoute = (0, compositors_1.compose)({
+    compilerOptions: (0, compositors_1.compose)({
+        lib: routes_1.listConcat,
+        $$default: (0, compositors_1.fork)([Array.isArray, routes_1.listConcat], [isPlainObject_1.default, routes_1.mapConcat], routes_1.primitive),
+    }),
+    $$default: (0, compositors_1.fork)([Array.isArray, routes_1.listConcat], [isPlainObject_1.default, routes_1.mapConcat], routes_1.primitive),
+});
+const jsonRoute = (0, compositors_1.json)(mainRoute);
+const travelPlan = (0, build_travel_plan_1.buildTravelPlan)([/tsconfig(?:\.\w+)?\.json$/, jsonRoute]);
+exports.default = (0, build_journey_plan_1.buildJourneyPlan)(travelPlan);

package/lib/routes/command.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.command = void 0;
 const command_1 = require("../utils/command");
-const hash_1 = require("./hash");
+const list_concat_1 = require("./list-concat");
 function command({ current, incoming }) {
+    var _a;
     if (!incoming) {
         return current !== null && current !== void 0 ? current : '';
     }
@@ -12,10 +13,34 @@ function command({ current, incoming }) {
     }
     const currentCommand = (0, command_1.splitCommand)(current);
     const incomingCommand = (0, command_1.splitCommand)(incoming);
-    const result = (0, hash_1.hash)({
-        current: currentCommand,
-        incoming: incomingCommand,
-    });
+    const result = {};
+    for (const [name, instances] of Object.entries(incomingCommand)) {
+        if (currentCommand[name]) {
+            result[name] = [];
+            for (const [index, instance] of instances.entries()) {
+                if (currentCommand[name][index]) {
+                    const currentInstance = currentCommand[name][index];
+                    result[name].push({
+                        args: (0, list_concat_1.listConcat)({
+                            current: currentInstance.args,
+                            incoming: instance.args,
+                        }),
+                        env: (0, list_concat_1.listConcat)({
+                            current: currentInstance.env,
+                            incoming: instance.env,
+                        }),
+                        separator: (_a = instance.separator) !== null && _a !== void 0 ? _a : currentInstance.separator,
+                    });
+                }
+                else {
+                    result[name].push(instance);
+                }
+            }
+        }
+        else {
+            result[name] = instances;
+        }
+    }
     return (0, command_1.joinCommand)(result);
 }
 exports.command = command;

package/lib/routes/index.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.primitive = exports.overwrite = exports.listConcat = exports.linesConcat = exports.hash = exports.command = void 0;
+exports.primitive = exports.overwrite = exports.listSortConcat = exports.listConcat = exports.linesConcat = exports.mapConcat = exports.command = void 0;
 var command_1 = require("./command");
 Object.defineProperty(exports, "command", { enumerable: true, get: function () { return command_1.command; } });
-var hash_1 = require("./hash");
-Object.defineProperty(exports, "hash", { enumerable: true, get: function () { return hash_1.hash; } });
+var map_concat_1 = require("./map-concat");
+Object.defineProperty(exports, "mapConcat", { enumerable: true, get: function () { return map_concat_1.mapConcat; } });
 var lines_concat_1 = require("./lines-concat");
 Object.defineProperty(exports, "linesConcat", { enumerable: true, get: function () { return lines_concat_1.linesConcat; } });
 var list_concat_1 = require("./list-concat");
 Object.defineProperty(exports, "listConcat", { enumerable: true, get: function () { return list_concat_1.listConcat; } });
+var list_sort_concat_1 = require("./list-sort-concat");
+Object.defineProperty(exports, "listSortConcat", { enumerable: true, get: function () { return list_sort_concat_1.listSortConcat; } });
 var overwrite_1 = require("./overwrite");
 Object.defineProperty(exports, "overwrite", { enumerable: true, get: function () { return overwrite_1.overwrite; } });
 var primitive_1 = require("./primitive");

package/lib/routes/lines-concat.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.linesConcat = void 0;
-const trim_final_newline_1 = require("../utils/trim-final-newline");
 const to_lines_1 = require("../utils/to-lines");
+const trim_final_newline_1 = require("../utils/trim-final-newline");
 const list_concat_1 = require("./list-concat");
 function linesConcat({ current, incoming }) {
     if (!incoming) {

package/lib/routes/list-sort-concat.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSortConcat = void 0;
+function listSortConcat({ current, incoming }) {
+    if (!incoming) {
+        return current !== null && current !== void 0 ? current : [];
+    }
+    if (!current) {
+        return incoming;
+    }
+    const sorting = [];
+    const weight2values = {};
+    const hash2weights = {};
+    let lastWeight = 0;
+    for (const [index, value] of current.entries()) {
+        const hash = JSON.stringify(value);
+        if (!hash2weights[hash]) {
+            const weight = (index + 1) * 1000;
+            hash2weights[hash] = weight;
+            weight2values[weight] = value;
+            sorting.push(weight);
+            lastWeight = weight;
+        }
+    }
+    let currentWeight = lastWeight;
+    for (const value of incoming) {
+        const hash = JSON.stringify(value);
+        if (hash2weights[hash]) {
+            currentWeight = hash2weights[hash];
+        }
+        else {
+            ++currentWeight;
+            hash2weights[hash] = currentWeight;
+            weight2values[currentWeight] = value;
+            sorting.push(currentWeight);
+        }
+    }
+    sorting.sort((a, b) => a - b);
+    const result = sorting.map((weight) => weight2values[weight]);
+    return result;
+}
+exports.listSortConcat = listSortConcat;

package/lib/routes/{hash.js → map-concat.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hash = void 0;
-function hash({ current, incoming }) {
+exports.mapConcat = void 0;
+function mapConcat({ current, incoming }) {
     if (!incoming) {
         return current !== null && current !== void 0 ? current : {};
     }
@@ -10,4 +10,4 @@ function hash({ current, incoming }) {
     }
     return Object.assign(Object.assign({}, current), incoming);
 }
-exports.hash = hash;
+exports.mapConcat = mapConcat;

package/lib/routes/overwrite.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.overwrite = void 0;
 function overwrite({ current, incoming }) {
-    if (!incoming) {
+    if (typeof incoming === 'undefined') {
         return current !== null && current !== void 0 ? current : [];
     }
     else {

package/lib/routes/primitive.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.primitive = void 0;
 function primitive({ current, incoming }) {
-    if (!incoming) {
+    if (typeof incoming === 'undefined') {
         return current !== null && current !== void 0 ? current : [];
     }
-    if (!current) {
+    if (typeof current === 'undefined') {
         return incoming;
     }
     if (current === incoming) {

package/lib/steps/apply-formatting.js

@@ -13,8 +13,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyFormatting = void 0;
-const fnmatch_1 = __importDefault(require("editorconfig/src/lib/fnmatch"));
 const detect_indent_1 = __importDefault(require("detect-indent"));
+const fnmatch_1 = __importDefault(require("editorconfig/src/lib/fnmatch"));
 const format_1 = require("../types/format");
 function applyFormat(file, format) {
     if (format.indentStyle === format_1.IndentStyle.SPACE) {

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

@@ -15,10 +15,21 @@ 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, options }) {
+function copyBinaryFiles({ binaryFiles, incomingPath, targetPath, onMissing, onUpdate, 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));
+                if (onUpdate(file)) {
+                    continue;
+                }
+            }
+            catch (_a) {
+                if (onMissing(file)) {
+                    continue;
+                }
+            }
             const source = path_1.default.join(cwd, file);
             const target = path_1.default.join(targetPath, file);
             yield fs_extra_1.default.copyFile(source, target);

package/lib/steps/index.js

@@ -16,9 +16,11 @@ 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 read_target_config_1 = require("./read-target-config");
-const update_target_config_1 = require("./update-target-config");
+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,
@@ -27,16 +29,37 @@ exports.steps = {
     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,
-    readTargetConfig: read_target_config_1.readTargetConfig,
-    updateTargetConfig: update_target_config_1.updateTargetConfig,
+    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 (context) => __awaiter(this, void 0, void 0, function* () {
+    return (targetPath, incomingPath, config, options) => __awaiter(this, void 0, void 0, function* () {
+        const context = {
+            targetPath,
+            incomingPath,
+            onMissing: () => false,
+            onUpdate: () => false,
+            filters: () => undefined,
+            routes: () => undefined,
+            binaryFiles: [],
+            textFiles: [],
+            mergedTextFiles: [],
+            formats: [],
+            config,
+            options,
+        };
+        let skipped = false;
         for (const step of steps) {
-            yield step(context);
+            if (yield step(context)) {
+                skipped = true;
+                break;
+            }
         }
+        return skipped ? undefined : context;
     });
 }
 exports.composeSteps = composeSteps;

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

@@ -16,18 +16,26 @@ exports.mergeTextFiles = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const journeys_1 = require("../journeys");
-function mergeTextFiles({ targetPath, textFiles, mergedTextFiles, options }) {
+function mergeTextFiles({ targetPath, textFiles, mergedTextFiles, onMissing, onUpdate, filters, routes, options }) {
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
         for (const file of textFiles) {
-            if (file.data.length === 0) {
-                mergedTextFiles.push(file);
-                continue;
-            }
-            const journey = (0, journeys_1.getJourney)(file.name);
+            const journey = (_a = routes(file.name)) !== null && _a !== void 0 ? _a : (0, journeys_1.getJourney)(file.name);
             if (!journey) {
                 if (options.verbose) {
                     console.log(`${file.name}, no merger found`);
                 }
+                try {
+                    yield fs_extra_1.default.access(path_1.default.join(targetPath, file.name));
+                    if (onUpdate(file.name)) {
+                        continue;
+                    }
+                }
+                catch (_b) {
+                    if (onMissing(file.name)) {
+                        continue;
+                    }
+                }
                 mergedTextFiles.push(file);
                 continue;
             }
@@ -35,12 +43,19 @@ function mergeTextFiles({ targetPath, textFiles, mergedTextFiles, options }) {
             let currentData;
             try {
                 currentData = yield fs_extra_1.default.readFile(path_1.default.join(targetPath, name), 'utf-8');
+                if (onUpdate(name)) {
+                    continue;
+                }
             }
-            catch (_a) {
+            catch (_c) {
+                if (onMissing(name)) {
+                    continue;
+                }
             }
             const data = journey.travel({
                 current: currentData,
                 incoming: file.data,
+                filters: filters(file.name),
             });
             mergedTextFiles.push({
                 name,

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

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -33,8 +37,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readEditorConfig = void 0;
 const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
 const editorconfig = __importStar(require("editorconfig"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const format_1 = require("../types/format");
 function buildFullGlob(glob) {
     switch (glob.indexOf('/')) {

package/lib/steps/read-files.js

@@ -14,13 +14,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFiles = void 0;
 const path_1 = __importDefault(require("path"));
-const istextorbinary_1 = require("istextorbinary");
-const globby_1 = __importDefault(require("globby"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const globby_1 = __importDefault(require("globby"));
+const istextorbinary_1 = require("istextorbinary");
 const read_buffer_1 = require("../utils/read-buffer");
-function readFiles(context) {
+function readFiles({ incomingPath, textFiles, binaryFiles, options }) {
     return __awaiter(this, void 0, void 0, function* () {
-        const cwd = path_1.default.join(context.incomingPath, 'configs');
+        const cwd = path_1.default.join(incomingPath, 'configs');
         const files = yield (0, globby_1.default)(['**/*', '!**/*.lock', '!**/*-lock.*'], {
             cwd,
             dot: true,
@@ -33,30 +33,30 @@ function readFiles(context) {
                 if (data.startsWith('#!')) {
                     // the text file might be executable
                     const { mode } = yield fs_extra_1.default.stat(filePath);
-                    context.textFiles.push({
+                    textFiles.push({
                         name: file,
                         data,
                         mode,
                         finalNewLine,
                     });
-                    if (context.options.verbose) {
+                    if (options.verbose) {
                         console.log(`${file} is a shebang file`);
                     }
                 }
                 else {
-                    context.textFiles.push({
+                    textFiles.push({
                         name: file,
                         data,
                         finalNewLine,
                     });
-                    if (context.options.verbose) {
+                    if (options.verbose) {
                         console.log(`${file} is a text file`);
                     }
                 }
             }
             else {
-                context.binaryFiles.push(file);
-                if (context.options.verbose) {
+                binaryFiles.push(file);
+                if (options.verbose) {
                     console.log(`${file} is a binary file`);
                 }
             }

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

@@ -0,0 +1,20 @@
+"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.readIncomingConfig = void 0;
+const config_1 = require("../config");
+function readIncomingConfig(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [config] = yield (0, config_1.readConfig)(context.incomingPath);
+        context.incomingConfig = config;
+    });
+}
+exports.readIncomingConfig = readIncomingConfig;

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

@@ -19,6 +19,9 @@ function readIncomingPackage(context) {
     return __awaiter(this, void 0, void 0, function* () {
         const filePath = path_1.default.resolve(context.incomingPath, './package.json');
         context.incomingPackage = (yield fs_extra_1.default.readJSON(filePath));
+        if (!context.incomingPackage) {
+            throw new Error('The package of the incoming artifact can\'t be found.');
+        }
     });
 }
 exports.readIncomingPackage = readIncomingPackage;

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

@@ -0,0 +1,25 @@
+"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.validateNewerPackage = void 0;
+const semver_1 = require("semver");
+function validateNewerPackage({ incomingPackage, config, options }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.force) {
+            return;
+        }
+        const artifact = config.artifacts.find(({ name }) => name === incomingPackage.name);
+        if (artifact) {
+            return !(0, semver_1.gt)(incomingPackage.version, artifact.version);
+        }
+    });
+}
+exports.validateNewerPackage = validateNewerPackage;

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

@@ -0,0 +1,33 @@
+"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.validateNotPresentPackage = void 0;
+function validateNotPresentPackage({ incomingPackage, config, options }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (options.force) {
+            return;
+        }
+        const { name } = incomingPackage;
+        const artifact = config.artifacts.find((artifact) => artifact.name === name);
+        if (artifact) {
+            if (options.skip) {
+                if (options.verbose) {
+                    console.log('The incoming artifact is already present, skipping...');
+                }
+                return true;
+            }
+            else {
+                throw new Error('The incoming artifact has already been added.');
+            }
+        }
+    });
+}
+exports.validateNotPresentPackage = validateNotPresentPackage;

package/lib/steps/validate-updatability.js

@@ -0,0 +1,160 @@
+"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.validateUpdatability = 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 validateUpdatability(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;
+            }
+        }
+        else if ((0, lodash_1.isPlainObject)(update)) {
+            const missings = [];
+            const updates = [];
+            const filters = {};
+            const routes = {};
+            for (const [file, fileUpdate] of Object.entries(update)) {
+                const { missing, update, filter, route } = fileUpdate;
+                if (missing === false) {
+                    missings.push(file);
+                }
+                if (update === false) {
+                    updates.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 (missings.length > 0) {
+                context.onMissing = (file) => (0, micromatch_1.isMatch)(file, missings);
+            }
+            if (updates.length > 0) {
+                context.onUpdate = (file) => (0, micromatch_1.isMatch)(file, updates);
+            }
+            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.validateUpdatability = validateUpdatability;