@geospatial-sdk/core 0.0.5-alpha.2 → 0.0.5-alpha.9

package/dist/lib/utils/map-context-diff.test.js

@@ -1,217 +0,0 @@
-import { computeMapContextDiff } from "./map-context-diff";
-import { SAMPLE_CONTEXT, SAMPLE_LAYER1, SAMPLE_LAYER2, SAMPLE_LAYER3, SAMPLE_LAYER4, SAMPLE_LAYER5, } from "../../fixtures/map-context.fixtures";
-describe("Context diff utils", () => {
-    describe("computeMapContextDiff", () => {
-        let contextOld;
-        let contextNew;
-        let diff;
-        describe("no change", () => {
-            beforeEach(() => {
-                contextOld = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER2, SAMPLE_LAYER1] });
-                contextNew = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER2, SAMPLE_LAYER1] });
-            });
-            it("outputs the correct diff", () => {
-                diff = computeMapContextDiff(contextNew, contextOld);
-                expect(diff).toEqual({
-                    layersAdded: [],
-                    layersChanged: [],
-                    layersRemoved: [],
-                    layersReordered: [],
-                    viewChanges: {},
-                });
-            });
-        });
-        describe("layers added", () => {
-            beforeEach(() => {
-                contextOld = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER1] });
-                contextNew = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER2, SAMPLE_LAYER1, SAMPLE_LAYER4] });
-            });
-            it("outputs the correct diff", () => {
-                diff = computeMapContextDiff(contextNew, contextOld);
-                expect(diff).toEqual({
-                    layersAdded: [
-                        {
-                            layer: SAMPLE_LAYER2,
-                            position: 0,
-                        },
-                        {
-                            layer: SAMPLE_LAYER4,
-                            position: 2,
-                        },
-                    ],
-                    layersChanged: [],
-                    layersRemoved: [],
-                    layersReordered: [],
-                    viewChanges: {},
-                });
-            });
-        });
-        describe("layers removed", () => {
-            beforeEach(() => {
-                contextOld = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER2, SAMPLE_LAYER1, SAMPLE_LAYER4] });
-                contextNew = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER4] });
-            });
-            it("outputs the correct diff", () => {
-                diff = computeMapContextDiff(contextNew, contextOld);
-                expect(diff).toEqual({
-                    layersAdded: [],
-                    layersChanged: [],
-                    layersRemoved: [
-                        {
-                            layer: SAMPLE_LAYER2,
-                            position: 0,
-                        },
-                        {
-                            layer: SAMPLE_LAYER1,
-                            position: 1,
-                        },
-                    ],
-                    layersReordered: [],
-                    viewChanges: {},
-                });
-            });
-        });
-        describe("layers changed", () => {
-            beforeEach(() => {
-                contextOld = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER2, Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: 123, version: 3 })] });
-                contextNew = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [
-                        Object.assign(Object.assign({}, SAMPLE_LAYER2), { extras: { prop: true } }),
-                        Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: 123, version: 10 }),
-                    ] });
-            });
-            it("outputs the correct diff", () => {
-                diff = computeMapContextDiff(contextNew, contextOld);
-                expect(diff).toEqual({
-                    layersAdded: [],
-                    layersChanged: [
-                        {
-                            layer: contextNew.layers[0],
-                            position: 0,
-                        },
-                        {
-                            layer: contextNew.layers[1],
-                            position: 1,
-                        },
-                    ],
-                    layersRemoved: [],
-                    layersReordered: [],
-                    viewChanges: {},
-                });
-            });
-        });
-        describe("reordering", () => {
-            describe("three layers reordered", () => {
-                beforeEach(() => {
-                    contextOld = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER1, SAMPLE_LAYER2, SAMPLE_LAYER3] });
-                    contextNew = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER2, SAMPLE_LAYER1, SAMPLE_LAYER3] });
-                });
-                it("outputs the correct diff", () => {
-                    diff = computeMapContextDiff(contextNew, contextOld);
-                    expect(diff).toEqual({
-                        layersAdded: [],
-                        layersChanged: [],
-                        layersRemoved: [],
-                        layersReordered: [
-                            {
-                                layer: SAMPLE_LAYER2,
-                                newPosition: 0,
-                                previousPosition: 1,
-                            },
-                            {
-                                layer: SAMPLE_LAYER1,
-                                newPosition: 1,
-                                previousPosition: 0,
-                            },
-                        ],
-                        viewChanges: {},
-                    });
-                });
-            });
-            describe("four layers reordered", () => {
-                beforeEach(() => {
-                    contextOld = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [
-                            SAMPLE_LAYER1,
-                            SAMPLE_LAYER3,
-                            SAMPLE_LAYER4,
-                            SAMPLE_LAYER2,
-                        ] });
-                    contextNew = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [
-                            SAMPLE_LAYER4,
-                            SAMPLE_LAYER3,
-                            SAMPLE_LAYER1,
-                            SAMPLE_LAYER2,
-                        ] });
-                });
-                it("outputs the correct diff", () => {
-                    diff = computeMapContextDiff(contextNew, contextOld);
-                    expect(diff).toEqual({
-                        layersAdded: [],
-                        layersChanged: [],
-                        layersRemoved: [],
-                        layersReordered: [
-                            {
-                                layer: SAMPLE_LAYER4,
-                                newPosition: 0,
-                                previousPosition: 2,
-                            },
-                            {
-                                layer: SAMPLE_LAYER1,
-                                newPosition: 2,
-                                previousPosition: 0,
-                            },
-                        ],
-                        viewChanges: {},
-                    });
-                });
-            });
-        });
-        describe("combined changes", () => {
-            let changedLayer;
-            beforeEach(() => {
-                changedLayer = Object.assign(Object.assign({}, SAMPLE_LAYER3), { extras: { prop: true } });
-                contextOld = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER1, SAMPLE_LAYER5, SAMPLE_LAYER3, SAMPLE_LAYER4] });
-                contextNew = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER2, changedLayer, SAMPLE_LAYER5] });
-            });
-            it("outputs the correct diff", () => {
-                diff = computeMapContextDiff(contextNew, contextOld);
-                expect(diff).toEqual({
-                    layersAdded: [
-                        {
-                            layer: SAMPLE_LAYER2,
-                            position: 0,
-                        },
-                    ],
-                    layersChanged: [
-                        {
-                            layer: changedLayer,
-                            position: 1,
-                        },
-                    ],
-                    layersRemoved: [
-                        {
-                            layer: SAMPLE_LAYER1,
-                            position: 0,
-                        },
-                        {
-                            layer: SAMPLE_LAYER4,
-                            position: 3,
-                        },
-                    ],
-                    layersReordered: [
-                        {
-                            layer: changedLayer,
-                            newPosition: 1,
-                            previousPosition: 2,
-                        },
-                        {
-                            layer: SAMPLE_LAYER5,
-                            newPosition: 2,
-                            previousPosition: 1,
-                        },
-                    ],
-                    viewChanges: {},
-                });
-            });
-        });
-    });
-});

package/dist/lib/utils/map-context.d.ts

@@ -1,6 +0,0 @@
-import { MapContext, MapContextLayer } from "../model";
-export declare function getLayerHash(layer: MapContextLayer, includeExtras?: boolean): string;
-export declare function isLayerSame(layerA: MapContextLayer, layerB: MapContextLayer): boolean;
-export declare function isLayerSameAndUnchanged(layerA: MapContextLayer, layerB: MapContextLayer): boolean;
-export declare function getLayerPosition(context: MapContext, layerModel: MapContextLayer): number;
-//# sourceMappingURL=map-context.d.ts.map

package/dist/lib/utils/map-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map-context.d.ts","sourceRoot":"","sources":["../../../lib/utils/map-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEvD,wBAAgB,YAAY,CAC1B,KAAK,EAAE,eAAe,EACtB,aAAa,UAAQ,GACpB,MAAM,CAkBR;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,eAAe,GACtB,OAAO,CAKT;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,eAAe,GACtB,OAAO,CAKT;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,eAAe,GAC1B,MAAM,CAER"}

package/dist/lib/utils/map-context.js

@@ -1,36 +0,0 @@
-export function getLayerHash(layer, includeExtras = false) {
-    function getHash(input) {
-        if (input instanceof Object) {
-            const obj = {};
-            const keys = Object.keys(input).sort();
-            for (const key of keys) {
-                if (!includeExtras && key === "extras")
-                    continue;
-                obj[key] = getHash(input[key]);
-            }
-            const hash = JSON.stringify(obj)
-                .split("")
-                .reduce((prev, curr) => (prev << 5) - prev + curr.charCodeAt(0), 0);
-            return (hash >>> 0).toString();
-        }
-        else {
-            return JSON.stringify(input);
-        }
-    }
-    return getHash(layer);
-}
-export function isLayerSame(layerA, layerB) {
-    if ("id" in layerA && "id" in layerB) {
-        return layerA.id == layerB.id;
-    }
-    return getLayerHash(layerA) === getLayerHash(layerB);
-}
-export function isLayerSameAndUnchanged(layerA, layerB) {
-    if ("id" in layerA && "id" in layerB) {
-        return layerA.id == layerB.id && layerA.version == layerB.version;
-    }
-    return getLayerHash(layerA, true) === getLayerHash(layerB, true);
-}
-export function getLayerPosition(context, layerModel) {
-    return context.layers.findIndex((l) => isLayerSame(layerModel, l));
-}

package/dist/lib/utils/map-context.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=map-context.test.d.ts.map

package/dist/lib/utils/map-context.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map-context.test.d.ts","sourceRoot":"","sources":["../../../lib/utils/map-context.test.ts"],"names":[],"mappings":""}

package/dist/lib/utils/map-context.test.js

@@ -1,131 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { describe } from "vitest";
-import { getLayerHash, getLayerPosition, isLayerSame, isLayerSameAndUnchanged, } from "./map-context";
-import { SAMPLE_CONTEXT, SAMPLE_LAYER1, SAMPLE_LAYER2, } from "../../fixtures/map-context.fixtures";
-describe("Map context utils", () => {
-    describe("isLayerSame", () => {
-        describe("layers with id", () => {
-            it("compares non-strictly by id", () => {
-                expect(isLayerSame(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "a" }), Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "b" }))).toBe(false);
-                expect(isLayerSame(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "ab" }), Object.assign(Object.assign({}, SAMPLE_LAYER2), { id: "ab" }))).toBe(true);
-                expect(isLayerSame(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: 1 }), Object.assign(Object.assign({}, SAMPLE_LAYER2), { id: "01" }))).toBe(true);
-                expect(isLayerSame(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: 1 }), Object.assign(Object.assign({}, SAMPLE_LAYER2), { id: 1 }))).toBe(true);
-                expect(isLayerSame(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: 1 }), Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: 2 }))).toBe(false);
-            });
-        });
-        describe("layers without id", () => {
-            it("compares by properties", () => {
-                expect(isLayerSame(SAMPLE_LAYER1, SAMPLE_LAYER1)).toBe(true);
-                expect(isLayerSame(SAMPLE_LAYER1, Object.assign(Object.assign({}, SAMPLE_LAYER1), { name: "abc" }))).toBe(false);
-                expect(isLayerSame(Object.assign(Object.assign({}, SAMPLE_LAYER1), { url: "http://abc.org", name: SAMPLE_LAYER1.name }), Object.assign(Object.assign({}, SAMPLE_LAYER1), { url: "http://abc.org" }))).toBe(true);
-                expect(isLayerSame(SAMPLE_LAYER1, SAMPLE_LAYER2)).toBe(false);
-            });
-            it("ignores extras prop", () => {
-                expect(isLayerSame(SAMPLE_LAYER1, Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: { otherProp: "abc" } }))).toBe(true);
-                expect(isLayerSame(SAMPLE_LAYER1, Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: undefined }))).toBe(true);
-                const { extras } = SAMPLE_LAYER1, layer = __rest(SAMPLE_LAYER1, ["extras"]);
-                expect(isLayerSame(SAMPLE_LAYER1, layer)).toBe(true);
-            });
-        });
-        describe("layers with and without id", () => {
-            it("compares by properties", () => {
-                expect(isLayerSame(SAMPLE_LAYER1, Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "123" }))).toBe(false);
-                expect(isLayerSame(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "123" }), Object.assign(Object.assign({ id: "123" }, SAMPLE_LAYER1), { name: SAMPLE_LAYER1.name }))).toBe(true);
-            });
-        });
-    });
-    describe("isLayerSameAndUnchanged", () => {
-        describe("layers with id", () => {
-            it("compares non-strictly by id and version field", () => {
-                expect(isLayerSameAndUnchanged(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "a" }), Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "b" }))).toBe(false);
-                expect(isLayerSameAndUnchanged(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "a" }), Object.assign(Object.assign({}, SAMPLE_LAYER2), { id: "a" }))).toBe(true);
-                expect(isLayerSameAndUnchanged(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "ab", version: 2 }), Object.assign(Object.assign({}, SAMPLE_LAYER2), { id: "ab", version: 2 }))).toBe(true);
-                expect(isLayerSameAndUnchanged(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "ab", version: 2 }), Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "ab", version: 1 }))).toBe(false);
-                expect(isLayerSameAndUnchanged(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: 1 }), Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "01", version: 3 }))).toBe(false);
-            });
-        });
-        describe("layers without id", () => {
-            it("compares by properties, including extras", () => {
-                expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, SAMPLE_LAYER1)).toBe(true);
-                expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, Object.assign(Object.assign({}, SAMPLE_LAYER1), { name: "abc" }))).toBe(false);
-                expect(isLayerSameAndUnchanged(Object.assign(Object.assign({}, SAMPLE_LAYER1), { url: "http://abc.org", name: SAMPLE_LAYER1.name }), Object.assign(Object.assign({}, SAMPLE_LAYER1), { url: "http://abc.org" }))).toBe(true);
-                expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, SAMPLE_LAYER2)).toBe(false);
-            });
-            it("takes into account extras prop", () => {
-                expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: { otherProp: "abc" } }))).toBe(false);
-                expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: undefined }))).toBe(false);
-                const { extras } = SAMPLE_LAYER1, layer = __rest(SAMPLE_LAYER1, ["extras"]);
-                expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, layer)).toBe(false);
-            });
-        });
-        describe("layers with and without id", () => {
-            it("compares by properties", () => {
-                expect(isLayerSameAndUnchanged(SAMPLE_LAYER1, Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "123" }))).toBe(false);
-                expect(isLayerSameAndUnchanged(Object.assign(Object.assign({}, SAMPLE_LAYER1), { id: "123" }), Object.assign(Object.assign({ id: "123" }, SAMPLE_LAYER1), { name: SAMPLE_LAYER1.name }))).toBe(true);
-            });
-        });
-    });
-    describe("getLayerHash", () => {
-        it("works with serializable entities", () => {
-            expect(getLayerHash(Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: {
-                    array: [11, 22, null, undefined],
-                    object: {},
-                    undef: undefined,
-                } }))).toBeTypeOf("string");
-        });
-        it("ignores extra property by default", () => {
-            expect(getLayerHash(Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: {
-                    array: [11, 22, null, undefined],
-                    object: {},
-                } }))).toEqual(getLayerHash(Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: { hello: "world" } })));
-        });
-        it("works with non-serializable entities (but they are ignored)", () => {
-            const hash = getLayerHash(Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: {
-                    func: () => 123,
-                    canvas: document.createElement("canvas"),
-                } }), true);
-            expect(hash).toBeTypeOf("string");
-            expect(hash).toEqual(getLayerHash(Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: {
-                    func: () => 456,
-                    canvas: document.createElement("div"),
-                } }), true));
-            expect(hash).not.toEqual(getLayerHash(Object.assign(Object.assign({}, SAMPLE_LAYER1), { extras: {} }), true));
-        });
-        it("does not take into account properties order", () => {
-            expect(getLayerHash({
-                type: "wms",
-                url: "http://abc.org/wms",
-                name: "myLayer",
-                extras: {
-                    array: [1, 2, 3],
-                    object: {},
-                },
-            }, true)).toEqual(getLayerHash({
-                extras: {
-                    array: [1, 2, 3],
-                    object: {},
-                },
-                url: "http://abc.org/wms",
-                type: "wms",
-                name: "myLayer",
-            }, true));
-        });
-    });
-    describe("getLayerPosition", () => {
-        it("returns the index of the layer in the context", () => {
-            const context = Object.assign(Object.assign({}, SAMPLE_CONTEXT), { layers: [SAMPLE_LAYER1, SAMPLE_LAYER2] });
-            expect(getLayerPosition(context, SAMPLE_LAYER1)).toBe(0);
-            expect(getLayerPosition(context, SAMPLE_LAYER2)).toBe(1);
-        });
-    });
-});

package/dist/lib/utils/url.d.ts

@@ -1,7 +0,0 @@
-/**
- * Removes the given search params from the URL completely; this is case-insensitive
- * @param url
- * @param searchParams
- */
-export declare function removeSearchParams(url: string, searchParams: string[]): string;
-//# sourceMappingURL=url.d.ts.map

package/dist/lib/utils/url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../lib/utils/url.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EAAE,GACrB,MAAM,CAWR"}

package/dist/lib/utils/url.js

@@ -1,17 +0,0 @@
-/**
- * Removes the given search params from the URL completely; this is case-insensitive
- * @param url
- * @param searchParams
- */
-export function removeSearchParams(url, searchParams) {
-    const toDelete = [];
-    const urlObj = new URL(url, window.location.toString());
-    const keysLower = searchParams.map((p) => p.toLowerCase());
-    for (const param of urlObj.searchParams.keys()) {
-        if (keysLower.indexOf(param.toLowerCase()) > -1) {
-            toDelete.push(param);
-        }
-    }
-    toDelete.map((param) => urlObj.searchParams.delete(param));
-    return urlObj.toString();
-}

package/dist/lib/utils/url.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=url.test.d.ts.map

package/dist/lib/utils/url.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"url.test.d.ts","sourceRoot":"","sources":["../../../lib/utils/url.test.ts"],"names":[],"mappings":""}

package/dist/lib/utils/url.test.js

@@ -1,8 +0,0 @@
-import { removeSearchParams } from "./url";
-describe("URL utils", () => {
-    describe("removeSearchParams", () => {
-        it("removes given search params in a case insensitive way", () => {
-            expect(removeSearchParams("http://my.org/abc/?arg0=1234&arg1=aaa&Arg1=111&ARG2=&aRG3=fff&arg4=5678", ["ARG1", "arg2", "arg3"])).toEqual("http://my.org/abc/?arg0=1234&arg4=5678");
-        });
-    });
-});

package/dist/utils/freeze.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=freeze.test.d.ts.map

package/dist/utils/freeze.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"freeze.test.d.ts","sourceRoot":"","sources":["../../lib/utils/freeze.test.ts"],"names":[],"mappings":""}

package/dist/utils/freeze.test.js

@@ -1,51 +0,0 @@
-import { deepFreeze } from "./freeze";
-describe("freeze util", () => {
-    describe("deepFreeze", () => {
-        let obj;
-        beforeEach(() => {
-            obj = deepFreeze({
-                ab: "cde",
-                fg: {
-                    h: true,
-                    ij: 12,
-                },
-                k: [
-                    {
-                        l: 456,
-                        mn: ["opqr"],
-                    },
-                ],
-            });
-        });
-        it("prevents mutation of root properties", () => {
-            expect(() => {
-                obj.ab = "AA";
-            }).toThrow();
-        });
-        it("prevents mutation of nested properties", () => {
-            expect(() => {
-                obj.fg.h = "AA";
-            }).toThrow();
-        });
-        it("prevents mutation of objects inside nested arrays", () => {
-            expect(() => {
-                obj.k[0].l = "AA";
-            }).toThrow();
-        });
-        describe("starting with array", () => {
-            beforeEach(() => {
-                obj = deepFreeze([
-                    {
-                        l: 456,
-                        mn: ["opqr"],
-                    },
-                ]);
-            });
-            it("prevents mutation of nested objects", () => {
-                expect(() => {
-                    obj[0].l = "AA";
-                }).toThrow();
-            });
-        });
-    });
-});

package/dist/utils/map-context-diff.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=map-context-diff.test.d.ts.map

package/dist/utils/map-context-diff.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"map-context-diff.test.d.ts","sourceRoot":"","sources":["../../lib/utils/map-context-diff.test.ts"],"names":[],"mappings":""}