@geospatial-sdk/core 0.0.5-alpha.1

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

@@ -0,0 +1,370 @@
+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 { deepFreeze } from "./freeze";
+import { computeMapContextDiff, getLayerHash, isLayerSame, isLayerSameAndUnchanged, } from "./map-context-diff";
+const SAMPLE_CONTEXT = deepFreeze({
+    view: {
+        center: [10, 20],
+        zoom: 3,
+        extent: [40, 50, 60, 70],
+    },
+    layers: [],
+});
+const SAMPLE_LAYER1 = deepFreeze({
+    type: "wms",
+    url: "http://abc.org/wms",
+    name: "myLayer",
+    extras: { myField: "abc" },
+});
+const SAMPLE_LAYER2 = deepFreeze({
+    type: "xyz",
+    url: "http://abc.org/tiles",
+    extras: { myField2: "123" },
+});
+const SAMPLE_LAYER3 = deepFreeze({
+    type: "geojson",
+    data: '{ "type": "Feature", "properties": {}}',
+    extras: { myField3: "000" },
+});
+const SAMPLE_LAYER4 = deepFreeze({
+    type: "wfs",
+    url: "http://abc.org/wfs",
+    featureType: "myFeatureType",
+    extras: { myField4: "aaa" },
+});
+const SAMPLE_LAYER5 = deepFreeze({
+    type: "xyz",
+    url: "http://my.tiles/server",
+});
+describe("Context diff 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("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: {},
+                });
+            });
+        });
+    });
+    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));
+        });
+    });
+});

package/dist/utils/url.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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/utils/url.d.ts.map

@@ -0,0 +1 @@
+{"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/utils/url.js

@@ -0,0 +1,17 @@
+/**
+ * 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/utils/url.test.d.ts

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

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

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

package/dist/utils/url.test.js

@@ -0,0 +1,8 @@
+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/lib/index.ts

@@ -0,0 +1,3 @@
+// PUBLIC API
+export * from "./utils";
+export * from "./model";

package/lib/model/index.ts

@@ -0,0 +1,2 @@
+export * from "./map-context";
+export * from "./map-context-diff";

package/lib/model/map-context-diff.ts

@@ -0,0 +1,37 @@
+import { MapContextLayer, MapContextView } from "./map-context";
+
+/**
+ * Associates a position to a layer; the position is the index of
+ * the layer in the layers array
+ */
+export interface MapContextLayerPositioned {
+  layer: MapContextLayer;
+  position: number;
+}
+
+/**
+ * Describes a layer being moved to a different position
+ */
+export interface MapContextLayerReordered {
+  layer: MapContextLayer;
+  newPosition: number;
+  previousPosition: number;
+}
+
+/**
+ * Describes a delta between two contexts, in order to be
+ * applied to an existing map.
+ *
+ * For positions to be correct the order of operations should be:
+ * 1. change layers
+ * 2. remove layers
+ * 3. add layers
+ * 4. move layers
+ */
+export interface MapContextDiff {
+  layersChanged: MapContextLayerPositioned[];
+  layersReordered: MapContextLayerReordered[];
+  layersRemoved: MapContextLayerPositioned[];
+  layersAdded: MapContextLayerPositioned[];
+  viewChanges: MapContextView;
+}

package/lib/model/map-context.ts

@@ -0,0 +1,96 @@
+import { FeatureCollection, Geometry } from "geojson";
+
+export type LayerDimensions = Record<string, string>;
+
+export type LayerExtras = Record<string, unknown>;
+
+export interface MapContextBaseLayer {
+  id?: string | number;
+  version?: number;
+
+  /**
+   * This property can be used to store anything application-specific on layers; as its content may occasionally
+   * be serialized to JSON for change detection purposes, it is not recommended to store Functions or other
+   * non-serializable entities
+   */
+  extras?: LayerExtras;
+}
+
+export interface MapContextLayerWms extends MapContextBaseLayer {
+  type: "wms";
+  url: string;
+  name: string;
+  dimensions?: LayerDimensions;
+  style?: string;
+}
+
+export interface MapContextLayerWmts extends MapContextBaseLayer {
+  type: "wmts";
+  url: string;
+  name: string;
+  dimensions?: LayerDimensions;
+  style?: string;
+}
+
+export interface MapContextLayerWfs extends MapContextBaseLayer {
+  type: "wfs";
+  url: string;
+  featureType: string;
+}
+
+export interface MapContextLayerXyz extends MapContextBaseLayer {
+  type: "xyz";
+  url: string;
+}
+
+interface LayerGeojson extends MapContextBaseLayer {
+  type: "geojson";
+}
+interface LayerGeojsonWithUrl extends LayerGeojson {
+  url: string;
+  data?: never;
+}
+interface LayerGeojsonWithData extends LayerGeojson {
+  data: FeatureCollection<Geometry | null> | string;
+  url?: never;
+}
+
+/**
+ * @interface
+ */
+export type MapContextLayerGeojson = LayerGeojsonWithUrl | LayerGeojsonWithData;
+
+/**
+ * @interface
+ */
+export type MapContextLayer =
+  | MapContextLayerWms
+  | MapContextLayerWmts
+  | MapContextLayerWfs
+  | MapContextLayerXyz
+  | MapContextLayerGeojson;
+
+export type Coordinate = [number, number];
+
+/**
+ * Min X, min Y, max X, max Y
+ */
+export type Extent = [number, number, number, number];
+
+/**
+ * @property center Expressed in longitude/latitude
+ * @property extent Expressed in longitude/latitude
+ * @property maxExtent Expressed in longitude/latitude
+ */
+export interface MapContextView {
+  center?: Coordinate;
+  zoom?: number;
+  extent?: Extent;
+  maxZoom?: number;
+  maxExtent?: Extent;
+}
+
+export interface MapContext {
+  layers: MapContextLayer[];
+  view: MapContextView;
+}

package/lib/utils/freeze.test.ts

@@ -0,0 +1,52 @@
+import { deepFreeze } from "./freeze";
+
+describe("freeze util", () => {
+  describe("deepFreeze", () => {
+    let obj: any;
+    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/lib/utils/freeze.ts

@@ -0,0 +1,14 @@
+export function deepFreeze<U>(obj: U): U {
+  if (Array.isArray(obj)) {
+    for (const elt of obj) {
+      deepFreeze(elt);
+    }
+    return obj;
+  } else if (obj instanceof Object) {
+    for (const prop in obj) {
+      deepFreeze((obj as Record<string, unknown>)[prop]);
+    }
+    return Object.freeze(obj);
+  }
+  return obj;
+}

package/lib/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./url";
+export * from "./freeze";
+export { computeMapContextDiff } from "./map-context-diff";