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

package/dist/cjs/plugins/json-merge.spec.js

@@ -0,0 +1,514 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("comment-json"));
+const _jsonmerge = require("./json-merge");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const testFileJson = {
+    here: "here",
+    another: 23,
+    inner: {
+        el1: "el1",
+        arr1: [
+            "a1",
+            "a2"
+        ],
+        nested: {
+            final: "final",
+            final2: "final2"
+        }
+    }
+};
+const templateFileJson = {
+    here: "heretemplate",
+    extra: "extra",
+    inner: {
+        arr1: [
+            "b1",
+            "b2"
+        ],
+        extra2: "extra2"
+    }
+};
+const testCommentJson = `{
+  // This is a top comment
+  "here": "here",
+  "another": 23, // this is inline
+  "inner": {
+    "el1": "el1",
+    "arr1": ["a1", "a2"],
+    "nested": {
+      // Upper comment
+      "final": "final", // Inline commment
+      "final2": "final2",
+    },
+  },
+}`;
+describe("merge", ()=>{
+    it("performs overwrite when specified", async ()=>{
+        const fromTemplateJson = {
+            fullOverride: true
+        };
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(fromTemplateJson), {
+            relFilePath: "somepath",
+            mergeArguments: "overwrite"
+        }))).toEqual(fromTemplateJson);
+    });
+    it("performs lodash merge-template when specified", async ()=>{
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: "merge-template"
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "b1",
+                    "b2"
+                ],
+                extra2: "extra2",
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs lodash merge-current when specified", async ()=>{
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: "merge-current"
+        }))).toEqual({
+            here: "here",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ],
+                extra2: "extra2",
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges with default non-path values", async ()=>{
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.arr1",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.el1",
+                        "overwrite"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            // This is the extra here since we add missing
+            extra: "extra",
+            another: 23,
+            inner: {
+                // This will stay here
+                el1: "el1",
+                arr1: [
+                    "b1",
+                    "b2"
+                ],
+                // extra2 doesn't show up since we didn't dictate it
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges with missing deletions", async ()=>{
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                missingIsDelete: true,
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested",
+                        "overwrite"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ]
+            }
+        });
+    });
+    it("performs pathjson merges with ignore new", async ()=>{
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                ignoreNewProperties: true,
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.arr1",
+                        "merge-template"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            //  extra: 'extra', - not added
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "b1",
+                    "b2"
+                ],
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges with no missing delete", async ()=>{
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(templateFileJson), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested",
+                        "merge-template"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ],
+                nested: {
+                    final: "final",
+                    final2: "final2"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges on multipath selection", async ()=>{
+        const template = {
+            ...templateFileJson
+        };
+        template.inner.nested = {
+            final: {
+                something: 44
+            },
+            newThing: "this"
+        };
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(template), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.*",
+                        "merge-template"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ],
+                nested: {
+                    final: {
+                        something: 44
+                    },
+                    final2: "final2",
+                    newThing: "this"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges on stacked selections", async ()=>{
+        const template = {
+            ...templateFileJson
+        };
+        template.inner.nested = {
+            final: {
+                something: 44
+            },
+            newThing: "this"
+        };
+        expect(JSON.parse(await (0, _jsonmerge.merge)(JSON.stringify(testFileJson), JSON.stringify(template), {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.*",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.final",
+                        "merge-current"
+                    ]
+                ]
+            }
+        }))).toEqual({
+            here: "heretemplate",
+            extra: "extra",
+            another: 23,
+            inner: {
+                el1: "el1",
+                arr1: [
+                    "a1",
+                    "a2"
+                ],
+                nested: {
+                    final: "final",
+                    final2: "final2",
+                    // We only added the newThing
+                    newThing: "this"
+                }
+            }
+        });
+    });
+    it("performs pathjson merges on comment json", async ()=>{
+        const template = {
+            ...templateFileJson
+        };
+        template.inner.nested = {
+            final: {
+                something: 44
+            },
+            newThing: "this"
+        };
+        const testTemplateCommentJson = `{
+      "here": "heretemplate",
+      /** New comment explaining extra **/
+      "extra": "extra",
+      "inner": {
+        "arr1": ["b1", "b2"],
+        "extra2": "extra2",
+        "nested": {
+          "final": {
+            // New comment explaining final
+            "something": 44,
+          },
+          "newThing": {
+            // new thing comment
+            "this": 23,
+          },
+        }
+      },
+    }`;
+        expect(_commentjson.stringify(_commentjson.parse(await (0, _jsonmerge.merge)(testCommentJson, testTemplateCommentJson, {
+            relFilePath: "somepath",
+            mergeArguments: {
+                paths: [
+                    [
+                        "$.here",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.*",
+                        "merge-template"
+                    ],
+                    [
+                        "$.inner.nested.final",
+                        "merge-current"
+                    ]
+                ]
+            }
+        })), null, 4)).toEqual(_commentjson.stringify(_commentjson.parse(`{
+        // This is a top comment
+        "here": "heretemplate",
+        "another": 23, // this is inline
+        "inner": {
+          "el1": "el1",
+          "arr1": ["a1", "a2"],
+          "nested": {
+            // Upper comment
+            "final": "final", // Inline commment
+            "final2": "final2",
+            "newThing": {
+              // new thing comment
+              "this": 23,
+            },
+          },
+        },
+        "extra": "extra",
+      }`), null, 4));
+    });
+});
+describe("validate", ()=>{
+    it("passes correct flat mapped values", ()=>{
+        expect((0, _jsonmerge.validate)("merge-template")).toEqual([]);
+    });
+    it("passes correct options object", ()=>{
+        expect((0, _jsonmerge.validate)({
+            ignoreNewProperties: true,
+            missingIsDelete: false,
+            paths: [
+                [
+                    "$.something",
+                    "merge-current"
+                ],
+                [
+                    "$.something[*].values",
+                    "merge-current"
+                ]
+            ]
+        })).toEqual([]);
+    });
+    it("returns an error if a flat map value is not correct", ()=>{
+        expect((0, _jsonmerge.validate)("bad-merge-options")).toEqual([
+            "bad-merge-options must be one of type overwrite, merge-template, or merge-current"
+        ]);
+    });
+    it("returns an unknown key exits in options object", ()=>{
+        expect((0, _jsonmerge.validate)({
+            unknownKey: "something",
+            paths: [
+                [
+                    "$.here",
+                    "merge-template"
+                ],
+                [
+                    "$.inner.nested.*",
+                    "merge-template"
+                ],
+                [
+                    "$.inner.nested.final",
+                    "merge-current"
+                ]
+            ]
+        })).toEqual([
+            "Unrecognized key: unknownKey"
+        ]);
+    });
+    it("returns a type error if the options object is an array", ()=>{
+        expect((0, _jsonmerge.validate)([])).toEqual([
+            "Options must be an object and not Array"
+        ]);
+    });
+    it("returns a type error if the options object is  null", ()=>{
+        expect((0, _jsonmerge.validate)(null)).toEqual([
+            "Options cannot be null"
+        ]);
+    });
+    it("returns a type error for each path that is invalid", ()=>{
+        expect((0, _jsonmerge.validate)({
+            paths: [
+                [
+                    "$.badc/value",
+                    "merge-template"
+                ],
+                [
+                    "no$",
+                    "merge-template"
+                ],
+                [
+                    "$.something",
+                    "not a value"
+                ]
+            ]
+        })).toEqual([
+            "Invalid jsonpath key: Error: Lexical error on line 1. Unrecognized text.\n$.badc/value\n------^",
+            "Unrecognized jsonpath syntax: no$",
+            "jsonpath $.something: not a value must be one of type overwrite, merge-template, or merge-current"
+        ]);
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/plugins/json-merge.spec.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport * as commentJson from \"comment-json\";\nimport type { JsonPathOverrides } from \"../types\";\nimport { merge, validate } from \"./json-merge\";\n\nconst testFileJson = {\n\there: \"here\",\n\tanother: 23,\n\tinner: {\n\t\tel1: \"el1\",\n\t\tarr1: [\"a1\", \"a2\"],\n\t\tnested: {\n\t\t\tfinal: \"final\",\n\t\t\tfinal2: \"final2\",\n\t\t},\n\t},\n};\n\nconst templateFileJson = {\n\there: \"heretemplate\",\n\textra: \"extra\",\n\tinner: {\n\t\tarr1: [\"b1\", \"b2\"],\n\t\textra2: \"extra2\",\n\t},\n};\n\nconst testCommentJson = `{\n  // This is a top comment\n  \"here\": \"here\",\n  \"another\": 23, // this is inline\n  \"inner\": {\n    \"el1\": \"el1\",\n    \"arr1\": [\"a1\", \"a2\"],\n    \"nested\": {\n      // Upper comment\n      \"final\": \"final\", // Inline commment\n      \"final2\": \"final2\",\n    },\n  },\n}`;\n\ndescribe(\"merge\", () => {\n\tit(\"performs overwrite when specified\", async () => {\n\t\tconst fromTemplateJson = {\n\t\t\tfullOverride: true,\n\t\t};\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(fromTemplateJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: \"overwrite\",\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual(fromTemplateJson);\n\t});\n\tit(\"performs lodash merge-template when specified\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: \"merge-template\",\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"b1\", \"b2\"],\n\t\t\t\textra2: \"extra2\",\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs lodash merge-current when specified\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: \"merge-current\",\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t),\n\t\t).toEqual({\n\t\t\there: \"here\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\textra2: \"extra2\",\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges with default non-path values\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.arr1\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.el1\", \"overwrite\"],\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),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\t// This is the extra here since we add missing\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\t// This will stay here\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"b1\", \"b2\"],\n\t\t\t\t// extra2 doesn't show up since we didn't dictate it\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges with missing deletions\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tmissingIsDelete: true,\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.nested\", \"overwrite\"],\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),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\t// nested is gone because it was undefined\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges with ignore new\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tignoreNewProperties: true,\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.arr1\", \"merge-template\"],\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),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\t//  extra: 'extra', - not added\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"b1\", \"b2\"],\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges with no missing delete\", async () => {\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(\n\t\t\t\t\tJSON.stringify(testFileJson),\n\t\t\t\t\tJSON.stringify(templateFileJson),\n\t\t\t\t\t{\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.nested\", \"merge-template\"],\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),\n\t\t).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges on multipath selection\", async () => {\n\t\tconst template = { ...templateFileJson };\n\t\t(template.inner as any).nested = {\n\t\t\tfinal: { something: 44 },\n\t\t\tnewThing: \"this\",\n\t\t};\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(JSON.stringify(testFileJson), JSON.stringify(template), {\n\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t[\"$.inner.nested.*\", \"merge-template\"],\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).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: { something: 44 },\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t\tnewThing: \"this\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges on stacked selections\", async () => {\n\t\tconst template = { ...templateFileJson };\n\t\t(template.inner as any).nested = {\n\t\t\tfinal: { something: 44 },\n\t\t\tnewThing: \"this\",\n\t\t};\n\t\texpect(\n\t\t\tJSON.parse(\n\t\t\t\tawait merge(JSON.stringify(testFileJson), JSON.stringify(template), {\n\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t[\"$.inner.nested.*\", \"merge-template\"],\n\t\t\t\t\t\t\t[\"$.inner.nested.final\", \"merge-current\"],\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).toEqual({\n\t\t\there: \"heretemplate\",\n\t\t\textra: \"extra\",\n\t\t\tanother: 23,\n\t\t\tinner: {\n\t\t\t\tel1: \"el1\",\n\t\t\t\tarr1: [\"a1\", \"a2\"],\n\t\t\t\tnested: {\n\t\t\t\t\tfinal: \"final\",\n\t\t\t\t\tfinal2: \"final2\",\n\t\t\t\t\t// We only added the newThing\n\t\t\t\t\tnewThing: \"this\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t});\n\tit(\"performs pathjson merges on comment json\", async () => {\n\t\tconst template = { ...templateFileJson };\n\t\t(template.inner as any).nested = {\n\t\t\tfinal: { something: 44 },\n\t\t\tnewThing: \"this\",\n\t\t};\n\n\t\tconst testTemplateCommentJson = `{\n      \"here\": \"heretemplate\",\n      /** New comment explaining extra **/\n      \"extra\": \"extra\",\n      \"inner\": {\n        \"arr1\": [\"b1\", \"b2\"],\n        \"extra2\": \"extra2\",\n        \"nested\": {\n          \"final\": {\n            // New comment explaining final\n            \"something\": 44,\n          },\n          \"newThing\": {\n            // new thing comment\n            \"this\": 23,\n          },\n        }\n      },\n    }`;\n\n\t\texpect(\n\t\t\tcommentJson.stringify(\n\t\t\t\tcommentJson.parse(\n\t\t\t\t\tawait merge(testCommentJson, testTemplateCommentJson, {\n\t\t\t\t\t\trelFilePath: \"somepath\",\n\t\t\t\t\t\tmergeArguments: {\n\t\t\t\t\t\t\tpaths: [\n\t\t\t\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.nested.*\", \"merge-template\"],\n\t\t\t\t\t\t\t\t[\"$.inner.nested.final\", \"merge-current\"],\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\tnull,\n\t\t\t\t4,\n\t\t\t),\n\t\t).toEqual(\n\t\t\tcommentJson.stringify(\n\t\t\t\tcommentJson.parse(`{\n        // This is a top comment\n        \"here\": \"heretemplate\",\n        \"another\": 23, // this is inline\n        \"inner\": {\n          \"el1\": \"el1\",\n          \"arr1\": [\"a1\", \"a2\"],\n          \"nested\": {\n            // Upper comment\n            \"final\": \"final\", // Inline commment\n            \"final2\": \"final2\",\n            \"newThing\": {\n              // new thing comment\n              \"this\": 23,\n            },\n          },\n        },\n        \"extra\": \"extra\",\n      }`),\n\t\t\t\tnull,\n\t\t\t\t4,\n\t\t\t),\n\t\t);\n\t});\n});\n\ndescribe(\"validate\", () => {\n\tit(\"passes correct flat mapped values\", () => {\n\t\texpect(validate(\"merge-template\")).toEqual([]);\n\t});\n\tit(\"passes correct options object\", () => {\n\t\texpect(\n\t\t\tvalidate({\n\t\t\t\tignoreNewProperties: true,\n\t\t\t\tmissingIsDelete: false,\n\t\t\t\tpaths: [\n\t\t\t\t\t[\"$.something\", \"merge-current\"],\n\t\t\t\t\t[\"$.something[*].values\", \"merge-current\"],\n\t\t\t\t],\n\t\t\t} as JsonPathOverrides),\n\t\t).toEqual([]);\n\t});\n\tit(\"returns an error if a flat map value is not correct\", () => {\n\t\texpect(validate(\"bad-merge-options\")).toEqual([\n\t\t\t\"bad-merge-options must be one of type overwrite, merge-template, or merge-current\",\n\t\t]);\n\t});\n\tit(\"returns an unknown key exits in options object\", () => {\n\t\texpect(\n\t\t\tvalidate({\n\t\t\t\tunknownKey: \"something\",\n\t\t\t\tpaths: [\n\t\t\t\t\t[\"$.here\", \"merge-template\"],\n\t\t\t\t\t[\"$.inner.nested.*\", \"merge-template\"],\n\t\t\t\t\t[\"$.inner.nested.final\", \"merge-current\"],\n\t\t\t\t],\n\t\t\t}),\n\t\t).toEqual([\"Unrecognized key: unknownKey\"]);\n\t});\n\tit(\"returns a type error if the options object is an array\", () => {\n\t\texpect(validate([])).toEqual([\"Options must be an object and not Array\"]);\n\t});\n\tit(\"returns a type error if the options object is  null\", () => {\n\t\texpect(validate(null)).toEqual([\"Options cannot be null\"]);\n\t});\n\tit(\"returns a type error for each path that is invalid\", () => {\n\t\texpect(\n\t\t\tvalidate({\n\t\t\t\tpaths: [\n\t\t\t\t\t[\"$.badc/value\", \"merge-template\"],\n\t\t\t\t\t[\"no$\", \"merge-template\"],\n\t\t\t\t\t[\"$.something\", \"not a value\"],\n\t\t\t\t],\n\t\t\t}),\n\t\t).toEqual([\n\t\t\t\"Invalid jsonpath key: Error: Lexical error on line 1. Unrecognized text.\\n$.badc/value\\n------^\",\n\t\t\t\"Unrecognized jsonpath syntax: no$\",\n\t\t\t\"jsonpath $.something: not a value must be one of type overwrite, merge-template, or merge-current\",\n\t\t]);\n\t});\n});\n"],"names":["testFileJson","here","another","inner","el1","arr1","nested","final","final2","templateFileJson","extra","extra2","testCommentJson","describe","it","fromTemplateJson","fullOverride","expect","JSON","parse","merge","stringify","relFilePath","mergeArguments","toEqual","paths","missingIsDelete","ignoreNewProperties","template","something","newThing","testTemplateCommentJson","commentJson","validate","unknownKey"],"mappings":"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"}

package/dist/cjs/ref-drivers/git-current-ref.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "gitCurrentRef", {
+    enumerable: true,
+    get: function() {
+        return gitCurrentRef;
+    }
+});
+const _child_process = require("child_process");
+async function gitCurrentRef(options) {
+    return (0, _child_process.execSync)(`git rev-parse HEAD`, {
+        cwd: options.rootDir
+    }).toString().trim();
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZWYtZHJpdmVycy9naXQtY3VycmVudC1yZWYudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZXhlY1N5bmMgfSBmcm9tIFwiY2hpbGRfcHJvY2Vzc1wiO1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZ2l0Q3VycmVudFJlZihvcHRpb25zOiB7IHJvb3REaXI6IHN0cmluZyB9KSB7XG5cdHJldHVybiBleGVjU3luYyhgZ2l0IHJldi1wYXJzZSBIRUFEYCwge1xuXHRcdGN3ZDogb3B0aW9ucy5yb290RGlyLFxuXHR9KVxuXHRcdC50b1N0cmluZygpXG5cdFx0LnRyaW0oKTtcbn1cbiJdLCJuYW1lcyI6WyJnaXRDdXJyZW50UmVmIiwib3B0aW9ucyIsImV4ZWNTeW5jIiwiY3dkIiwicm9vdERpciIsInRvU3RyaW5nIiwidHJpbSJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFFc0JBOzs7ZUFBQUE7OzsrQkFGRztBQUVsQixlQUFlQSxjQUFjQyxPQUE0QjtJQUMvRCxPQUFPQyxJQUFBQSx1QkFBUSxFQUFDLENBQUMsa0JBQWtCLENBQUMsRUFBRTtRQUNyQ0MsS0FBS0YsUUFBUUcsT0FBTztJQUNyQixHQUNFQyxRQUFRLEdBQ1JDLElBQUk7QUFDUCJ9

package/dist/cjs/ref-drivers/git-current-ref.spec.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _child_process = require("child_process");
+const _gitcurrentref = require("./git-current-ref");
+describe("getCurrentRef", ()=>{
+    it("gets the current sha", async ()=>{
+        expect(await (0, _gitcurrentref.gitCurrentRef)({
+            rootDir: process.cwd()
+        })).toEqual((0, _child_process.execSync)("git rev-parse HEAD").toString().trim());
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZWYtZHJpdmVycy9naXQtY3VycmVudC1yZWYuc3BlYy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBleGVjU3luYyB9IGZyb20gXCJjaGlsZF9wcm9jZXNzXCI7XG5pbXBvcnQgeyBnaXRDdXJyZW50UmVmIH0gZnJvbSBcIi4vZ2l0LWN1cnJlbnQtcmVmXCI7XG5cbmRlc2NyaWJlKFwiZ2V0Q3VycmVudFJlZlwiLCAoKSA9PiB7XG5cdGl0KFwiZ2V0cyB0aGUgY3VycmVudCBzaGFcIiwgYXN5bmMgKCkgPT4ge1xuXHRcdGV4cGVjdChcblx0XHRcdGF3YWl0IGdpdEN1cnJlbnRSZWYoe1xuXHRcdFx0XHRyb290RGlyOiBwcm9jZXNzLmN3ZCgpLFxuXHRcdFx0fSksXG5cdFx0KS50b0VxdWFsKGV4ZWNTeW5jKFwiZ2l0IHJldi1wYXJzZSBIRUFEXCIpLnRvU3RyaW5nKCkudHJpbSgpKTtcblx0fSk7XG59KTtcbiJdLCJuYW1lcyI6WyJkZXNjcmliZSIsIml0IiwiZXhwZWN0IiwiZ2l0Q3VycmVudFJlZiIsInJvb3REaXIiLCJwcm9jZXNzIiwiY3dkIiwidG9FcXVhbCIsImV4ZWNTeW5jIiwidG9TdHJpbmciLCJ0cmltIl0sIm1hcHBpbmdzIjoiOzs7OytCQUF5QjsrQkFDSztBQUU5QkEsU0FBUyxpQkFBaUI7SUFDekJDLEdBQUcsd0JBQXdCO1FBQzFCQyxPQUNDLE1BQU1DLElBQUFBLDRCQUFhLEVBQUM7WUFDbkJDLFNBQVNDLFFBQVFDLEdBQUc7UUFDckIsSUFDQ0MsT0FBTyxDQUFDQyxJQUFBQSx1QkFBUSxFQUFDLHNCQUFzQkMsUUFBUSxHQUFHQyxJQUFJO0lBQ3pEO0FBQ0QifQ==

package/dist/cjs/ref-drivers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./git-current-ref"), 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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZWYtZHJpdmVycy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9naXQtY3VycmVudC1yZWZcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O3FCQUFjIn0=

package/dist/cjs/ref-drivers/types.js

@@ -0,0 +1,11 @@
+/**
+ * A function that operates within the root dir and returns the
+ * current ref for its state.  This abstracts the idea of getting
+ * the current commit sha, so that things like other custom templating
+ * frameworks can provide their own ref
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yZWYtZHJpdmVycy90eXBlcy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgZnVuY3Rpb24gdGhhdCBvcGVyYXRlcyB3aXRoaW4gdGhlIHJvb3QgZGlyIGFuZCByZXR1cm5zIHRoZVxuICogY3VycmVudCByZWYgZm9yIGl0cyBzdGF0ZS4gIFRoaXMgYWJzdHJhY3RzIHRoZSBpZGVhIG9mIGdldHRpbmdcbiAqIHRoZSBjdXJyZW50IGNvbW1pdCBzaGEsIHNvIHRoYXQgdGhpbmdzIGxpa2Ugb3RoZXIgY3VzdG9tIHRlbXBsYXRpbmdcbiAqIGZyYW1ld29ya3MgY2FuIHByb3ZpZGUgdGhlaXIgb3duIHJlZlxuICovXG5leHBvcnQgdHlwZSBUZW1wbGF0ZVJlZkRyaXZlckZuID0gKG9wdGlvbnM6IHtcblx0LyoqIFRoZSByb290IGRpciB3aGVyZSB3ZSB3YW50IHRvIGdldCB0aGUgXCJjdXJyZW50XCIgcmVmICovXG5cdHJvb3REaXI6IHN0cmluZztcbn0pID0+IFByb21pc2U8c3RyaW5nPjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Q0FLQyJ9