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

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

@@ -1,16 +1,5 @@
-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";
+import { computeMapContextDiff } from "./map-context-diff";
 const SAMPLE_CONTEXT = deepFreeze({
     view: {
         center: [10, 20],
@@ -46,68 +35,6 @@ const SAMPLE_LAYER5 = deepFreeze({
     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;
@@ -321,50 +248,4 @@ describe("Context diff utils", () => {
             });
         });
     });
-    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/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/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/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/utils/map-context.test.d.ts

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

package/dist/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/utils/map-context.test.js

@@ -0,0 +1,150 @@
+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 { deepFreeze } from "./freeze";
+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_CONTEXT = deepFreeze({
+    view: {
+        center: [10, 20],
+        zoom: 3,
+        extent: [40, 50, 60, 70],
+    },
+    layers: [],
+});
+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/lib/model/map-context-diff.ts

@@ -23,10 +23,10 @@ export interface MapContextLayerReordered {
  * 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
+ * 1. remove layers
+ * 2. add layers
+ * 3. move layers
+ * 4. change layers
  */
 export interface MapContextDiff {
   layersChanged: MapContextLayerPositioned[];

package/lib/utils/index.ts

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