@zokugun/artifact 0.1.0

package/lib/parsers/jsonc/parse.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const jsonc_parser_1 = require("jsonc-parser");
+function parse(text) {
+    if (!text) {
+        return {
+            data: undefined,
+            transform: {},
+        };
+    }
+    const stack = [];
+    let current;
+    let property = '';
+    const transformStack = [];
+    let comment;
+    let transform;
+    let lastLine = 0;
+    let lastOffset = 0;
+    let lastKid;
+    (0, jsonc_parser_1.visit)(text, {
+        onObjectBegin(offset, length, startLine, _startCharacter) {
+            // console.log('onObjectBegin', startLine)
+            if (current) {
+                stack.unshift(current);
+            }
+            if (transform) {
+                transformStack.unshift(transform);
+            }
+            current = {};
+            transform = {
+                children: {},
+            };
+            if (stack.length > 0) {
+                if (Array.isArray(stack[0])) {
+                    stack[0].push(current);
+                }
+                else {
+                    stack[0][property] = current;
+                    transformStack[0].children[property] = transform;
+                    property = '';
+                }
+            }
+            lastKid = transform;
+            lastLine = startLine;
+            lastOffset = offset + length;
+        },
+        onObjectProperty(name, _offset, _length, _startLine, _startCharacter) {
+            // console.log('onObjectProperty', name, _startLine, _startCharacter)
+            property = name;
+        },
+        onObjectEnd(offset, length, startLine, _startCharacter) {
+            // console.log('onObjectEnd', startLine, startCharacter)
+            if (stack.length > 0) {
+                lastKid = transform;
+                current = stack.shift();
+                transform = transformStack.shift();
+            }
+            lastLine = startLine;
+            lastOffset = offset + length;
+        },
+        onArrayBegin(offset, length, startLine, _startCharacter) {
+            // console.log('onArrayBegin', startLine, _startCharacter)
+            if (current) {
+                stack.unshift(current);
+            }
+            if (transform) {
+                transformStack.unshift(transform);
+            }
+            current = [];
+            transform = {
+                children: {},
+            };
+            if (stack.length > 0) {
+                if (Array.isArray(stack[0])) {
+                    stack[0].push(current);
+                }
+                else {
+                    stack[0][property] = current;
+                    transformStack[0].children[property] = transform;
+                    property = '';
+                }
+            }
+            lastKid = transform;
+            lastLine = startLine;
+            lastOffset = offset + length;
+        },
+        onArrayEnd(offset, length, startLine, _startCharacter) {
+            // console.log('onArrayEnd', startLine, _startCharacter)
+            if (stack.length > 0) {
+                lastKid = transform;
+                current = stack.shift();
+                transform = transformStack.shift();
+            }
+            lastLine = startLine;
+            lastOffset = offset + length;
+        },
+        onLiteralValue(value, offset, length, startLine, _startCharacter) {
+            // console.log('onLiteralValue', startLine, _startCharacter)
+            if (current) {
+                if (Array.isArray(current)) {
+                    lastKid = {};
+                    transform.children[current.length] = lastKid;
+                    current.push(value);
+                }
+                else {
+                    current[property] = value;
+                    if (comment) {
+                        transform.children[property] = {
+                            comments: {
+                                top: comment.text,
+                            },
+                        };
+                        if (comment.line - lastLine > 1) {
+                            transform.children[property].emptyLines = comment.line - lastLine - 1;
+                        }
+                        comment = undefined;
+                    }
+                    else if (startLine - lastLine > 1) {
+                        transform.children[property] = {
+                            emptyLines: startLine - lastLine - 1,
+                        };
+                    }
+                    else {
+                        transform.children[property] = {};
+                    }
+                    lastKid = transform.children[property];
+                    property = '';
+                }
+            }
+            lastLine = startLine;
+            lastOffset = offset + length;
+        },
+        onSeparator(_character, offset, length, _startLine, _startCharacter) {
+            // console.log('onSeparator', _character, _startLine, _startCharacter)
+            if (lastOffset) {
+                lastOffset = offset + length;
+            }
+        },
+        onComment(offset, length, startLine, _startCharacter) {
+            // console.log('onComment', startLine, _startCharacter)
+            let line = text.slice(offset, offset + length);
+            if (startLine === lastLine && lastKid) {
+                line = text.slice(lastOffset, lastOffset + offset - lastOffset) + line;
+                if (lastKid.comments) {
+                    lastKid.comments.right = [line];
+                }
+                else {
+                    lastKid.comments = {
+                        right: [line],
+                    };
+                }
+            }
+            else if (comment) {
+                if (comment.line + comment.text.length === startLine) {
+                    comment.text.push(line);
+                }
+                else {
+                    if (lastKid.comments) {
+                        lastKid.comments.bottom = comment.text;
+                    }
+                    else {
+                        lastKid.comments = {
+                            bottom: comment.text,
+                        };
+                    }
+                    lastLine += comment.text.length;
+                    comment = {
+                        text: [line],
+                        line: startLine,
+                    };
+                }
+            }
+            else {
+                comment = {
+                    text: [line],
+                    line: startLine,
+                };
+            }
+        },
+        onError(error, _offset, _length, _startLine, _startCharacter) {
+            // console.log('onError', error, _startLine, _startCharacter)
+            if ((error === 3 /* PropertyNameExpected */ || error === 4 /* ValueExpected */) && lastKid) {
+                lastKid.separator = true;
+            }
+        },
+    });
+    // console.log(JSON.stringify(transform, null, 2))
+    return {
+        data: current,
+        transform,
+    };
+}
+exports.parse = parse;

package/lib/parsers/jsonc/stringify.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = void 0;
+const lodash_1 = require("lodash");
+function stringify(data, transform = {}) {
+    const result = format(data, '', transform);
+    return result;
+}
+exports.stringify = stringify;
+function format(data, indentValue, transform, separator = false) {
+    var _a;
+    let result;
+    if (Array.isArray(data)) {
+        result = formatArray(data, indentValue, transform);
+        if (separator) {
+            result += ',';
+        }
+    }
+    else if ((0, lodash_1.isPlainObject)(data)) {
+        result = formatObject(data, indentValue, transform);
+        if (separator) {
+            result += ',';
+        }
+    }
+    else {
+        result = JSON.stringify(data);
+        if (separator) {
+            result += ',';
+        }
+        if ((_a = transform.comments) === null || _a === void 0 ? void 0 : _a.right) {
+            result += transform.comments.right[0];
+        }
+    }
+    return result;
+}
+function formatArray(data, indentValue, transform) {
+    var _a, _b, _c, _d, _e;
+    let result = '[';
+    if ((_a = transform.comments) === null || _a === void 0 ? void 0 : _a.right) {
+        result += transform.comments.right[0];
+    }
+    result += '\n';
+    const indent = indentValue + '\t';
+    const lastIndex = data.length - 1;
+    const children = (_b = transform.children) !== null && _b !== void 0 ? _b : {};
+    for (const [index, value] of data.entries()) {
+        const transform = (_c = children[index]) !== null && _c !== void 0 ? _c : {};
+        if (transform.emptyLines) {
+            result += '\n'.repeat(transform.emptyLines);
+        }
+        if ((_d = transform.comments) === null || _d === void 0 ? void 0 : _d.top) {
+            for (const line of transform.comments.top) {
+                result += `${indent}${line}\n`;
+            }
+        }
+        result += `${indent}`;
+        result += format(value, indent, transform, index !== lastIndex || transform.separator);
+        result += '\n';
+        if ((_e = transform.comments) === null || _e === void 0 ? void 0 : _e.bottom) {
+            for (const line of transform.comments.bottom) {
+                result += `${indent}${line}\n`;
+            }
+        }
+    }
+    result += `${indentValue}]`;
+    return result;
+}
+function formatObject(data, indentValue, transform) {
+    var _a, _b, _c, _d, _e;
+    let result = '{';
+    if ((_a = transform.comments) === null || _a === void 0 ? void 0 : _a.right) {
+        result += transform.comments.right[0];
+    }
+    result += '\n';
+    const indent = indentValue + '\t';
+    const values = Object.entries(data);
+    const lastIndex = values.length - 1;
+    const children = (_b = transform.children) !== null && _b !== void 0 ? _b : {};
+    for (const [index, [key, value]] of values.entries()) {
+        const transform = (_c = children[key]) !== null && _c !== void 0 ? _c : {};
+        if (transform.emptyLines) {
+            result += '\n'.repeat(transform.emptyLines);
+        }
+        if ((_d = transform.comments) === null || _d === void 0 ? void 0 : _d.top) {
+            for (const line of transform.comments.top) {
+                result += `${indent}${line}\n`;
+            }
+        }
+        result += `${indent}"${key}": `;
+        result += format(value, indent, transform, index !== lastIndex || transform.separator);
+        result += '\n';
+        if ((_e = transform.comments) === null || _e === void 0 ? void 0 : _e.bottom) {
+            for (const line of transform.comments.bottom) {
+                result += `${indent}${line}\n`;
+            }
+        }
+    }
+    result += `${indentValue}}`;
+    return result;
+}

package/lib/parsers/jsonc/transform.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/parsers/yaml.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = exports.parse = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+function parse(data) {
+    return yaml_1.default.parse(data);
+}
+exports.parse = parse;
+function stringify(data) {
+    return yaml_1.default.stringify(data);
+}
+exports.stringify = stringify;

package/lib/routes/command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const command_1 = require("../utils/command");
+const hash_1 = require("./hash");
+function command({ current, incoming }) {
+    if (!incoming) {
+        return current !== null && current !== void 0 ? current : '';
+    }
+    if (!current) {
+        return 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,
+    });
+    return (0, command_1.joinCommand)(result);
+}
+exports.command = command;

package/lib/routes/hash.js

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

package/lib/routes/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitive = exports.overwrite = exports.listConcat = exports.linesConcat = exports.hash = 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 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 overwrite_1 = require("./overwrite");
+Object.defineProperty(exports, "overwrite", { enumerable: true, get: function () { return overwrite_1.overwrite; } });
+var primitive_1 = require("./primitive");
+Object.defineProperty(exports, "primitive", { enumerable: true, get: function () { return primitive_1.primitive; } });

package/lib/routes/lines-concat.js

@@ -0,0 +1,22 @@
+"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 list_concat_1 = require("./list-concat");
+function linesConcat({ current, incoming }) {
+    if (!incoming) {
+        return current !== null && current !== void 0 ? current : '';
+    }
+    if (!current) {
+        return incoming;
+    }
+    const currentLines = (0, to_lines_1.toLines)((0, trim_final_newline_1.trimFinalNewLine)(current));
+    const incomingLines = (0, to_lines_1.toLines)((0, trim_final_newline_1.trimFinalNewLine)(incoming));
+    const result = (0, list_concat_1.listConcat)({
+        current: currentLines,
+        incoming: incomingLines,
+    });
+    return result.join('\n');
+}
+exports.linesConcat = linesConcat;

package/lib/routes/list-concat.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listConcat = void 0;
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const uniqWith_1 = __importDefault(require("lodash/uniqWith"));
+function listConcat({ current, incoming }) {
+    if (!incoming) {
+        return current !== null && current !== void 0 ? current : [];
+    }
+    if (!current) {
+        return incoming;
+    }
+    return (0, uniqWith_1.default)([...current, ...incoming], isEqual_1.default);
+}
+exports.listConcat = listConcat;

package/lib/routes/overwrite.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwrite = void 0;
+function overwrite({ current, incoming }) {
+    if (!incoming) {
+        return current !== null && current !== void 0 ? current : [];
+    }
+    else {
+        return incoming;
+    }
+}
+exports.overwrite = overwrite;

package/lib/routes/primitive.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitive = void 0;
+function primitive({ current, incoming }) {
+    if (!incoming) {
+        return current !== null && current !== void 0 ? current : [];
+    }
+    if (!current) {
+        return incoming;
+    }
+    if (current === incoming) {
+        return current;
+    }
+    else {
+        return incoming;
+    }
+}
+exports.primitive = primitive;

package/lib/steps/apply-formatting.js

@@ -0,0 +1,78 @@
+"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.applyFormatting = void 0;
+const fnmatch_1 = __importDefault(require("editorconfig/src/lib/fnmatch"));
+const detect_indent_1 = __importDefault(require("detect-indent"));
+const format_1 = require("../types/format");
+function applyFormat(file, format) {
+    if (format.indentStyle === format_1.IndentStyle.SPACE) {
+        file.data = indentWithSpace(file.data, format.indentSize);
+    }
+    else {
+        file.data = indentWithTab(file.data);
+    }
+    if (format.insertFinalNewline) {
+        const withFinalNewLine = file.data.endsWith('\n');
+        if (!withFinalNewLine) {
+            file.data = `${file.data}\n`;
+        }
+    }
+} // }}}
+function fnmatch(filepath, glob) {
+    const matchOptions = { matchBase: true, dot: true, noext: true };
+    return (0, fnmatch_1.default)(filepath, glob, matchOptions);
+} // }}}
+function indentWithSpace(data, size) {
+    const { type, indent } = (0, detect_indent_1.default)(data);
+    if (type === 'space') {
+        if (indent.length === size) {
+            return data;
+        }
+        else {
+            data = data.replace(new RegExp(indent, 'gm'), '\t');
+            const newIndent = ' '.repeat(size);
+            return data.replace(/\t/gm, newIndent);
+        }
+    }
+    else if (type === 'tab') {
+        const newIndent = ' '.repeat(size);
+        return data.replace(new RegExp(indent, 'gm'), newIndent);
+    }
+    else {
+        return data;
+    }
+} // }}}
+function indentWithTab(data) {
+    const { type, indent } = (0, detect_indent_1.default)(data);
+    if (type === 'space') {
+        return data.replace(new RegExp(indent, 'gm'), '\t');
+    }
+    else {
+        return data;
+    }
+} // }}}
+function applyFormatting({ mergedTextFiles, formats }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const file of mergedTextFiles) {
+            for (const format of formats) {
+                if (fnmatch(file.name, format.glob)) {
+                    applyFormat(file, format);
+                    break;
+                }
+            }
+        }
+    });
+}
+exports.applyFormatting = applyFormatting;

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

@@ -0,0 +1,31 @@
+"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.copyBinaryFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+function copyBinaryFiles({ binaryFiles, incomingPath, targetPath, options }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = path_1.default.join(incomingPath, 'configs');
+        for (const file of binaryFiles) {
+            const source = path_1.default.join(cwd, file);
+            const target = path_1.default.join(targetPath, file);
+            yield fs_extra_1.default.copyFile(source, target);
+            if (options.verbose) {
+                console.log(`${file} has been written as a binary file`);
+            }
+        }
+    });
+}
+exports.copyBinaryFiles = copyBinaryFiles;

package/lib/steps/index.js

@@ -0,0 +1,42 @@
+"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.composeSteps = exports.steps = void 0;
+const apply_formatting_1 = require("./apply-formatting");
+const copy_binary_files_1 = require("./copy-binary-files");
+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_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 write_text_files_1 = require("./write-text-files");
+exports.steps = {
+    applyFormatting: apply_formatting_1.applyFormatting,
+    copyBinaryFiles: copy_binary_files_1.copyBinaryFiles,
+    insertFinalNewLine: insert_final_new_line_1.insertFinalNewLine,
+    mergeTextFiles: merge_text_files_1.mergeTextFiles,
+    readEditorConfig: read_editor_config_1.readEditorConfig,
+    readFiles: read_files_1.readFiles,
+    readIncomingPackage: read_incoming_package_1.readIncomingPackage,
+    readTargetConfig: read_target_config_1.readTargetConfig,
+    updateTargetConfig: update_target_config_1.updateTargetConfig,
+    writeTextFiles: write_text_files_1.writeTextFiles,
+};
+function composeSteps(...steps) {
+    return (context) => __awaiter(this, void 0, void 0, function* () {
+        for (const step of steps) {
+            yield step(context);
+        }
+    });
+}
+exports.composeSteps = composeSteps;

package/lib/steps/insert-final-new-line.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.insertFinalNewLine = void 0;
+function insertFinalNewLine({ mergedTextFiles }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const file of mergedTextFiles) {
+            if (file.finalNewLine) {
+                const withFinalNewLine = file.data.endsWith('\n');
+                if (!withFinalNewLine) {
+                    file.data = `${file.data}\n`;
+                }
+            }
+        }
+    });
+}
+exports.insertFinalNewLine = insertFinalNewLine;