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

package/dist/esm/merge-file.spec.mjs

@@ -0,0 +1,504 @@
+import { existsSync } from "fs";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { copySync } from "fs-extra";
+import { join, resolve } from "path";
+import { mergeFile } from "./merge-file.mjs";
+import { TEST_FIXTURES_DIR, tempDir } from "./test-utils/index.mjs";
+const testTemplateDir = resolve(TEST_FIXTURES_DIR, "template");
+const testDownstreamDir = resolve(TEST_FIXTURES_DIR, "downstream");
+describe("mergeFile", ()=>{
+    let tmpDir;
+    let tmpTemplateDir;
+    beforeEach(async ()=>{
+        tmpDir = await mkdtemp(tempDir());
+        copySync(testDownstreamDir, tmpDir);
+        tmpTemplateDir = await mkdtemp(tempDir());
+        copySync(testTemplateDir, tmpTemplateDir);
+    });
+    afterEach(async ()=>{
+        await rm(tmpDir, {
+            force: true,
+            recursive: true
+        });
+        await rm(tmpTemplateDir, {
+            force: true,
+            recursive: true
+        });
+    });
+    // Note: we use the "ignore" from the templateSync to constrain files we iterate over so it doeesn't happen here
+    // it('skips the file if it is part of template config ignroe', async () => {
+    //     expect(await mergeFile('package.json', {
+    //         cwd: tmpDir,
+    //         tempCloneDir: testTemplateDir,
+    //         localTemplateSyncConfig: {
+    //             ignore: [],
+    //             merge: {
+    //             }
+    //         },
+    //         templateSyncConfig: {
+    //             ignore: ['**/package.json'],
+    //         }
+    //     })).toBe(false)
+    // })
+    it.each([
+        [
+            "added"
+        ],
+        [
+            "deleted"
+        ],
+        [
+            "modified"
+        ]
+    ])("skips the [%s] file if it is part of local config ignore", async (op)=>{
+        expect(await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: tmpTemplateDir,
+            localTemplateSyncConfig: {
+                ignore: [
+                    "**/package.json"
+                ],
+                merge: []
+            },
+            templateSyncConfig: {
+                ignore: [
+                    "**/*.txt"
+                ]
+            },
+            fileOperation: op
+        })).toEqual({
+            ignoredDueToLocal: true
+        });
+    });
+    it.each([
+        [
+            "added"
+        ],
+        [
+            "modified"
+        ]
+    ])("overwrites if no merge config for [%s] files", async (op)=>{
+        expect(await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: tmpTemplateDir,
+            localTemplateSyncConfig: {
+                ignore: []
+            },
+            templateSyncConfig: {
+                ignore: [
+                    "**/*.txt"
+                ]
+            },
+            fileOperation: op
+        })).toEqual({
+            ignoredDueToLocal: false,
+            localChanges: []
+        });
+        // Ensure we overwrote
+        expect(await readFile(join(tmpDir, "package.json"))).toEqual(await readFile(join(tmpTemplateDir, "package.json")));
+    });
+    it("removes the template deleted files", async ()=>{
+        expect(await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: tmpTemplateDir,
+            localTemplateSyncConfig: {
+                ignore: []
+            },
+            templateSyncConfig: {
+                ignore: [
+                    "**/*.txt"
+                ]
+            },
+            fileOperation: "deleted"
+        })).toEqual({
+            ignoredDueToLocal: false,
+            localChanges: []
+        });
+        // Ensure we overwrote
+        expect(existsSync(join(tmpDir, "package.json"))).toBeFalsy();
+    });
+    // TODO - this could change if there's a use case
+    it("does not apply plugins on deleted", async ()=>{
+        expect(await mergeFile("package.json", {
+            cwd: tmpDir,
+            tempCloneDir: tmpTemplateDir,
+            localTemplateSyncConfig: {
+                ignore: [],
+                merge: [
+                    {
+                        plugin: "_json",
+                        glob: "**/package.json",
+                        options: {
+                            paths: [
+                                // Do not touch huh
+                                [
+                                    "$.dependencies.huh",
+                                    "merge-current"
+                                ]
+                            ]
+                        }
+                    }
+                ]
+            },
+            templateSyncConfig: {
+                ignore: [
+                    "**/*.txt"
+                ],
+                merge: [
+                    {
+                        glob: "**/package.json",
+                        plugin: "_json",
+                        options: {
+                            missingIsDelete: true,
+                            paths: [
+                                // Merge all template dependencies
+                                [
+                                    "$.dependencies",
+                                    "merge-template"
+                                ]
+                            ]
+                        }
+                    }
+                ]
+            },
+            fileOperation: "deleted"
+        })).toEqual({
+            ignoredDueToLocal: false,
+            localChanges: []
+        });
+        // Ensure we overwrote
+        expect(existsSync(join(tmpDir, "package.json"))).toBeFalsy();
+    });
+    describe.each([
+        [
+            "added"
+        ],
+        [
+            "modified"
+        ]
+    ])("[%s] file", (op)=>{
+        // Yea... these are more integration tests but I'm kinda untrusting of mocks for this
+        it("applies default [.json] merge with first rules if merge applies to file", async ()=>{
+            expect(await mergeFile("package.json", {
+                cwd: tmpDir,
+                tempCloneDir: testTemplateDir,
+                localTemplateSyncConfig: {
+                    ignore: []
+                },
+                fileOperation: op,
+                templateSyncConfig: {
+                    ignore: [
+                        "**/*.txt"
+                    ],
+                    merge: [
+                        {
+                            glob: "**/package.json",
+                            options: "merge-current",
+                            plugin: "_json"
+                        },
+                        {
+                            glob: "**/package.json",
+                            options: "merge-template",
+                            plugin: "_json"
+                        }
+                    ]
+                }
+            })).toEqual({
+                ignoredDueToLocal: false,
+                localChanges: []
+            });
+            // Ensure we overwrote
+            expect(JSON.parse((await readFile(join(tmpDir, "package.json"))).toString())).toEqual({
+                name: "mypkg",
+                description: "my description",
+                dependencies: {
+                    mypackage: "^1.2.0",
+                    newpacakge: "^22.2.2",
+                    package2: "3.22.1",
+                    huh: "^2.30.0"
+                },
+                engines: {
+                    node: ">=20"
+                },
+                scripts: {
+                    build: "build",
+                    test: "jest",
+                    myscript: "somescript"
+                },
+                version: "new-version"
+            });
+        });
+        it("[inverse] applies default [.json] merge with first rules if merge applies to file", async ()=>{
+            expect(await mergeFile("package.json", {
+                cwd: tmpDir,
+                tempCloneDir: testTemplateDir,
+                localTemplateSyncConfig: {
+                    ignore: []
+                },
+                fileOperation: op,
+                templateSyncConfig: {
+                    ignore: [
+                        "**/*.txt"
+                    ],
+                    merge: [
+                        {
+                            glob: "**/package.json",
+                            options: "merge-template",
+                            plugin: "_json"
+                        },
+                        {
+                            glob: "**/package.json",
+                            options: "merge-current",
+                            plugin: "_json"
+                        }
+                    ]
+                }
+            })).toEqual({
+                ignoredDueToLocal: false,
+                localChanges: []
+            });
+            // Ensure we overwrote
+            expect(JSON.parse((await readFile(join(tmpDir, "package.json"))).toString())).toEqual({
+                name: "some-stub-name",
+                description: "some-stub-description",
+                dependencies: {
+                    mypackage: "^1.2.0",
+                    newpacakge: "^22.2.2",
+                    package2: "3.22.1",
+                    huh: "~1.0.0"
+                },
+                engines: {
+                    node: ">=15"
+                },
+                scripts: {
+                    build: "build",
+                    test: "fill this in yourself",
+                    myscript: "somescript"
+                },
+                version: "new-version"
+            });
+        });
+        it("[inverse] applies default [.json] merge with sync and then local override", async ()=>{
+            expect(await mergeFile("package.json", {
+                cwd: tmpDir,
+                tempCloneDir: testTemplateDir,
+                fileOperation: op,
+                localTemplateSyncConfig: {
+                    ignore: [],
+                    merge: [
+                        {
+                            plugin: "_json",
+                            glob: "**/package.json",
+                            options: {
+                                paths: [
+                                    // Do not touch huh
+                                    [
+                                        "$.dependencies.huh",
+                                        "merge-current"
+                                    ]
+                                ]
+                            }
+                        }
+                    ]
+                },
+                templateSyncConfig: {
+                    ignore: [
+                        "**/*.txt"
+                    ],
+                    merge: [
+                        {
+                            glob: "**/package.json",
+                            plugin: "_json",
+                            options: {
+                                missingIsDelete: true,
+                                paths: [
+                                    // Merge all template dependencies
+                                    [
+                                        "$.dependencies",
+                                        "merge-template"
+                                    ]
+                                ]
+                            }
+                        }
+                    ]
+                }
+            })).toEqual({
+                ignoredDueToLocal: false,
+                localChanges: expect.arrayContaining([
+                    {
+                        added: undefined,
+                        count: 1,
+                        removed: true,
+                        value: '\t\t"huh": "~1.0.0"\n'
+                    },
+                    {
+                        added: true,
+                        count: 1,
+                        removed: undefined,
+                        value: '\t\t"huh": "^2.30.0"\n'
+                    }
+                ])
+            });
+            // Ensure we overwrote
+            expect(JSON.parse((await readFile(join(tmpDir, "package.json"))).toString())).toEqual({
+                name: "mypkg",
+                description: "my description",
+                dependencies: {
+                    mypackage: "^1.2.0",
+                    newpacakge: "^22.2.2",
+                    package2: "3.22.1",
+                    huh: "^2.30.0"
+                },
+                engines: {
+                    node: ">=20"
+                },
+                scripts: {
+                    build: "build",
+                    test: "jest",
+                    myscript: "somescript"
+                },
+                version: "new-version"
+            });
+        });
+        it("[inverse] applies default [.json] and custom merge for local with sync and then local override", async ()=>{
+            expect(await mergeFile("package.json", {
+                cwd: tmpDir,
+                tempCloneDir: testTemplateDir,
+                fileOperation: op,
+                localTemplateSyncConfig: {
+                    ignore: [],
+                    merge: [
+                        {
+                            plugin: "../test-fixtures/dummy-plugin.js",
+                            options: {
+                                paths: [
+                                    // Do not touch huh
+                                    [
+                                        "$.dependencies.huh",
+                                        "merge-current"
+                                    ]
+                                ]
+                            },
+                            glob: "**/package.json"
+                        }
+                    ]
+                },
+                templateSyncConfig: {
+                    ignore: [
+                        "**/*.txt"
+                    ],
+                    merge: [
+                        {
+                            plugin: "_json",
+                            glob: "**/package.json",
+                            options: {
+                                missingIsDelete: true,
+                                paths: [
+                                    // Merge all template dependencies
+                                    [
+                                        "$.dependencies",
+                                        "merge-template"
+                                    ]
+                                ]
+                            }
+                        }
+                    ]
+                }
+            })).toEqual({
+                ignoredDueToLocal: false,
+                // TODO: I don't
+                localChanges: expect.arrayContaining([
+                    {
+                        added: undefined,
+                        count: 17,
+                        removed: true,
+                        value: `\t"name": "mypkg",
+\t"description": "my description",
+\t"dependencies": {
+\t\t"mypackage": "^1.2.0",
+\t\t"newpacakge": "^22.2.2",
+\t\t"package2": "3.22.1",
+\t\t"huh": "~1.0.0"
+\t},
+\t"engines": {
+\t\t"node": ">=20"
+\t},
+\t"scripts": {
+\t\t"build": "build",
+\t\t"test": "jest",
+\t\t"myscript": "somescript"
+\t},
+\t"version": "new-version"\n`
+                    },
+                    {
+                        added: true,
+                        count: 1,
+                        removed: undefined,
+                        value: `    "tested": true\n`
+                    }
+                ])
+            });
+            // Ensure we overwrote
+            expect(JSON.parse((await readFile(join(tmpDir, "package.json"))).toString())).toEqual({
+                tested: true
+            });
+        });
+        it("[inverse] applies builtin _json and custom merge for local with sync plugin and then local override", async ()=>{
+            expect(await mergeFile("package.json", {
+                cwd: tmpDir,
+                tempCloneDir: testTemplateDir,
+                fileOperation: op,
+                localTemplateSyncConfig: {
+                    ignore: [],
+                    merge: [
+                        {
+                            glob: "**/package.json",
+                            plugin: "plugins/custom-plugin.js",
+                            options: {
+                                paths: [
+                                    // Do not touch huh
+                                    [
+                                        "$.dependencies.huh",
+                                        "merge-current"
+                                    ]
+                                ]
+                            }
+                        }
+                    ]
+                },
+                templateSyncConfig: {
+                    ignore: [
+                        "**/*.txt"
+                    ],
+                    merge: [
+                        {
+                            glob: "**/package.json",
+                            // TODO - we need to handle the weird implicit case I added here.  It's dumb
+                            options: {
+                                missingIsDelete: true,
+                                paths: [
+                                    // Merge all template dependencies
+                                    [
+                                        "$.dependencies",
+                                        "merge-template"
+                                    ]
+                                ]
+                            },
+                            plugin: "_json"
+                        }
+                    ]
+                }
+            })).toEqual({
+                ignoredDueToLocal: false,
+                // We are just making sure plugin look up happens here
+                localChanges: expect.arrayContaining([])
+            });
+            // Ensure we overwrote
+            expect(JSON.parse((await readFile(join(tmpDir, "package.json"))).toString())).toEqual({
+                downstream: true
+            });
+        });
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/merge-file.spec.ts"],"sourcesContent":["import { existsSync } from \"fs\";\nimport { mkdtemp, readFile, rm } from \"fs/promises\";\nimport { copySync } from \"fs-extra\";\nimport { join, resolve } from \"path\";\nimport { mergeFile } from \"./merge-file\";\nimport { TEST_FIXTURES_DIR, tempDir } from \"./test-utils\";\nimport type { FileOperation, JsonFileMergeOptions } from \"./types\";\n\nconst testTemplateDir = resolve(TEST_FIXTURES_DIR, \"template\");\nconst testDownstreamDir = resolve(TEST_FIXTURES_DIR, \"downstream\");\n\ndescribe(\"mergeFile\", () => {\n\tlet tmpDir: string;\n\tlet tmpTemplateDir: string;\n\tbeforeEach(async () => {\n\t\ttmpDir = await mkdtemp(tempDir());\n\t\tcopySync(testDownstreamDir, tmpDir);\n\t\ttmpTemplateDir = await mkdtemp(tempDir());\n\t\tcopySync(testTemplateDir, tmpTemplateDir);\n\t});\n\tafterEach(async () => {\n\t\tawait rm(tmpDir, {\n\t\t\tforce: true,\n\t\t\trecursive: true,\n\t\t});\n\t\tawait rm(tmpTemplateDir, {\n\t\t\tforce: true,\n\t\t\trecursive: true,\n\t\t});\n\t});\n\t// Note: we use the \"ignore\" from the templateSync to constrain files we iterate over so it doeesn't happen here\n\t// it('skips the file if it is part of template config ignroe', async () => {\n\t//     expect(await mergeFile('package.json', {\n\t//         cwd: tmpDir,\n\t//         tempCloneDir: testTemplateDir,\n\t//         localTemplateSyncConfig: {\n\t//             ignore: [],\n\t//             merge: {\n\t//             }\n\t//         },\n\t//         templateSyncConfig: {\n\t//             ignore: ['**/package.json'],\n\t//         }\n\t//     })).toBe(false)\n\t// })\n\tit.each([\n\t\t[\"added\"],\n\t\t[\"deleted\"],\n\t\t[\"modified\"],\n\t])(\"skips the [%s] file if it is part of local config ignore\", async (op) => {\n\t\texpect(\n\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\tcwd: tmpDir,\n\t\t\t\ttempCloneDir: tmpTemplateDir,\n\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\tignore: [\"**/package.json\"],\n\t\t\t\t\tmerge: [],\n\t\t\t\t},\n\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t},\n\t\t\t\tfileOperation: op as FileOperation,\n\t\t\t}),\n\t\t).toEqual({\n\t\t\tignoredDueToLocal: true,\n\t\t});\n\t});\n\tit.each([\n\t\t[\"added\"],\n\t\t[\"modified\"],\n\t])(\"overwrites if no merge config for [%s] files\", async (op) => {\n\t\texpect(\n\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\tcwd: tmpDir,\n\t\t\t\ttempCloneDir: tmpTemplateDir,\n\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\tignore: [],\n\t\t\t\t},\n\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t},\n\t\t\t\tfileOperation: op as FileOperation,\n\t\t\t}),\n\t\t).toEqual({\n\t\t\tignoredDueToLocal: false,\n\t\t\tlocalChanges: [],\n\t\t});\n\n\t\t// Ensure we overwrote\n\t\texpect(await readFile(join(tmpDir, \"package.json\"))).toEqual(\n\t\t\tawait readFile(join(tmpTemplateDir, \"package.json\")),\n\t\t);\n\t});\n\tit(\"removes the template deleted files\", async () => {\n\t\texpect(\n\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\tcwd: tmpDir,\n\t\t\t\ttempCloneDir: tmpTemplateDir,\n\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\tignore: [],\n\t\t\t\t},\n\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t},\n\t\t\t\tfileOperation: \"deleted\", // This is normally inferred by the top-level code\n\t\t\t}),\n\t\t).toEqual({\n\t\t\tignoredDueToLocal: false,\n\t\t\tlocalChanges: [],\n\t\t});\n\n\t\t// Ensure we overwrote\n\t\texpect(existsSync(join(tmpDir, \"package.json\"))).toBeFalsy();\n\t});\n\n\t// TODO - this could change if there's a use case\n\tit(\"does not apply plugins on deleted\", async () => {\n\t\texpect(\n\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\tcwd: tmpDir,\n\t\t\t\ttempCloneDir: tmpTemplateDir,\n\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\tignore: [],\n\t\t\t\t\tmerge: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t\t// Do not touch huh\n\t\t\t\t\t\t\t\t\t[\"$.dependencies.huh\", \"merge-current\"],\n\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t},\n\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t\tmerge: [\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\t\tmissingIsDelete: true,\n\t\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t\t// Merge all template dependencies\n\t\t\t\t\t\t\t\t\t[\"$.dependencies\", \"merge-template\"],\n\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t} as JsonFileMergeOptions,\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t},\n\t\t\t\tfileOperation: \"deleted\", // This is normally inferred by the top-level code\n\t\t\t}),\n\t\t).toEqual({\n\t\t\tignoredDueToLocal: false,\n\t\t\tlocalChanges: [],\n\t\t});\n\n\t\t// Ensure we overwrote\n\t\texpect(existsSync(join(tmpDir, \"package.json\"))).toBeFalsy();\n\t});\n\n\tdescribe.each([\n\t\t[\"added\" as FileOperation],\n\t\t[\"modified\" as FileOperation],\n\t])(\"[%s] file\", (op: FileOperation) => {\n\t\t// Yea... these are more integration tests but I'm kinda untrusting of mocks for this\n\t\tit(\"applies default [.json] merge with first rules if merge applies to file\", async () => {\n\t\t\texpect(\n\t\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\t\tcwd: tmpDir,\n\t\t\t\t\ttempCloneDir: testTemplateDir,\n\t\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\t\tignore: [],\n\t\t\t\t\t},\n\t\t\t\t\tfileOperation: op,\n\t\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t\t\tmerge: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\toptions: \"merge-current\",\n\t\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\toptions: \"merge-template\",\n\t\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t).toEqual({\n\t\t\t\tignoredDueToLocal: false,\n\t\t\t\tlocalChanges: [],\n\t\t\t});\n\n\t\t\t// Ensure we overwrote\n\t\t\texpect(\n\t\t\t\tJSON.parse((await readFile(join(tmpDir, \"package.json\"))).toString()),\n\t\t\t).toEqual({\n\t\t\t\tname: \"mypkg\",\n\t\t\t\tdescription: \"my description\",\n\t\t\t\tdependencies: {\n\t\t\t\t\tmypackage: \"^1.2.0\",\n\t\t\t\t\tnewpacakge: \"^22.2.2\",\n\t\t\t\t\tpackage2: \"3.22.1\",\n\t\t\t\t\thuh: \"^2.30.0\",\n\t\t\t\t},\n\t\t\t\tengines: {\n\t\t\t\t\tnode: \">=20\",\n\t\t\t\t},\n\t\t\t\tscripts: {\n\t\t\t\t\tbuild: \"build\",\n\t\t\t\t\ttest: \"jest\",\n\t\t\t\t\tmyscript: \"somescript\",\n\t\t\t\t},\n\t\t\t\tversion: \"new-version\",\n\t\t\t});\n\t\t});\n\t\tit(\"[inverse] applies default [.json] merge with first rules if merge applies to file\", async () => {\n\t\t\texpect(\n\t\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\t\tcwd: tmpDir,\n\t\t\t\t\ttempCloneDir: testTemplateDir,\n\t\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\t\tignore: [],\n\t\t\t\t\t},\n\t\t\t\t\tfileOperation: op,\n\t\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t\t\tmerge: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\toptions: \"merge-template\",\n\t\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\toptions: \"merge-current\",\n\t\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t).toEqual({\n\t\t\t\tignoredDueToLocal: false,\n\t\t\t\tlocalChanges: [],\n\t\t\t});\n\n\t\t\t// Ensure we overwrote\n\t\t\texpect(\n\t\t\t\tJSON.parse((await readFile(join(tmpDir, \"package.json\"))).toString()),\n\t\t\t).toEqual({\n\t\t\t\tname: \"some-stub-name\",\n\t\t\t\tdescription: \"some-stub-description\",\n\t\t\t\tdependencies: {\n\t\t\t\t\tmypackage: \"^1.2.0\",\n\t\t\t\t\tnewpacakge: \"^22.2.2\",\n\t\t\t\t\tpackage2: \"3.22.1\",\n\t\t\t\t\thuh: \"~1.0.0\",\n\t\t\t\t},\n\t\t\t\tengines: {\n\t\t\t\t\tnode: \">=15\",\n\t\t\t\t},\n\t\t\t\tscripts: {\n\t\t\t\t\tbuild: \"build\",\n\t\t\t\t\ttest: \"fill this in yourself\",\n\t\t\t\t\tmyscript: \"somescript\",\n\t\t\t\t},\n\t\t\t\tversion: \"new-version\",\n\t\t\t});\n\t\t});\n\t\tit(\"[inverse] applies default [.json] merge with sync and then local override\", async () => {\n\t\t\texpect(\n\t\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\t\tcwd: tmpDir,\n\t\t\t\t\ttempCloneDir: testTemplateDir,\n\t\t\t\t\tfileOperation: op,\n\t\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\t\tignore: [],\n\t\t\t\t\t\tmerge: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t\t\t// Do not touch huh\n\t\t\t\t\t\t\t\t\t\t[\"$.dependencies.huh\", \"merge-current\"],\n\t\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t\t\tmerge: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\t\t\tmissingIsDelete: true,\n\t\t\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t\t\t// Merge all template dependencies\n\t\t\t\t\t\t\t\t\t\t[\"$.dependencies\", \"merge-template\"],\n\t\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t\t} as JsonFileMergeOptions,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t).toEqual({\n\t\t\t\tignoredDueToLocal: false,\n\t\t\t\tlocalChanges: expect.arrayContaining([\n\t\t\t\t\t{\n\t\t\t\t\t\tadded: undefined,\n\t\t\t\t\t\tcount: 1,\n\t\t\t\t\t\tremoved: true,\n\t\t\t\t\t\tvalue: '\\t\\t\"huh\": \"~1.0.0\"\\n',\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tadded: true,\n\t\t\t\t\t\tcount: 1,\n\t\t\t\t\t\tremoved: undefined,\n\t\t\t\t\t\tvalue: '\\t\\t\"huh\": \"^2.30.0\"\\n',\n\t\t\t\t\t},\n\t\t\t\t]),\n\t\t\t});\n\n\t\t\t// Ensure we overwrote\n\t\t\texpect(\n\t\t\t\tJSON.parse((await readFile(join(tmpDir, \"package.json\"))).toString()),\n\t\t\t).toEqual({\n\t\t\t\tname: \"mypkg\",\n\t\t\t\tdescription: \"my description\",\n\t\t\t\tdependencies: {\n\t\t\t\t\tmypackage: \"^1.2.0\",\n\t\t\t\t\tnewpacakge: \"^22.2.2\",\n\t\t\t\t\tpackage2: \"3.22.1\",\n\t\t\t\t\thuh: \"^2.30.0\",\n\t\t\t\t},\n\t\t\t\tengines: {\n\t\t\t\t\tnode: \">=20\",\n\t\t\t\t},\n\t\t\t\tscripts: {\n\t\t\t\t\tbuild: \"build\",\n\t\t\t\t\ttest: \"jest\",\n\t\t\t\t\tmyscript: \"somescript\",\n\t\t\t\t},\n\t\t\t\tversion: \"new-version\",\n\t\t\t});\n\t\t});\n\t\tit(\"[inverse] applies default [.json] and custom merge for local with sync and then local override\", async () => {\n\t\t\texpect(\n\t\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\t\tcwd: tmpDir,\n\t\t\t\t\ttempCloneDir: testTemplateDir,\n\t\t\t\t\tfileOperation: op,\n\t\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\t\tignore: [],\n\t\t\t\t\t\tmerge: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tplugin: \"../test-fixtures/dummy-plugin.js\",\n\t\t\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t\t\t// Do not touch huh\n\t\t\t\t\t\t\t\t\t\t[\"$.dependencies.huh\", \"merge-current\"],\n\t\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t\t\tmerge: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\t\t\tmissingIsDelete: true,\n\t\t\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t\t\t// Merge all template dependencies\n\t\t\t\t\t\t\t\t\t\t[\"$.dependencies\", \"merge-template\"],\n\t\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t\t} as JsonFileMergeOptions,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t).toEqual({\n\t\t\t\tignoredDueToLocal: false,\n\t\t\t\t// TODO: I don't\n\t\t\t\tlocalChanges: expect.arrayContaining([\n\t\t\t\t\t{\n\t\t\t\t\t\tadded: undefined,\n\t\t\t\t\t\tcount: 17,\n\t\t\t\t\t\tremoved: true,\n\t\t\t\t\t\tvalue: `\\t\"name\": \"mypkg\",\n\\t\"description\": \"my description\",\n\\t\"dependencies\": {\n\\t\\t\"mypackage\": \"^1.2.0\",\n\\t\\t\"newpacakge\": \"^22.2.2\",\n\\t\\t\"package2\": \"3.22.1\",\n\\t\\t\"huh\": \"~1.0.0\"\n\\t},\n\\t\"engines\": {\n\\t\\t\"node\": \">=20\"\n\\t},\n\\t\"scripts\": {\n\\t\\t\"build\": \"build\",\n\\t\\t\"test\": \"jest\",\n\\t\\t\"myscript\": \"somescript\"\n\\t},\n\\t\"version\": \"new-version\"\\n`,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tadded: true,\n\t\t\t\t\t\tcount: 1,\n\t\t\t\t\t\tremoved: undefined,\n\t\t\t\t\t\tvalue: `    \"tested\": true\\n`,\n\t\t\t\t\t},\n\t\t\t\t]),\n\t\t\t});\n\n\t\t\t// Ensure we overwrote\n\t\t\texpect(\n\t\t\t\tJSON.parse((await readFile(join(tmpDir, \"package.json\"))).toString()),\n\t\t\t).toEqual({\n\t\t\t\ttested: true,\n\t\t\t});\n\t\t});\n\t\tit(\"[inverse] applies builtin _json and custom merge for local with sync plugin and then local override\", async () => {\n\t\t\texpect(\n\t\t\t\tawait mergeFile(\"package.json\", {\n\t\t\t\t\tcwd: tmpDir,\n\t\t\t\t\ttempCloneDir: testTemplateDir,\n\t\t\t\t\tfileOperation: op,\n\t\t\t\t\tlocalTemplateSyncConfig: {\n\t\t\t\t\t\tignore: [],\n\t\t\t\t\t\tmerge: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\tplugin: \"plugins/custom-plugin.js\",\n\t\t\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t\t\t// Do not touch huh\n\t\t\t\t\t\t\t\t\t\t[\"$.dependencies.huh\", \"merge-current\"],\n\t\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\ttemplateSyncConfig: {\n\t\t\t\t\t\tignore: [\"**/*.txt\"],\n\t\t\t\t\t\tmerge: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tglob: \"**/package.json\",\n\t\t\t\t\t\t\t\t// TODO - we need to handle the weird implicit case I added here.  It's dumb\n\t\t\t\t\t\t\t\toptions: {\n\t\t\t\t\t\t\t\t\tmissingIsDelete: true,\n\t\t\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t\t\t// Merge all template dependencies\n\t\t\t\t\t\t\t\t\t\t[\"$.dependencies\", \"merge-template\"],\n\t\t\t\t\t\t\t\t\t],\n\t\t\t\t\t\t\t\t} as JsonFileMergeOptions,\n\t\t\t\t\t\t\t\tplugin: \"_json\",\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t\t//   \".json\": {\n\t\t\t\t\t\t//     // no plugins\n\t\t\t\t\t\t//     rules: [\n\t\t\t\t\t\t//       {\n\t\t\t\t\t\t//         glob: \"**/package.json\",\n\t\t\t\t\t\t//         options: {\n\t\t\t\t\t\t//           missingIsDelete: true,\n\t\t\t\t\t\t//           paths: [\n\t\t\t\t\t\t//             // Merge all template dependencies\n\t\t\t\t\t\t//             [\"$.dependencies\", \"merge-template\"],\n\t\t\t\t\t\t//           ],\n\t\t\t\t\t\t//         } as JsonFileMergeOptions,\n\t\t\t\t\t\t//       },\n\t\t\t\t\t\t//       {\n\t\t\t\t\t\t//         glob: \"**/package.json\",\n\t\t\t\t\t\t//         options: \"merge-current\",\n\t\t\t\t\t\t//       },\n\t\t\t\t\t\t//     ],\n\t\t\t\t\t\t//   },\n\t\t\t\t\t\t// },\n\t\t\t\t\t},\n\t\t\t\t}),\n\t\t\t).toEqual({\n\t\t\t\tignoredDueToLocal: false,\n\t\t\t\t// We are just making sure plugin look up happens here\n\t\t\t\tlocalChanges: expect.arrayContaining([]),\n\t\t\t});\n\n\t\t\t// Ensure we overwrote\n\t\t\texpect(\n\t\t\t\tJSON.parse((await readFile(join(tmpDir, \"package.json\"))).toString()),\n\t\t\t).toEqual({\n\t\t\t\tdownstream: true,\n\t\t\t});\n\t\t});\n\t});\n});\n"],"names":["existsSync","mkdtemp","readFile","rm","copySync","join","resolve","mergeFile","TEST_FIXTURES_DIR","tempDir","testTemplateDir","testDownstreamDir","describe","tmpDir","tmpTemplateDir","beforeEach","afterEach","force","recursive","it","each","op","expect","cwd","tempCloneDir","localTemplateSyncConfig","ignore","merge","templateSyncConfig","fileOperation","toEqual","ignoredDueToLocal","localChanges","toBeFalsy","plugin","glob","options","paths","missingIsDelete","JSON","parse","toString","name","description","dependencies","mypackage","newpacakge","package2","huh","engines","node","scripts","build","test","myscript","version","arrayContaining","added","undefined","count","removed","value","tested","downstream"],"mappings":"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"}

package/dist/esm/plugins/index.mjs

@@ -0,0 +1,10 @@
+import { merge as jsonMerge, validate as jsonValidate } from "./json-merge.mjs";
+export const defaultExtensionMap = {
+    ".json": {
+        merge: jsonMerge,
+        validate: jsonValidate,
+        builtinName: "_json"
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wbHVnaW5zL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgSnNvbkZpbGVNZXJnZU9wdGlvbnMsIE1lcmdlUGx1Z2luIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgeyBtZXJnZSBhcyBqc29uTWVyZ2UsIHZhbGlkYXRlIGFzIGpzb25WYWxpZGF0ZSB9IGZyb20gXCIuL2pzb24tbWVyZ2VcIjtcblxuZXhwb3J0IGNvbnN0IGRlZmF1bHRFeHRlbnNpb25NYXAgPSB7XG5cdFwiLmpzb25cIjoge1xuXHRcdG1lcmdlOiBqc29uTWVyZ2UsXG5cdFx0dmFsaWRhdGU6IGpzb25WYWxpZGF0ZSxcblx0XHRidWlsdGluTmFtZTogXCJfanNvblwiLFxuXHR9LFxufSBhcyB7XG5cdFtleHQ6IHN0cmluZ106IE1lcmdlUGx1Z2luPEpzb25GaWxlTWVyZ2VPcHRpb25zPiAmIHsgYnVpbHRpbk5hbWU6IHN0cmluZyB9O1xufTtcbiJdLCJuYW1lcyI6WyJtZXJnZSIsImpzb25NZXJnZSIsInZhbGlkYXRlIiwianNvblZhbGlkYXRlIiwiZGVmYXVsdEV4dGVuc2lvbk1hcCIsImJ1aWx0aW5OYW1lIl0sIm1hcHBpbmdzIjoiQUFDQSxTQUFTQSxTQUFTQyxTQUFTLEVBQUVDLFlBQVlDLFlBQVksUUFBUSxtQkFBZTtBQUU1RSxPQUFPLE1BQU1DLHNCQUFzQjtJQUNsQyxTQUFTO1FBQ1JKLE9BQU9DO1FBQ1BDLFVBQVVDO1FBQ1ZFLGFBQWE7SUFDZDtBQUNELEVBRUUifQ==