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

package/dist/esm/template-sync.spec.mjs

@@ -0,0 +1,517 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { copy } from "fs-extra";
+import { join, resolve } from "path";
+import { templateSync } from "./template-sync.mjs";
+import { TEST_FIXTURES_DIR, tempDir } from "./test-utils/index.mjs";
+const dummyCheckoutDriver = jest.fn();
+const dummyCurrentRefDriver = jest.fn();
+const downstreamDir = resolve(TEST_FIXTURES_DIR, "downstream");
+describe("templateSync", ()=>{
+    let tmpDir;
+    let templateDir;
+    let dummyCloneDriver;
+    beforeEach(async ()=>{
+        jest.resetAllMocks();
+        tmpDir = await mkdtemp(tempDir());
+        templateDir = await mkdtemp(tempDir());
+        await copy(resolve(TEST_FIXTURES_DIR, "template"), templateDir);
+        await copy(downstreamDir, tmpDir);
+        dummyCloneDriver = async ()=>{
+            return {
+                dir: templateDir,
+                remoteName: "ourRemote"
+            };
+        };
+    });
+    afterEach(async ()=>{
+        await rm(tmpDir, {
+            force: true,
+            recursive: true
+        });
+    });
+    // Note: for this test, we expect actions and users to handle misconfigured template syncs
+    it.each([
+        [
+            "local",
+            `templatesync.local.json plugin option errors:
+\tPlugin (plugins/fail-validate-plugin.js):
+\t\toh no!
+\t\tnot this one too!
+`
+        ],
+        [
+            "template",
+            `templatesync.json plugin option errors:
+\tPlugin (dummy-fail-plugin.js):
+\t\tshucks
+\t\tno good
+`
+        ],
+        [
+            "both",
+            `templatesync.json plugin option errors:
+\tPlugin (dummy-fail-plugin.js):
+\t\tshucks
+\t\tno good
+templatesync.local.json plugin option errors:
+\tPlugin (plugins/fail-validate-plugin.js):
+\t\toh no!
+\t\tnot this one too!
+`
+        ]
+    ])("throws errors from plugin validation", async (mode, expected)=>{
+        // Remove the local sync overrides
+        await rm(join(tmpDir, "templatesync.local.json"));
+        if (mode === "local" || mode == "both") {
+            writeFileSync(join(tmpDir, "templatesync.local.json"), JSON.stringify({
+                ignore: [
+                    // Ignores the templated.ts
+                    "**/*.ts",
+                    // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                    "plugins/**"
+                ],
+                merge: [
+                    {
+                        glob: "package.json",
+                        plugin: "plugins/fail-validate-plugin.js",
+                        options: {}
+                    }
+                ]
+            }));
+        }
+        if (mode === "template" || mode === "both") {
+            writeFileSync(join(templateDir, "templatesync.json"), JSON.stringify({
+                ignore: [
+                    // Ignores the templated.ts
+                    "**/*.ts",
+                    // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                    "plugins/**"
+                ],
+                merge: [
+                    {
+                        glob: "package.json",
+                        plugin: "dummy-fail-plugin.js",
+                        options: {}
+                    }
+                ]
+            }));
+        }
+        await expect(async ()=>await templateSync({
+                tmpCloneDir: "stubbed-by-driver",
+                cloneDriver: dummyCloneDriver,
+                repoUrl: "not-important",
+                repoDir: tmpDir,
+                checkoutDriver: dummyCheckoutDriver,
+                currentRefDriver: dummyCurrentRefDriver
+            })).rejects.toThrow(expected);
+    });
+    it("appropriately merges according to just the templatesync config file into an empty dir", async ()=>{
+        const emptyTmpDir = await mkdtemp(tempDir());
+        expect(await templateSync({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: emptyTmpDir,
+            checkoutDriver: dummyCheckoutDriver,
+            currentRefDriver: dummyCurrentRefDriver
+        })).toEqual({
+            // Expect no changes since there was no local sync file
+            localSkipFiles: [],
+            localFileChanges: {},
+            modifiedFiles: {
+                added: [
+                    "package.json",
+                    "src/index.js",
+                    "src/templated.js",
+                    "src/templated.ts",
+                    "templatesync.json"
+                ],
+                deleted: [],
+                modified: [],
+                total: 5
+            }
+        });
+        // Verify the files
+        await fileMatchTemplate(emptyTmpDir, "templatesync.json");
+        await fileMatchTemplate(emptyTmpDir, "package.json");
+        await fileMatchTemplate(emptyTmpDir, "src/templated.ts");
+        // Expect the ignores to not be a problem
+        expect(existsSync(resolve(emptyTmpDir, "src/index.ts"))).toBeFalsy();
+        expect(existsSync(resolve(emptyTmpDir, "src/custom-bin"))).toBeFalsy();
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("Checks out the branch and then appropriately merges", async ()=>{
+        const emptyTmpDir = await mkdtemp(tempDir());
+        expect(await templateSync({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: emptyTmpDir,
+            branch: "new-template-test",
+            checkoutDriver: dummyCheckoutDriver,
+            currentRefDriver: dummyCurrentRefDriver
+        })).toEqual({
+            // Expect no changes since there was no local sync file
+            localSkipFiles: [],
+            localFileChanges: {},
+            modifiedFiles: {
+                added: [
+                    "package.json",
+                    "src/index.js",
+                    "src/templated.js",
+                    "src/templated.ts",
+                    "templatesync.json"
+                ],
+                deleted: [],
+                modified: [],
+                total: 5
+            }
+        });
+        // Verify the files
+        await fileMatchTemplate(emptyTmpDir, "templatesync.json");
+        await fileMatchTemplate(emptyTmpDir, "package.json");
+        await fileMatchTemplate(emptyTmpDir, "src/templated.ts");
+        // Expect the ignores to not be a problem
+        expect(existsSync(resolve(emptyTmpDir, "src/index.ts"))).toBeFalsy();
+        expect(existsSync(resolve(emptyTmpDir, "src/custom-bin"))).toBeFalsy();
+        const cloneInfo = await dummyCloneDriver();
+        expect(dummyCheckoutDriver).toHaveBeenCalledWith({
+            tmpDir: cloneInfo.dir,
+            remoteName: cloneInfo.remoteName,
+            branch: "new-template-test"
+        });
+    });
+    it("appropriately merges according to just the templatesync config file in an existing repo", async ()=>{
+        // Remove the local sync overrides
+        await rm(join(tmpDir, "templatesync.local.json"));
+        const result = await templateSync({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            checkoutDriver: dummyCheckoutDriver,
+            currentRefDriver: dummyCurrentRefDriver
+        });
+        expect(result.localSkipFiles).toEqual([]);
+        expect(result.localFileChanges).toEqual({});
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchTemplate(tmpDir, "src/templated.ts");
+        const packageJson = JSON.parse(readFileSync(resolve(tmpDir, "package.json")).toString());
+        expect(packageJson).toEqual({
+            name: "mypkg",
+            description: "my 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: "jest",
+                myscript: "somescript"
+            },
+            // By default we add new top-level fields
+            version: "new-version"
+        });
+        // Expect the ignores to not be a problem
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("appropriately merges according to the templatesync config file and the local config in an existing repo", async ()=>{
+        // Remove the local sync overrides
+        await rm(join(tmpDir, "templatesync.local.json"));
+        writeFileSync(join(tmpDir, "templatesync.local.json"), JSON.stringify({
+            ignore: [
+                // Ignores the templated.ts
+                "**/*.ts",
+                // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                "plugins/**"
+            ],
+            merge: [
+                {
+                    glob: "package.json",
+                    plugin: "plugins/custom-plugin.js",
+                    options: {}
+                }
+            ]
+        }));
+        const result = await templateSync({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            checkoutDriver: dummyCheckoutDriver,
+            currentRefDriver: dummyCurrentRefDriver
+        });
+        expect(result.localSkipFiles).toEqual([
+            "src/templated.ts"
+        ]);
+        // TODO: more rigorous testing around diff changes
+        expect(result.localFileChanges).toEqual(expect.objectContaining({
+            "package.json": expect.arrayContaining([])
+        }));
+        // Make sure the result captures the changes
+        expect(result.modifiedFiles).toEqual({
+            added: [
+                "package.json",
+                "src/index.js",
+                "src/templated.js",
+                "templatesync.json"
+            ],
+            deleted: [],
+            modified: [],
+            total: 4
+        });
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchDownstream(tmpDir, "src/templated.ts");
+        const packageJson = JSON.parse(readFileSync(resolve(tmpDir, "package.json")).toString());
+        // The plugin nuked this
+        expect(packageJson).toEqual({
+            downstream: true
+        });
+        // Expect the ignores to not be a problem
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("appropriately merges according to the templatesync config file and the local config in an existing repo with afterRef", async ()=>{
+        // Remove the local sync overrides
+        await rm(join(tmpDir, "templatesync.local.json"));
+        writeFileSync(join(tmpDir, "templatesync.local.json"), JSON.stringify({
+            afterRef: "dummySha",
+            ignore: [
+                // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                "plugins/**"
+            ]
+        }));
+        // We will only update the templated.ts
+        const mockDiffDriver = jest.fn().mockImplementation(async ()=>({
+                added: [
+                    "src/templated.ts"
+                ],
+                modified: [],
+                deleted: []
+            }));
+        const result = await templateSync({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            diffDriver: mockDiffDriver,
+            currentRefDriver: dummyCurrentRefDriver,
+            checkoutDriver: dummyCheckoutDriver
+        });
+        // since there was no override for this file, not changes from the local file
+        expect(result.localFileChanges).toEqual(expect.objectContaining({}));
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchTemplate(tmpDir, "src/templated.ts");
+        // Expect the none of the diff files to work
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        await fileMatchDownstream(tmpDir, "package.json");
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("updates the local templatesync with the current ref if updateAfterRef is true", async ()=>{
+        // Remove the local sync overrides
+        await rm(join(tmpDir, "templatesync.local.json"));
+        const mockLocalConfig = {
+            afterRef: "dummySha",
+            ignore: [
+                // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                "plugins/**"
+            ]
+        };
+        writeFileSync(join(tmpDir, "templatesync.local.json"), JSON.stringify(mockLocalConfig));
+        // We will only update the templated.ts
+        const mockDiffDriver = jest.fn().mockImplementation(async ()=>({
+                added: [
+                    "src/templated.ts"
+                ],
+                modified: [
+                    "src/index.ts"
+                ],
+                deleted: []
+            }));
+        const mockCurrentRefDriver = jest.fn().mockImplementation(async ()=>"newestSha");
+        const result = await templateSync({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            updateAfterRef: true,
+            diffDriver: mockDiffDriver,
+            currentRefDriver: mockCurrentRefDriver,
+            checkoutDriver: dummyCheckoutDriver
+        });
+        // since there was no override for this file, no changes from the local file
+        expect(result.localFileChanges).toEqual(expect.objectContaining({}));
+        expect(result.modifiedFiles).toEqual({
+            added: [
+                "src/templated.ts"
+            ],
+            modified: [
+                "templatesync.local.json"
+            ],
+            deleted: [],
+            total: 2
+        });
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchTemplate(tmpDir, "src/templated.ts");
+        // Expect the none of the diff files to work
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        await fileMatchDownstream(tmpDir, "package.json");
+        // Ensure we have updated the local template field
+        expect(JSON.parse((await readFile(join(tmpDir, "templatesync.local.json"))).toString())).toEqual({
+            ...mockLocalConfig,
+            afterRef: "newestSha"
+        });
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("Does not update the local templatesync if updateAfterRef is true and the ref is the same", async ()=>{
+        // Remove the local sync overrides
+        await rm(join(tmpDir, "templatesync.local.json"));
+        const mockLocalConfig = {
+            afterRef: "dummySha",
+            ignore: [
+                // We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins
+                "plugins/**"
+            ]
+        };
+        writeFileSync(join(tmpDir, "templatesync.local.json"), JSON.stringify(mockLocalConfig));
+        // We will only update the templated.ts
+        const mockDiffDriver = jest.fn().mockImplementation(async ()=>({
+                added: [
+                    "src/templated.ts"
+                ],
+                modified: [
+                    "src/index.ts"
+                ],
+                deleted: []
+            }));
+        const mockCurrentRefDriver = jest.fn().mockImplementation(async ()=>"dummySha");
+        const result = await templateSync({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            updateAfterRef: true,
+            diffDriver: mockDiffDriver,
+            currentRefDriver: mockCurrentRefDriver,
+            checkoutDriver: dummyCheckoutDriver
+        });
+        // Nothing shoudl be reported as changing
+        expect(result).toEqual({
+            localFileChanges: {},
+            localSkipFiles: [],
+            modifiedFiles: {
+                added: [],
+                modified: [],
+                deleted: [],
+                total: 0
+            }
+        });
+        // Verify the files
+        await fileMatchDownstream(tmpDir, "templatesync.json");
+        await fileMatchDownstream(tmpDir, "src/templated.ts");
+        // Expect the none of the diff files to work
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        await fileMatchDownstream(tmpDir, "package.json");
+        // Ensure we have updated the local template field
+        expect(JSON.parse((await readFile(join(tmpDir, "templatesync.local.json"))).toString())).toEqual({
+            ...mockLocalConfig
+        });
+        expect(dummyCheckoutDriver).not.toHaveBeenCalled();
+    });
+    it("creates the local templatesync with the current ref if updateAfterRef is true and no local template exists", async ()=>{
+        // Remove the local sync overrides
+        await rm(join(tmpDir, "templatesync.local.json"));
+        // We will only update the templated.ts
+        const mockDiffDriver = jest.fn().mockImplementation(async ()=>({
+                added: [
+                    "src/templated.ts"
+                ]
+            }));
+        const mockCurrentRefDriver = jest.fn().mockImplementation(async ()=>"newestSha");
+        const result = await templateSync({
+            tmpCloneDir: "stubbed-by-driver",
+            cloneDriver: dummyCloneDriver,
+            repoUrl: "not-important",
+            repoDir: tmpDir,
+            updateAfterRef: true,
+            diffDriver: mockDiffDriver,
+            currentRefDriver: mockCurrentRefDriver,
+            checkoutDriver: dummyCheckoutDriver
+        });
+        // since there was no override for this file, no changes from the local file
+        expect(result.localFileChanges).toEqual(expect.objectContaining({}));
+        expect(result.modifiedFiles).toEqual({
+            added: [
+                "package.json",
+                "src/index.js",
+                "src/templated.js",
+                "src/templated.ts",
+                "templatesync.json",
+                "templatesync.local.json"
+            ],
+            deleted: [],
+            modified: [],
+            total: 6
+        });
+        // Verify the files
+        await fileMatchTemplate(tmpDir, "templatesync.json");
+        await fileMatchTemplate(tmpDir, "src/templated.ts");
+        const packageJson = JSON.parse(readFileSync(resolve(tmpDir, "package.json")).toString());
+        expect(packageJson).toEqual({
+            name: "mypkg",
+            description: "my 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: "jest",
+                myscript: "somescript"
+            },
+            // By default we add new top-level fields
+            version: "new-version"
+        });
+        // Expect the none of the diff files to work
+        await fileMatchDownstream(tmpDir, "src/index.ts");
+        await fileMatchDownstream(tmpDir, "plugins/custom-plugin.js");
+        // Ensure we have updated the local template field
+        expect(JSON.parse((await readFile(join(tmpDir, "templatesync.local.json"))).toString())).toEqual({
+            afterRef: "newestSha"
+        });
+    });
+    // helper
+    async function fileMatchTemplate(_tmpDir, relPath) {
+        return fileMatch(_tmpDir, relPath, "template");
+    }
+    async function fileMatchDownstream(_tmpDir, relPath) {
+        return fileMatch(_tmpDir, relPath, "downstream");
+    }
+    async function fileMatch(_tmpDir, relPath, source) {
+        const dir = source === "downstream" ? downstreamDir : (await dummyCloneDriver()).dir;
+        expect((await readFile(resolve(_tmpDir, relPath))).toString()).toEqual((await readFile(resolve(dir, relPath))).toString());
+    }
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/template-sync.spec.ts"],"sourcesContent":["import { existsSync, readFileSync, writeFileSync } from \"fs\";\nimport { mkdtemp, readFile, rm } from \"fs/promises\";\nimport { copy } from \"fs-extra\";\nimport { join, resolve } from \"path\";\nimport { templateSync } from \"./template-sync\";\nimport { TEST_FIXTURES_DIR, tempDir } from \"./test-utils\";\n\nconst dummyCheckoutDriver = jest.fn();\nconst dummyCurrentRefDriver = jest.fn();\n\nconst downstreamDir = resolve(TEST_FIXTURES_DIR, \"downstream\");\n\ndescribe(\"templateSync\", () => {\n\tlet tmpDir: string;\n\tlet templateDir: string;\n\tlet dummyCloneDriver: () => Promise<{ dir: string; remoteName: string }>;\n\tbeforeEach(async () => {\n\t\tjest.resetAllMocks();\n\t\ttmpDir = await mkdtemp(tempDir());\n\t\ttemplateDir = await mkdtemp(tempDir());\n\t\tawait copy(resolve(TEST_FIXTURES_DIR, \"template\"), templateDir);\n\t\tawait copy(downstreamDir, tmpDir);\n\t\tdummyCloneDriver = async () => {\n\t\t\treturn {\n\t\t\t\tdir: templateDir,\n\t\t\t\tremoteName: \"ourRemote\",\n\t\t\t};\n\t\t};\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});\n\t// Note: for this test, we expect actions and users to handle misconfigured template syncs\n\tit.each([\n\t\t[\n\t\t\t\"local\",\n\t\t\t`templatesync.local.json plugin option errors:\n\\tPlugin (plugins/fail-validate-plugin.js):\n\\t\\toh no!\n\\t\\tnot this one too!\n`,\n\t\t],\n\t\t[\n\t\t\t\"template\",\n\t\t\t`templatesync.json plugin option errors:\n\\tPlugin (dummy-fail-plugin.js):\n\\t\\tshucks\n\\t\\tno good\n`,\n\t\t],\n\t\t[\n\t\t\t\"both\",\n\t\t\t`templatesync.json plugin option errors:\n\\tPlugin (dummy-fail-plugin.js):\n\\t\\tshucks\n\\t\\tno good\ntemplatesync.local.json plugin option errors:\n\\tPlugin (plugins/fail-validate-plugin.js):\n\\t\\toh no!\n\\t\\tnot this one too!\n`,\n\t\t],\n\t])(\"throws errors from plugin validation\", async (mode, expected) => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\tif (mode === \"local\" || mode == \"both\") {\n\t\t\twriteFileSync(\n\t\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\t\tJSON.stringify({\n\t\t\t\t\tignore: [\n\t\t\t\t\t\t// Ignores the templated.ts\n\t\t\t\t\t\t\"**/*.ts\",\n\t\t\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\t\t\"plugins/**\",\n\t\t\t\t\t],\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: \"plugins/fail-validate-plugin.js\",\n\t\t\t\t\t\t\toptions: {},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t}),\n\t\t\t);\n\t\t}\n\t\tif (mode === \"template\" || mode === \"both\") {\n\t\t\twriteFileSync(\n\t\t\t\tjoin(templateDir, \"templatesync.json\"),\n\t\t\t\tJSON.stringify({\n\t\t\t\t\tignore: [\n\t\t\t\t\t\t// Ignores the templated.ts\n\t\t\t\t\t\t\"**/*.ts\",\n\t\t\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\t\t\"plugins/**\",\n\t\t\t\t\t],\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: \"dummy-fail-plugin.js\",\n\t\t\t\t\t\t\toptions: {},\n\t\t\t\t\t\t},\n\t\t\t\t\t],\n\t\t\t\t}),\n\t\t\t);\n\t\t}\n\n\t\tawait expect(\n\t\t\tasync () =>\n\t\t\t\tawait templateSync({\n\t\t\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\t\t\trepoUrl: \"not-important\",\n\t\t\t\t\trepoDir: tmpDir,\n\t\t\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t\t\t}),\n\t\t).rejects.toThrow(expected);\n\t});\n\tit(\"appropriately merges according to just the templatesync config file into an empty dir\", async () => {\n\t\tconst emptyTmpDir = await mkdtemp(tempDir());\n\t\texpect(\n\t\t\tawait templateSync({\n\t\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\t\trepoUrl: \"not-important\",\n\t\t\t\trepoDir: emptyTmpDir,\n\t\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t\t}),\n\t\t).toEqual({\n\t\t\t// Expect no changes since there was no local sync file\n\t\t\tlocalSkipFiles: [],\n\t\t\tlocalFileChanges: {},\n\t\t\tmodifiedFiles: {\n\t\t\t\tadded: [\n\t\t\t\t\t\"package.json\",\n\t\t\t\t\t\"src/index.js\",\n\t\t\t\t\t\"src/templated.js\",\n\t\t\t\t\t\"src/templated.ts\",\n\t\t\t\t\t\"templatesync.json\",\n\t\t\t\t],\n\t\t\t\tdeleted: [],\n\t\t\t\tmodified: [],\n\t\t\t\ttotal: 5,\n\t\t\t},\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(emptyTmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(emptyTmpDir, \"package.json\");\n\t\tawait fileMatchTemplate(emptyTmpDir, \"src/templated.ts\");\n\n\t\t// Expect the ignores to not be a problem\n\t\texpect(existsSync(resolve(emptyTmpDir, \"src/index.ts\"))).toBeFalsy();\n\t\texpect(existsSync(resolve(emptyTmpDir, \"src/custom-bin\"))).toBeFalsy();\n\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"Checks out the branch and then appropriately merges\", async () => {\n\t\tconst emptyTmpDir = await mkdtemp(tempDir());\n\t\texpect(\n\t\t\tawait templateSync({\n\t\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\t\trepoUrl: \"not-important\",\n\t\t\t\trepoDir: emptyTmpDir,\n\t\t\t\tbranch: \"new-template-test\",\n\t\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t\t}),\n\t\t).toEqual({\n\t\t\t// Expect no changes since there was no local sync file\n\t\t\tlocalSkipFiles: [],\n\t\t\tlocalFileChanges: {},\n\t\t\tmodifiedFiles: {\n\t\t\t\tadded: [\n\t\t\t\t\t\"package.json\",\n\t\t\t\t\t\"src/index.js\",\n\t\t\t\t\t\"src/templated.js\",\n\t\t\t\t\t\"src/templated.ts\",\n\t\t\t\t\t\"templatesync.json\",\n\t\t\t\t],\n\t\t\t\tdeleted: [],\n\t\t\t\tmodified: [],\n\t\t\t\ttotal: 5,\n\t\t\t},\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(emptyTmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(emptyTmpDir, \"package.json\");\n\t\tawait fileMatchTemplate(emptyTmpDir, \"src/templated.ts\");\n\n\t\t// Expect the ignores to not be a problem\n\t\texpect(existsSync(resolve(emptyTmpDir, \"src/index.ts\"))).toBeFalsy();\n\t\texpect(existsSync(resolve(emptyTmpDir, \"src/custom-bin\"))).toBeFalsy();\n\t\tconst cloneInfo = await dummyCloneDriver();\n\t\texpect(dummyCheckoutDriver).toHaveBeenCalledWith({\n\t\t\ttmpDir: cloneInfo.dir,\n\t\t\tremoteName: cloneInfo.remoteName,\n\t\t\tbranch: \"new-template-test\",\n\t\t});\n\t});\n\tit(\"appropriately merges according to just the templatesync config file in an existing repo\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t});\n\n\t\texpect(result.localSkipFiles).toEqual([]);\n\t\texpect(result.localFileChanges).toEqual({});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(tmpDir, \"src/templated.ts\");\n\t\tconst packageJson = JSON.parse(\n\t\t\treadFileSync(resolve(tmpDir, \"package.json\")).toString(),\n\t\t);\n\n\t\texpect(packageJson).toEqual({\n\t\t\tname: \"mypkg\",\n\t\t\tdescription: \"my description\",\n\t\t\tdependencies: {\n\t\t\t\tmypackage: \"^1.2.0\",\n\t\t\t\tnewpacakge: \"^22.2.2\",\n\t\t\t\tpackage2: \"3.22.1\",\n\t\t\t\thuh: \"~1.0.0\",\n\t\t\t},\n\t\t\tengines: {\n\t\t\t\tnode: \">=15\",\n\t\t\t},\n\t\t\tscripts: {\n\t\t\t\tbuild: \"build\",\n\t\t\t\ttest: \"jest\",\n\t\t\t\tmyscript: \"somescript\",\n\t\t\t},\n\t\t\t// By default we add new top-level fields\n\t\t\tversion: \"new-version\",\n\t\t});\n\n\t\t// Expect the ignores to not be a problem\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"appropriately merges according to the templatesync config file and the local config in an existing repo\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\twriteFileSync(\n\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\tJSON.stringify({\n\t\t\t\tignore: [\n\t\t\t\t\t// Ignores the templated.ts\n\t\t\t\t\t\"**/*.ts\",\n\t\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\t\"plugins/**\",\n\t\t\t\t],\n\t\t\t\tmerge: [\n\t\t\t\t\t{\n\t\t\t\t\t\tglob: \"package.json\",\n\t\t\t\t\t\tplugin: \"plugins/custom-plugin.js\",\n\t\t\t\t\t\toptions: {},\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t}),\n\t\t);\n\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t});\n\n\t\texpect(result.localSkipFiles).toEqual([\"src/templated.ts\"]);\n\t\t// TODO: more rigorous testing around diff changes\n\t\texpect(result.localFileChanges).toEqual(\n\t\t\texpect.objectContaining({\n\t\t\t\t\"package.json\": expect.arrayContaining([]),\n\t\t\t}),\n\t\t);\n\t\t// Make sure the result captures the changes\n\t\texpect(result.modifiedFiles).toEqual({\n\t\t\tadded: [\n\t\t\t\t\"package.json\",\n\t\t\t\t\"src/index.js\",\n\t\t\t\t\"src/templated.js\",\n\t\t\t\t\"templatesync.json\",\n\t\t\t],\n\t\t\tdeleted: [],\n\t\t\tmodified: [],\n\t\t\ttotal: 4,\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchDownstream(tmpDir, \"src/templated.ts\");\n\t\tconst packageJson = JSON.parse(\n\t\t\treadFileSync(resolve(tmpDir, \"package.json\")).toString(),\n\t\t);\n\n\t\t// The plugin nuked this\n\t\texpect(packageJson).toEqual({\n\t\t\tdownstream: true,\n\t\t});\n\n\t\t// Expect the ignores to not be a problem\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"appropriately merges according to the templatesync config file and the local config in an existing repo with afterRef\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\twriteFileSync(\n\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\tJSON.stringify({\n\t\t\t\tafterRef: \"dummySha\",\n\t\t\t\tignore: [\n\t\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\t\"plugins/**\",\n\t\t\t\t],\n\t\t\t}),\n\t\t);\n\n\t\t// We will only update the templated.ts\n\t\tconst mockDiffDriver = jest.fn().mockImplementation(async () => ({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t\tmodified: [],\n\t\t\tdeleted: [],\n\t\t}));\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tdiffDriver: mockDiffDriver,\n\t\t\tcurrentRefDriver: dummyCurrentRefDriver,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t});\n\n\t\t// since there was no override for this file, not changes from the local file\n\t\texpect(result.localFileChanges).toEqual(expect.objectContaining({}));\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(tmpDir, \"src/templated.ts\");\n\n\t\t// Expect the none of the diff files to work\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\tawait fileMatchDownstream(tmpDir, \"package.json\");\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"updates the local templatesync with the current ref if updateAfterRef is true\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\tconst mockLocalConfig = {\n\t\t\tafterRef: \"dummySha\",\n\t\t\tignore: [\n\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\"plugins/**\",\n\t\t\t],\n\t\t};\n\n\t\twriteFileSync(\n\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\tJSON.stringify(mockLocalConfig),\n\t\t);\n\n\t\t// We will only update the templated.ts\n\t\tconst mockDiffDriver = jest.fn().mockImplementation(async () => ({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t\tmodified: [\"src/index.ts\"], // Add index.ts so we make sure it is still ignored - see test-fixtures/template/templatesync.json ignores\n\t\t\tdeleted: [],\n\t\t}));\n\t\tconst mockCurrentRefDriver = jest\n\t\t\t.fn()\n\t\t\t.mockImplementation(async () => \"newestSha\");\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tupdateAfterRef: true,\n\t\t\tdiffDriver: mockDiffDriver,\n\t\t\tcurrentRefDriver: mockCurrentRefDriver,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t});\n\n\t\t// since there was no override for this file, no changes from the local file\n\t\texpect(result.localFileChanges).toEqual(expect.objectContaining({}));\n\t\texpect(result.modifiedFiles).toEqual({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t\tmodified: [\"templatesync.local.json\"], // Add index.ts so we make sure it is still ignored - due to a bug\n\t\t\tdeleted: [],\n\t\t\ttotal: 2,\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(tmpDir, \"src/templated.ts\");\n\n\t\t// Expect the none of the diff files to work\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\tawait fileMatchDownstream(tmpDir, \"package.json\");\n\n\t\t// Ensure we have updated the local template field\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\t(await readFile(join(tmpDir, \"templatesync.local.json\"))).toString(),\n\t\t\t),\n\t\t).toEqual({\n\t\t\t...mockLocalConfig,\n\t\t\tafterRef: \"newestSha\",\n\t\t});\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"Does not update the local templatesync if updateAfterRef is true and the ref is the same\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\tconst mockLocalConfig = {\n\t\t\tafterRef: \"dummySha\",\n\t\t\tignore: [\n\t\t\t\t// We don't have a need for this in here, but it's an example of keeping things cleaner for our custom plugins\n\t\t\t\t\"plugins/**\",\n\t\t\t],\n\t\t};\n\n\t\twriteFileSync(\n\t\t\tjoin(tmpDir, \"templatesync.local.json\"),\n\t\t\tJSON.stringify(mockLocalConfig),\n\t\t);\n\n\t\t// We will only update the templated.ts\n\t\tconst mockDiffDriver = jest.fn().mockImplementation(async () => ({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t\tmodified: [\"src/index.ts\"], // Add index.ts so we make sure it is still ignored - see test-fixtures/template/templatesync.json ignores\n\t\t\tdeleted: [],\n\t\t}));\n\t\tconst mockCurrentRefDriver = jest\n\t\t\t.fn()\n\t\t\t.mockImplementation(async () => \"dummySha\");\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tupdateAfterRef: true,\n\t\t\tdiffDriver: mockDiffDriver,\n\t\t\tcurrentRefDriver: mockCurrentRefDriver,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t});\n\n\t\t// Nothing shoudl be reported as changing\n\t\texpect(result).toEqual({\n\t\t\tlocalFileChanges: {},\n\t\t\tlocalSkipFiles: [],\n\t\t\tmodifiedFiles: {\n\t\t\t\tadded: [],\n\t\t\t\tmodified: [],\n\t\t\t\tdeleted: [],\n\t\t\t\ttotal: 0,\n\t\t\t},\n\t\t});\n\t\t// Verify the files\n\t\tawait fileMatchDownstream(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchDownstream(tmpDir, \"src/templated.ts\");\n\n\t\t// Expect the none of the diff files to work\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\t\tawait fileMatchDownstream(tmpDir, \"package.json\");\n\n\t\t// Ensure we have updated the local template field\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\t(await readFile(join(tmpDir, \"templatesync.local.json\"))).toString(),\n\t\t\t),\n\t\t).toEqual({\n\t\t\t...mockLocalConfig,\n\t\t});\n\t\texpect(dummyCheckoutDriver).not.toHaveBeenCalled();\n\t});\n\tit(\"creates the local templatesync with the current ref if updateAfterRef is true and no local template exists\", async () => {\n\t\t// Remove the local sync overrides\n\t\tawait rm(join(tmpDir, \"templatesync.local.json\"));\n\n\t\t// We will only update the templated.ts\n\t\tconst mockDiffDriver = jest.fn().mockImplementation(async () => ({\n\t\t\tadded: [\"src/templated.ts\"],\n\t\t}));\n\t\tconst mockCurrentRefDriver = jest\n\t\t\t.fn()\n\t\t\t.mockImplementation(async () => \"newestSha\");\n\t\tconst result = await templateSync({\n\t\t\ttmpCloneDir: \"stubbed-by-driver\",\n\t\t\tcloneDriver: dummyCloneDriver,\n\t\t\trepoUrl: \"not-important\",\n\t\t\trepoDir: tmpDir,\n\t\t\tupdateAfterRef: true,\n\t\t\tdiffDriver: mockDiffDriver,\n\t\t\tcurrentRefDriver: mockCurrentRefDriver,\n\t\t\tcheckoutDriver: dummyCheckoutDriver,\n\t\t});\n\n\t\t// since there was no override for this file, no changes from the local file\n\t\texpect(result.localFileChanges).toEqual(expect.objectContaining({}));\n\t\texpect(result.modifiedFiles).toEqual({\n\t\t\tadded: [\n\t\t\t\t\"package.json\",\n\t\t\t\t\"src/index.js\",\n\t\t\t\t\"src/templated.js\",\n\t\t\t\t\"src/templated.ts\",\n\t\t\t\t\"templatesync.json\",\n\t\t\t\t\"templatesync.local.json\",\n\t\t\t],\n\t\t\tdeleted: [],\n\t\t\tmodified: [],\n\t\t\ttotal: 6,\n\t\t});\n\n\t\t// Verify the files\n\t\tawait fileMatchTemplate(tmpDir, \"templatesync.json\");\n\t\tawait fileMatchTemplate(tmpDir, \"src/templated.ts\");\n\t\tconst packageJson = JSON.parse(\n\t\t\treadFileSync(resolve(tmpDir, \"package.json\")).toString(),\n\t\t);\n\n\t\texpect(packageJson).toEqual({\n\t\t\tname: \"mypkg\",\n\t\t\tdescription: \"my description\",\n\t\t\tdependencies: {\n\t\t\t\tmypackage: \"^1.2.0\",\n\t\t\t\tnewpacakge: \"^22.2.2\",\n\t\t\t\tpackage2: \"3.22.1\",\n\t\t\t\thuh: \"~1.0.0\",\n\t\t\t},\n\t\t\tengines: {\n\t\t\t\tnode: \">=15\",\n\t\t\t},\n\t\t\tscripts: {\n\t\t\t\tbuild: \"build\",\n\t\t\t\ttest: \"jest\",\n\t\t\t\tmyscript: \"somescript\",\n\t\t\t},\n\t\t\t// By default we add new top-level fields\n\t\t\tversion: \"new-version\",\n\t\t});\n\n\t\t// Expect the none of the diff files to work\n\t\tawait fileMatchDownstream(tmpDir, \"src/index.ts\");\n\t\tawait fileMatchDownstream(tmpDir, \"plugins/custom-plugin.js\");\n\n\t\t// Ensure we have updated the local template field\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\t(await readFile(join(tmpDir, \"templatesync.local.json\"))).toString(),\n\t\t\t),\n\t\t).toEqual({\n\t\t\tafterRef: \"newestSha\",\n\t\t});\n\t});\n\t// helper\n\tasync function fileMatchTemplate(_tmpDir: string, relPath: string) {\n\t\treturn fileMatch(_tmpDir, relPath, \"template\");\n\t}\n\n\tasync function fileMatchDownstream(_tmpDir: string, relPath: string) {\n\t\treturn fileMatch(_tmpDir, relPath, \"downstream\");\n\t}\n\n\tasync function fileMatch(\n\t\t_tmpDir: string,\n\t\trelPath: string,\n\t\tsource: \"downstream\" | \"template\",\n\t) {\n\t\tconst dir =\n\t\t\tsource === \"downstream\" ? downstreamDir : (await dummyCloneDriver()).dir;\n\t\texpect((await readFile(resolve(_tmpDir, relPath))).toString()).toEqual(\n\t\t\t(await readFile(resolve(dir, relPath))).toString(),\n\t\t);\n\t}\n});\n"],"names":["existsSync","readFileSync","writeFileSync","mkdtemp","readFile","rm","copy","join","resolve","templateSync","TEST_FIXTURES_DIR","tempDir","dummyCheckoutDriver","jest","fn","dummyCurrentRefDriver","downstreamDir","describe","tmpDir","templateDir","dummyCloneDriver","beforeEach","resetAllMocks","dir","remoteName","afterEach","force","recursive","it","each","mode","expected","JSON","stringify","ignore","merge","glob","plugin","options","expect","tmpCloneDir","cloneDriver","repoUrl","repoDir","checkoutDriver","currentRefDriver","rejects","toThrow","emptyTmpDir","toEqual","localSkipFiles","localFileChanges","modifiedFiles","added","deleted","modified","total","fileMatchTemplate","toBeFalsy","not","toHaveBeenCalled","branch","cloneInfo","toHaveBeenCalledWith","result","packageJson","parse","toString","name","description","dependencies","mypackage","newpacakge","package2","huh","engines","node","scripts","build","test","myscript","version","fileMatchDownstream","objectContaining","arrayContaining","downstream","afterRef","mockDiffDriver","mockImplementation","diffDriver","mockLocalConfig","mockCurrentRefDriver","updateAfterRef","_tmpDir","relPath","fileMatch","source"],"mappings":"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"}

package/dist/esm/test-utils/index.mjs

@@ -0,0 +1,10 @@
+import { tmpdir } from "os";
+import { resolve, dirname as __swc_shim_dirname } from "path";
+import { fileURLToPath as __swc_shim_fileURLToPath } from "url";
+const __dirname = __swc_shim_dirname(__swc_shim_fileURLToPath(import.meta.url));
+export const TEST_FIXTURES_DIR = resolve(__dirname, "..", "..", "test-fixtures");
+export function tempDir() {
+    return process.env.RUNNER_TEMP ?? tmpdir();
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90ZXN0LXV0aWxzL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHRtcGRpciB9IGZyb20gXCJvc1wiO1xuaW1wb3J0IHsgcmVzb2x2ZSB9IGZyb20gXCJwYXRoXCI7XG5cbmV4cG9ydCBjb25zdCBURVNUX0ZJWFRVUkVTX0RJUiA9IHJlc29sdmUoXG5cdF9fZGlybmFtZSxcblx0XCIuLlwiLFxuXHRcIi4uXCIsXG5cdFwidGVzdC1maXh0dXJlc1wiLFxuKTtcblxuZXhwb3J0IGZ1bmN0aW9uIHRlbXBEaXIoKTogc3RyaW5nIHtcblx0cmV0dXJuIHByb2Nlc3MuZW52LlJVTk5FUl9URU1QID8/IHRtcGRpcigpO1xufVxuIl0sIm5hbWVzIjpbInRtcGRpciIsInJlc29sdmUiLCJURVNUX0ZJWFRVUkVTX0RJUiIsIl9fZGlybmFtZSIsInRlbXBEaXIiLCJwcm9jZXNzIiwiZW52IiwiUlVOTkVSX1RFTVAiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLE1BQU0sUUFBUSxLQUFLO0FBQzVCLFNBQVNDLE9BQU8sdUNBQVEsT0FBTzs7O0FBRS9CLE9BQU8sTUFBTUMsb0JBQW9CRCxRQUNoQ0UsV0FDQSxNQUNBLE1BQ0EsaUJBQ0M7QUFFRixPQUFPLFNBQVNDO0lBQ2YsT0FBT0MsUUFBUUMsR0FBRyxDQUFDQyxXQUFXLElBQUlQO0FBQ25DIn0=

package/dist/esm/types.mjs

@@ -0,0 +1,9 @@
+/**
+ * How we want to merge json
+ *
+ * overwrite - the template sync overwrites completely
+ * merge-template - we merge template into the current json with overrides on matching values happening from the template
+ * merge-current - we merge the current json into the template json with overrides on matching values happening from the current json
+ */ export { };
+
+//# sourceMappingURL=data:application/json;base64,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

package/{lib/cjs → dist/types}/checkout-drivers/git-checkout.d.ts

@@ -6,3 +6,4 @@ export declare function gitCheckout(options: {
     /** The branch to checkout against */
     branch: string;
 }): Promise<boolean>;
+//# sourceMappingURL=git-checkout.d.ts.map

package/dist/types/checkout-drivers/git-checkout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-checkout.d.ts","sourceRoot":"","sources":["../../../src/checkout-drivers/git-checkout.ts"],"names":[],"mappings":"AAEA,wBAAsB,WAAW,CAAC,OAAO,EAAE;IAC1C,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,OAAO,CAAC,CA4BnB"}

package/dist/types/checkout-drivers/git-checkout.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=git-checkout.spec.d.ts.map

package/dist/types/checkout-drivers/git-checkout.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-checkout.spec.d.ts","sourceRoot":"","sources":["../../../src/checkout-drivers/git-checkout.spec.ts"],"names":[],"mappings":""}

package/{lib/cjs → dist/types}/checkout-drivers/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./git-checkout";
 export * from "./types";
+//# sourceMappingURL=index.d.ts.map