@hanseltime/template-repo-sync 2.2.1 → 2.4.0-alpha.0

package/dist/cjs/formatting/infer-json-indent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "inferJSONIndent", {
+    enumerable: true,
+    get: function() {
+        return inferJSONIndent;
+    }
+});
+const spacingRegex = /[{[]\n?(?<spacing>\s+)["tf\d]/;
+function inferJSONIndent(rawJSON) {
+    const match = spacingRegex.exec(rawJSON);
+    if (!match?.groups?.spacing) {
+        // eslint-disable-next-line no-console
+        console.warn(`Could not find json indentation for json string: ${rawJSON.slice(40)} ... \nDefaulting to 4 spaces`);
+        // Four spaces
+        return "    ";
+    }
+    const spacing = match.groups.spacing;
+    // Handle the case where there were multiple newlines before a value
+    const lastNewLine = spacing.lastIndexOf("\n");
+    return match?.groups.spacing.slice(lastNewLine >= 0 ? lastNewLine + 1 : 0);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9mb3JtYXR0aW5nL2luZmVyLWpzb24taW5kZW50LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImNvbnN0IHNwYWNpbmdSZWdleCA9IC9be1tdXFxuPyg/PHNwYWNpbmc+XFxzKylbXCJ0ZlxcZF0vO1xuZXhwb3J0IGZ1bmN0aW9uIGluZmVySlNPTkluZGVudChyYXdKU09OOiBzdHJpbmcpIHtcblx0Y29uc3QgbWF0Y2ggPSBzcGFjaW5nUmVnZXguZXhlYyhyYXdKU09OKTtcblx0aWYgKCFtYXRjaD8uZ3JvdXBzPy5zcGFjaW5nKSB7XG5cdFx0Ly8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnNvbGVcblx0XHRjb25zb2xlLndhcm4oXG5cdFx0XHRgQ291bGQgbm90IGZpbmQganNvbiBpbmRlbnRhdGlvbiBmb3IganNvbiBzdHJpbmc6ICR7cmF3SlNPTi5zbGljZSg0MCl9IC4uLiBcXG5EZWZhdWx0aW5nIHRvIDQgc3BhY2VzYCxcblx0XHQpO1xuXHRcdC8vIEZvdXIgc3BhY2VzXG5cdFx0cmV0dXJuIFwiICAgIFwiO1xuXHR9XG5cdGNvbnN0IHNwYWNpbmcgPSBtYXRjaC5ncm91cHMuc3BhY2luZztcblx0Ly8gSGFuZGxlIHRoZSBjYXNlIHdoZXJlIHRoZXJlIHdlcmUgbXVsdGlwbGUgbmV3bGluZXMgYmVmb3JlIGEgdmFsdWVcblx0Y29uc3QgbGFzdE5ld0xpbmUgPSBzcGFjaW5nLmxhc3RJbmRleE9mKFwiXFxuXCIpO1xuXHRyZXR1cm4gbWF0Y2g/Lmdyb3Vwcy5zcGFjaW5nLnNsaWNlKGxhc3ROZXdMaW5lID49IDAgPyBsYXN0TmV3TGluZSArIDEgOiAwKTtcbn1cbiJdLCJuYW1lcyI6WyJpbmZlckpTT05JbmRlbnQiLCJzcGFjaW5nUmVnZXgiLCJyYXdKU09OIiwibWF0Y2giLCJleGVjIiwiZ3JvdXBzIiwic3BhY2luZyIsImNvbnNvbGUiLCJ3YXJuIiwic2xpY2UiLCJsYXN0TmV3TGluZSIsImxhc3RJbmRleE9mIl0sIm1hcHBpbmdzIjoiOzs7OytCQUNnQkE7OztlQUFBQTs7O0FBRGhCLE1BQU1DLGVBQWU7QUFDZCxTQUFTRCxnQkFBZ0JFLE9BQWU7SUFDOUMsTUFBTUMsUUFBUUYsYUFBYUcsSUFBSSxDQUFDRjtJQUNoQyxJQUFJLENBQUNDLE9BQU9FLFFBQVFDLFNBQVM7UUFDNUIsc0NBQXNDO1FBQ3RDQyxRQUFRQyxJQUFJLENBQ1gsQ0FBQyxpREFBaUQsRUFBRU4sUUFBUU8sS0FBSyxDQUFDLElBQUksNkJBQTZCLENBQUM7UUFFckcsY0FBYztRQUNkLE9BQU87SUFDUjtJQUNBLE1BQU1ILFVBQVVILE1BQU1FLE1BQU0sQ0FBQ0MsT0FBTztJQUNwQyxvRUFBb0U7SUFDcEUsTUFBTUksY0FBY0osUUFBUUssV0FBVyxDQUFDO0lBQ3hDLE9BQU9SLE9BQU9FLE9BQU9DLFFBQVFHLE1BQU1DLGVBQWUsSUFBSUEsY0FBYyxJQUFJO0FBQ3pFIn0=

package/dist/cjs/formatting/infer-json-indent.spec.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _inferjsonindent = require("./infer-json-indent");
+const withNewLine = `{
+
+    "whoa": true,
+    "thing": here,
+    "something": {
+        "nested": false
+    }
+}`;
+const fourSpaces = `{
+    "whoa": true,
+    "thing": here,
+    "something": {
+        "nested": false
+    }
+}`;
+const tabSpaces = `{
+	"whoa": true,
+	"thing": here,
+	"something": {
+		"nested": false
+	}
+}`;
+const twoSpaces = `{
+  "whoa": true,
+  "thing": here,
+  "something": {
+    "nested": false
+  }
+}`;
+describe("inferJSONIndent", ()=>{
+    it("returns spaces when the first indent is spaces with a new line", ()=>{
+        expect((0, _inferjsonindent.inferJSONIndent)(withNewLine)).toBe("    ");
+    });
+    it("returns spaces when the first indent is spaces", ()=>{
+        expect((0, _inferjsonindent.inferJSONIndent)(fourSpaces)).toBe("    ");
+    });
+    it("returns spaces when the first indent is spaces", ()=>{
+        expect((0, _inferjsonindent.inferJSONIndent)(twoSpaces)).toBe("  ");
+    });
+    it("returns tabs when the first indent is a tab", ()=>{
+        expect((0, _inferjsonindent.inferJSONIndent)(tabSpaces)).toBe("\t");
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/formatting/sync-results-to-md.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "syncResultsToMd", {
+    enumerable: true,
+    get: function() {
+        return syncResultsToMd;
+    }
+});
+const _templatesync = require("../template-sync");
+function syncResultsToMd(result) {
+    return `# ${_templatesync.TEMPLATE_SYNC_LOCAL_CONFIG} 
+
+## Stopped the following files from syncing:
+
+${result.localSkipFiles.reduce((s, file)=>{
+        return `${s}* ${file}\n`;
+    }, "")}
+
+## Changed the following files from what they would have synced:
+
+${Object.keys(result.localFileChanges).reduce((s, file)=>{
+        return `${s}${file}
+\`\`\`diff
+${result.localFileChanges[file].reduce((diffS, change)=>{
+            return `${diffS}\n${makeChangeIntoDiffLines(change)}`;
+        }, "")}
+\`\`\``;
+    }, "")}
+
+## Files Modified (${result.modifiedFiles.total})
+
+Added:
+${result.modifiedFiles.added.reduce((s, f)=>{
+        return `${s}\n- ${f}`;
+    }, "")}
+
+Modified:
+${result.modifiedFiles.modified.reduce((s, f)=>{
+        return `${s}\n- ${f}`;
+    }, "")}
+
+Deleted:
+${result.modifiedFiles.deleted.reduce((s, f)=>{
+        return `${s}\n- ${f}`;
+    }, "")}
+`;
+}
+function makeChangeIntoDiffLines(change, nonchangeMax = 3) {
+    const operator = change.added ? "+" : change.removed ? "-" : "";
+    if (!operator && nonchangeMax > 0 && change.count && change.count > nonchangeMax) {
+        const lines = change.value.split("\n");
+        const partial = lines.slice(lines.length - nonchangeMax);
+        return `...\n${partial.join("\n")}\n`;
+    }
+    return change.value.split("\n").reduce((s, line)=>{
+        return `${s}${operator}${line}\n`;
+    }, "");
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/formatting/sync-results-to-md.spec.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _syncresultstomd = require("./sync-results-to-md");
+describe("syncResultsToMd", ()=>{
+    it("snapshots", ()=>{
+        expect((0, _syncresultstomd.syncResultsToMd)({
+            localSkipFiles: [
+                "src/file1.ts"
+            ],
+            localFileChanges: {
+                "package.json": [
+                    {
+                        count: 8,
+                        value: "my thing",
+                        added: true
+                    },
+                    {
+                        count: 10,
+                        value: "your thang",
+                        removed: true
+                    }
+                ]
+            },
+            modifiedFiles: {
+                added: [
+                    "src/something.ts",
+                    "new_settings.toml"
+                ],
+                deleted: [
+                    "TODO.md",
+                    "throwaway.ts"
+                ],
+                modified: [
+                    "something.txt",
+                    ".env"
+                ],
+                total: 6
+            }
+        })).toMatchSnapshot();
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./formatting"), exports);
+_export_star(require("./template-sync"), exports);
+_export_star(require("./types"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9mb3JtYXR0aW5nXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90ZW1wbGF0ZS1zeW5jXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7cUJBQWM7cUJBQ0E7cUJBQ0EifQ==

package/dist/cjs/load-plugin.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "loadPlugin", {
+    enumerable: true,
+    get: function() {
+        return loadPlugin;
+    }
+});
+const _fs = require("fs");
+const _path = require("path");
+const _plugins = require("./plugins");
+async function loadPlugin(mergeConfig, configDir) {
+    if (mergeConfig.plugin.startsWith("_")) {
+        const defaultHandler = Object.values(_plugins.defaultExtensionMap).find((el)=>el.builtinName === mergeConfig.plugin);
+        if (!defaultHandler) {
+            throw new Error(`No builtin merge function supplied for ${mergeConfig.plugin}.  Cannot have merge config without custom plugin supplied.`);
+        }
+        return defaultHandler;
+    }
+    let handler;
+    // First check if this is a local .js file
+    const localPath = (0, _path.resolve)(configDir, mergeConfig.plugin);
+    const importPath = (0, _fs.existsSync)(localPath) ? localPath : mergeConfig.plugin;
+    try {
+        // Sad workaround for testing since dynamic import segfaults
+        if (process.env.JEST_WORKER_ID !== undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            handler = require(importPath);
+        } else {
+            handler = await import(importPath);
+        }
+        if (!handler.merge) {
+            handler = handler.default;
+        }
+    } catch (err) {
+        console.error(err);
+        throw err;
+    }
+    return handler;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/match.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getAllFilesInDir: function() {
+        return getAllFilesInDir;
+    },
+    invertMatchPatterns: function() {
+        return invertMatchPatterns;
+    }
+});
+const _fs = require("fs");
+const _micromatch = require("micromatch");
+const _path = require("path");
+function invertMatchPatterns(patterns) {
+    return patterns.map((pattern)=>{
+        if (pattern.startsWith("!")) {
+            return pattern.slice(1);
+        }
+        return `!${pattern}`;
+    });
+}
+function getAllFilesInDir(dir, ignorePatterns) {
+    return recurseDirsForFiles(dir, ignorePatterns);
+}
+function recurseDirsForFiles(dirpath, ignorePatterns, relativeRoot = "") {
+    return (0, _fs.readdirSync)(dirpath, {
+        withFileTypes: true
+    }).reduce((files, f)=>{
+        const relPath = (0, _path.join)(relativeRoot, f.name);
+        if ((0, _micromatch.some)(relPath, ignorePatterns)) {
+            return files;
+        }
+        // Ensure we aren't ignoring these folders explicitly
+        if (f.isDirectory()) {
+            files.push(...recurseDirsForFiles((0, _path.join)(dirpath, f.name), ignorePatterns, relPath));
+        } else {
+            files.push(relPath);
+        }
+        return files;
+    }, []);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/match.spec.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _path = require("path");
+const _match = require("./match");
+const _testutils = require("./test-utils");
+const TEST_GLOB_DIR = (0, _path.resolve)(_testutils.TEST_FIXTURES_DIR, "glob-test");
+describe("getAllFilesInDir", ()=>{
+    it("gets all files in the directory with no ignores", ()=>{
+        const files = (0, _match.getAllFilesInDir)(TEST_GLOB_DIR, []);
+        expect(files).toEqual(expect.arrayContaining([
+            "folder1/something.js",
+            "folder1/something.ts",
+            "toplevel.js",
+            "toplevel.txt"
+        ]));
+        try {
+            expect(files.length).toBe(4);
+        } catch (err) {
+            console.error("All found files: " + files);
+            throw err;
+        }
+    });
+    it("gets all files in the directory that do not match the ignore (single)", ()=>{
+        const files = (0, _match.getAllFilesInDir)(TEST_GLOB_DIR, [
+            "**/*.ts"
+        ]);
+        expect(files).toEqual(expect.arrayContaining([
+            "folder1/something.js",
+            "toplevel.js",
+            "toplevel.txt"
+        ]));
+        try {
+            expect(files.length).toBe(3);
+        } catch (err) {
+            console.error("All found files: " + files);
+            throw err;
+        }
+    });
+    it("gets all files in the directory that do not match the ignore (multiple)", ()=>{
+        const files = (0, _match.getAllFilesInDir)(TEST_GLOB_DIR, [
+            "**/*.ts",
+            "**/*.txt"
+        ]);
+        expect(files).toEqual(expect.arrayContaining([
+            "folder1/something.js",
+            "toplevel.js"
+        ]));
+        try {
+            expect(files.length).toBe(2);
+        } catch (err) {
+            console.error("All found files: " + files);
+            throw err;
+        }
+    });
+    it("gets all files in the directory that do not match the ignore with a folder level directive (multiple)", ()=>{
+        const files = (0, _match.getAllFilesInDir)(TEST_GLOB_DIR, [
+            "**/*.ts",
+            "**/*.txt",
+            "folder1"
+        ]);
+        expect(files).toEqual(expect.arrayContaining([
+            "toplevel.js"
+        ]));
+        try {
+            expect(files.length).toBe(1);
+        } catch (err) {
+            console.error("All found files: " + files);
+            throw err;
+        }
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/merge-file.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "mergeFile", {
+    enumerable: true,
+    get: function() {
+        return mergeFile;
+    }
+});
+const _diff = require("diff");
+const _fs = require("fs");
+const _promises = require("fs/promises");
+const _fsextra = require("fs-extra");
+const _micromatch = require("micromatch");
+const _path = require("path");
+const _loadplugin = require("./load-plugin");
+async function mergeFile(relPath, context) {
+    const { localTemplateSyncConfig, templateSyncConfig, tempCloneDir, cwd } = context;
+    if ((0, _micromatch.some)(relPath, localTemplateSyncConfig.ignore)) {
+        return {
+            ignoredDueToLocal: true
+        };
+    }
+    const ext = (0, _path.extname)(relPath);
+    const filePath = (0, _path.join)(cwd, relPath);
+    const templatePath = (0, _path.join)(tempCloneDir, relPath);
+    // Unless there's a need, we remove files that were deleted and don't pass them to plugins yet
+    if (context.fileOperation === "deleted") {
+        if ((0, _fs.existsSync)(filePath)) {
+            await (0, _promises.rm)(filePath);
+        }
+        return {
+            ignoredDueToLocal: false,
+            localChanges: []
+        };
+    }
+    const mergeConfig = templateSyncConfig.merge?.find((mc)=>(0, _micromatch.isMatch)(relPath, mc.glob));
+    const localMergeConfig = localTemplateSyncConfig.merge?.find((mc)=>(0, _micromatch.isMatch)(relPath, mc.glob));
+    const mergeHandler = mergeConfig ? await (0, _loadplugin.loadPlugin)(mergeConfig, tempCloneDir) : undefined;
+    const localMergeHandler = localMergeConfig ? await (0, _loadplugin.loadPlugin)(localMergeConfig, cwd) : undefined;
+    // Either write the merge or write the file
+    let fileContents;
+    const localChanges = [];
+    if ((0, _fs.existsSync)(filePath) && (mergeHandler || localMergeHandler)) {
+        const originalCurrentFile = (await (0, _promises.readFile)(filePath)).toString();
+        if (mergeHandler) {
+            fileContents = await safeMerge(mergeHandler, mergeConfig?.plugin ?? `default for ${ext}`, originalCurrentFile, (await (0, _promises.readFile)(templatePath)).toString(), {
+                relFilePath: relPath,
+                mergeArguments: mergeConfig?.options ?? {},
+                isLocalOptions: false
+            });
+        } else {
+            // Apply overwrite if we didn't set up merge
+            fileContents = (await (0, _promises.readFile)(templatePath)).toString();
+        }
+        // We apply the localMerge Config to the fileContent output by the template merge
+        if (localMergeHandler) {
+            const localContents = await safeMerge(localMergeHandler, localMergeConfig?.plugin ?? `default for ${ext}`, originalCurrentFile, fileContents, {
+                relFilePath: relPath,
+                mergeArguments: localMergeConfig?.options ?? {},
+                isLocalOptions: true
+            });
+            localChanges.push(...(0, _diff.diffLines)(fileContents, localContents));
+            fileContents = localContents;
+        }
+    } else {
+        // Just perform simple overwrite
+        fileContents = (await (0, _promises.readFile)(templatePath)).toString();
+    }
+    await (0, _fsextra.outputFile)(filePath, fileContents);
+    return {
+        ignoredDueToLocal: false,
+        localChanges
+    };
+}
+/**
+ * Simple helper function to ensure that we don't let bad plugins corrupt the call flow
+ * @param plugin
+ */ async function safeMerge(plugin, pluginPath, current, fromTemplate, context) {
+    const ret = await plugin.merge(current, fromTemplate, context);
+    if (typeof ret !== "string") {
+        throw new Error(`Plugin ${pluginPath} did not return string for merge function!  This is not allowed!`);
+    }
+    if (!ret) {
+        throw new Error(`Plugin ${pluginPath} should not make a merge be an empty string!`);
+    }
+    return ret;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/merge-file.ts"],"sourcesContent":["import type { Change } from \"diff\";\nimport { diffLines } from \"diff\";\nimport { existsSync } from \"fs\";\nimport { readFile, rm } from \"fs/promises\";\nimport { outputFile } from \"fs-extra\";\nimport { isMatch, some } from \"micromatch\";\nimport { extname, join } from \"path\";\nimport { loadPlugin } from \"./load-plugin\";\nimport type { Config, FileOperation, MergeContext, MergePlugin } from \"./types\";\n\ninterface MergeFileOptions {\n\tlocalTemplateSyncConfig: Config;\n\ttemplateSyncConfig: Config;\n\ttempCloneDir: string;\n\tcwd: string;\n\tfileOperation: FileOperation;\n}\n\ninterface MergeFileReturn {\n\t/**\n\t * If the file was ignored due to the local config\n\t */\n\tignoredDueToLocal: boolean;\n\t/**\n\t * Only available if the file wasn't ignored, this is a list of lineDiffs\n\t * from the diff library that were applied to what would've been changed by\n\t * the base templatesync repo\n\t */\n\tlocalChanges?: Change[];\n}\n\n/**\n * Applies the merge to a file according to the context information.\n *\n * Returns true if merged and false if skipped\n * @param relPath\n * @param context\n * @returns\n */\nexport async function mergeFile(\n\trelPath: string,\n\tcontext: MergeFileOptions,\n): Promise<MergeFileReturn> {\n\tconst { localTemplateSyncConfig, templateSyncConfig, tempCloneDir, cwd } =\n\t\tcontext;\n\n\tif (some(relPath, localTemplateSyncConfig.ignore)) {\n\t\treturn {\n\t\t\tignoredDueToLocal: true,\n\t\t};\n\t}\n\n\tconst ext = extname(relPath);\n\tconst filePath = join(cwd, relPath);\n\tconst templatePath = join(tempCloneDir, relPath);\n\n\t// Unless there's a need, we remove files that were deleted and don't pass them to plugins yet\n\tif (context.fileOperation === \"deleted\") {\n\t\tif (existsSync(filePath)) {\n\t\t\tawait rm(filePath);\n\t\t}\n\t\treturn {\n\t\t\tignoredDueToLocal: false,\n\t\t\tlocalChanges: [],\n\t\t};\n\t}\n\n\tconst mergeConfig = templateSyncConfig.merge?.find((mc) =>\n\t\tisMatch(relPath, mc.glob),\n\t);\n\tconst localMergeConfig = localTemplateSyncConfig.merge?.find((mc) =>\n\t\tisMatch(relPath, mc.glob),\n\t);\n\n\tconst mergeHandler = mergeConfig\n\t\t? await loadPlugin(mergeConfig, tempCloneDir)\n\t\t: undefined;\n\tconst localMergeHandler = localMergeConfig\n\t\t? await loadPlugin(localMergeConfig, cwd)\n\t\t: undefined;\n\n\t// Either write the merge or write the file\n\tlet fileContents: string;\n\tconst localChanges: Change[] = [];\n\tif (existsSync(filePath) && (mergeHandler || localMergeHandler)) {\n\t\tconst originalCurrentFile = (await readFile(filePath)).toString();\n\t\tif (mergeHandler) {\n\t\t\tfileContents = await safeMerge(\n\t\t\t\tmergeHandler,\n\t\t\t\tmergeConfig?.plugin ?? `default for ${ext}`,\n\t\t\t\toriginalCurrentFile,\n\t\t\t\t(await readFile(templatePath)).toString(),\n\t\t\t\t{\n\t\t\t\t\trelFilePath: relPath,\n\t\t\t\t\tmergeArguments: mergeConfig?.options ?? {},\n\t\t\t\t\tisLocalOptions: false,\n\t\t\t\t},\n\t\t\t);\n\t\t} else {\n\t\t\t// Apply overwrite if we didn't set up merge\n\t\t\tfileContents = (await readFile(templatePath)).toString();\n\t\t}\n\n\t\t// We apply the localMerge Config to the fileContent output by the template merge\n\t\tif (localMergeHandler) {\n\t\t\tconst localContents = await safeMerge(\n\t\t\t\tlocalMergeHandler,\n\t\t\t\tlocalMergeConfig?.plugin ?? `default for ${ext}`,\n\t\t\t\toriginalCurrentFile,\n\t\t\t\tfileContents,\n\t\t\t\t{\n\t\t\t\t\trelFilePath: relPath,\n\t\t\t\t\tmergeArguments: localMergeConfig?.options ?? {},\n\t\t\t\t\tisLocalOptions: true,\n\t\t\t\t},\n\t\t\t);\n\t\t\tlocalChanges.push(...diffLines(fileContents, localContents));\n\t\t\tfileContents = localContents;\n\t\t}\n\t} else {\n\t\t// Just perform simple overwrite\n\t\tfileContents = (await readFile(templatePath)).toString();\n\t}\n\tawait outputFile(filePath, fileContents);\n\treturn {\n\t\tignoredDueToLocal: false,\n\t\tlocalChanges,\n\t};\n}\n\n/**\n * Simple helper function to ensure that we don't let bad plugins corrupt the call flow\n * @param plugin\n */\nasync function safeMerge(\n\tplugin: MergePlugin<unknown>,\n\tpluginPath: string,\n\tcurrent: string,\n\tfromTemplate: string,\n\tcontext: MergeContext,\n) {\n\tconst ret = await plugin.merge(current, fromTemplate, context);\n\tif (typeof ret !== \"string\") {\n\t\tthrow new Error(\n\t\t\t`Plugin ${pluginPath} did not return string for merge function!  This is not allowed!`,\n\t\t);\n\t}\n\n\tif (!ret) {\n\t\tthrow new Error(\n\t\t\t`Plugin ${pluginPath} should not make a merge be an empty string!`,\n\t\t);\n\t}\n\treturn ret as string;\n}\n"],"names":["mergeFile","relPath","context","localTemplateSyncConfig","templateSyncConfig","tempCloneDir","cwd","some","ignore","ignoredDueToLocal","ext","extname","filePath","join","templatePath","fileOperation","existsSync","rm","localChanges","mergeConfig","merge","find","mc","isMatch","glob","localMergeConfig","mergeHandler","loadPlugin","undefined","localMergeHandler","fileContents","originalCurrentFile","readFile","toString","safeMerge","plugin","relFilePath","mergeArguments","options","isLocalOptions","localContents","push","diffLines","outputFile","pluginPath","current","fromTemplate","ret","Error"],"mappings":"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"}