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

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

@@ -0,0 +1,217 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,36 @@
+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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,131 @@
+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

@@ -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/lib/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/lib/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/lib/utils/url.test.d.ts

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

package/dist/lib/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/lib/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/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./url";
 export * from "./freeze";
 export { computeMapContextDiff } from "./map-context-diff";
+export { getLayerPosition } from "./map-context";
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC"}

package/dist/utils/index.js

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

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

@@ -1,7 +1,4 @@
-import { MapContext, MapContextDiff, 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;
+import { MapContext, MapContextDiff } from "../model";
 /**
  * The following logic is produced by identifying layers in both context
  * and determining whether they have been added, removed, changed or reordered.

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

@@ -1 +1 @@
-{"version":3,"file":"map-context-diff.d.ts","sourceRoot":"","sources":["../../lib/utils/map-context-diff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,cAAc,EACd,eAAe,EAIhB,MAAM,UAAU,CAAC;AAElB,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;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,UAAU,EACvB,eAAe,EAAE,UAAU,GAC1B,cAAc,CAqEhB"}
+{"version":3,"file":"map-context-diff.d.ts","sourceRoot":"","sources":["../../lib/utils/map-context-diff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,cAAc,EAKf,MAAM,UAAU,CAAC;AAGlB;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,UAAU,EACvB,eAAe,EAAE,UAAU,GAC1B,cAAc,CAqEhB"}

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

@@ -1,36 +1,4 @@
-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);
-}
+import { isLayerSame, isLayerSameAndUnchanged } from "./map-context";
 /**
  * The following logic is produced by identifying layers in both context
  * and determining whether they have been added, removed, changed or reordered.