@versatiles/svelte 2.0.1 → 2.1.0

package/dist/components/MapEditor/lib/state/history.d.ts

@@ -0,0 +1,14 @@
+import type { StateRoot } from './types.js';
+export declare class StateHistory {
+    private history;
+    private index;
+    undoEnabled: import("svelte/store").Writable<boolean>;
+    redoEnabled: import("svelte/store").Writable<boolean>;
+    constructor(state: StateRoot);
+    reset(state: StateRoot): void;
+    push(state: StateRoot): void;
+    private get;
+    undo(): StateRoot;
+    redo(): StateRoot;
+    private updateButtons;
+}

package/dist/components/MapEditor/lib/state/history.js

@@ -0,0 +1,53 @@
+import { writable } from 'svelte/store';
+const MAXLENGTH = 100;
+export class StateHistory {
+    // History of state hashes
+    // The first element is the most recent state
+    history = [];
+    // The index of the current state in the history
+    // 0 means the most recent state
+    // 1 means the second most recent state
+    index = 0;
+    undoEnabled = writable(false);
+    redoEnabled = writable(false);
+    constructor(state) {
+        this.reset(state);
+    }
+    reset(state) {
+        this.history = [];
+        this.index = 0;
+        this.push(state);
+    }
+    push(state) {
+        state.map = undefined; // Remove map state from history
+        if (this.index > 0) {
+            this.history.splice(0, this.index);
+            this.index = 0;
+        }
+        this.history.unshift(JSON.stringify(state));
+        // Remove old history
+        if (this.history.length > MAXLENGTH) {
+            this.history.length = MAXLENGTH;
+        }
+        this.updateButtons();
+    }
+    get() {
+        return JSON.parse(this.history[this.index]);
+    }
+    undo() {
+        if (this.index < this.history.length - 1)
+            this.index++;
+        this.updateButtons();
+        return this.get();
+    }
+    redo() {
+        if (this.index > 0)
+            this.index--;
+        this.updateButtons();
+        return this.get();
+    }
+    updateButtons() {
+        this.undoEnabled.set(this.index < this.history.length - 1);
+        this.redoEnabled.set(this.index > 0);
+    }
+}

package/dist/components/MapEditor/lib/state/manager.d.ts

@@ -1,17 +1,14 @@
-import type { GeometryManager } from '../geometry_manager.js';
+import type { GeometryManagerInteractive } from '../geometry_manager_interactive.js';
+import type { StateMetadata } from './types.js';
+import { StateHistory } from './history.js';
 export declare class StateManager {
-    geometryManager: GeometryManager;
+    geometryManager: GeometryManagerInteractive;
     private disableLogging;
-    constructor(geometryManager: GeometryManager);
-    getHash(): string;
+    readonly history: StateHistory;
+    constructor(geometryManager: GeometryManagerInteractive);
+    getHash(additionalMeta?: StateMetadata): string;
     setHash(hash: string): void;
-    private history;
-    private historyIndex;
-    undoEnabled: import("svelte/store").Writable<boolean>;
-    redoEnabled: import("svelte/store").Writable<boolean>;
-    private resetHistory;
     log(): void;
     undo(): void;
     redo(): void;
-    private updateButtons;
 }

package/dist/components/MapEditor/lib/state/manager.js

@@ -1,17 +1,27 @@
-import { writable } from 'svelte/store';
 import { StateReader } from './reader.js';
 import { StateWriter } from './writer.js';
-const MAXLENGTH = 100;
+import { StateHistory } from './history.js';
 export class StateManager {
     geometryManager;
     disableLogging = false;
+    history;
     constructor(geometryManager) {
         this.geometryManager = geometryManager;
-        this.resetHistory();
+        this.history = new StateHistory(geometryManager.getState());
     }
-    getHash() {
+    getHash(additionalMeta) {
         const writer = new StateWriter();
-        writer.writeRoot(this.geometryManager.getState());
+        const state = this.geometryManager.getState();
+        if (additionalMeta) {
+            state.meta ??= {};
+            const keys = Object.keys(additionalMeta);
+            for (const key of keys) {
+                if (additionalMeta[key] == null)
+                    continue;
+                state.meta[key] = additionalMeta[key];
+            }
+        }
+        writer.writeRoot(state);
         return writer.asBase64();
     }
     setHash(hash) {
@@ -22,66 +32,21 @@ export class StateManager {
             this.disableLogging = true;
             this.geometryManager.setState(state);
             this.disableLogging = false;
-            this.history = [{ ...state, map: undefined }];
-            this.historyIndex = 0;
-            this.updateButtons();
+            this.history.reset(state);
         }
         catch (error) {
             console.error(error);
         }
     }
-    // History of state hashes
-    // The first element is the most recent state
-    history = [];
-    // The index of the current state in the history
-    // 0 means the most recent state
-    // 1 means the second most recent state
-    historyIndex = 0;
-    undoEnabled = writable(false);
-    redoEnabled = writable(false);
-    resetHistory() {
-        this.history = [this.geometryManager.getState()];
-        this.historyIndex = 0;
-        this.updateButtons();
-    }
     log() {
         if (this.disableLogging)
             return;
-        const state = this.geometryManager.getState();
-        state.map = undefined; // Remove map state from history
-        if (this.historyIndex > 0) {
-            this.history.splice(0, this.historyIndex);
-            this.historyIndex = 0;
-        }
-        this.history.unshift(state);
-        // Remove old history
-        if (this.history.length > MAXLENGTH) {
-            this.history.length = MAXLENGTH;
-        }
-        this.updateButtons();
+        this.history.push(this.geometryManager.getState());
     }
     undo() {
-        if (this.historyIndex < this.history.length - 1) {
-            this.historyIndex++;
-            const state = this.history[this.historyIndex];
-            this.disableLogging = true;
-            this.geometryManager.setState(state);
-            this.disableLogging = false;
-            this.updateButtons();
-        }
+        this.geometryManager.setState(this.history.undo());
     }
     redo() {
-        if (this.historyIndex > 0) {
-            this.historyIndex--;
-            const state = this.history[this.historyIndex];
-            this.disableLogging = true;
-            this.geometryManager.setState(state);
-            this.disableLogging = false;
-            this.updateButtons();
-        }
-    }
-    updateButtons() {
-        this.undoEnabled.set(this.historyIndex < this.history.length - 1);
-        this.redoEnabled.set(this.historyIndex > 0);
+        this.geometryManager.setState(this.history.redo());
     }
 }

package/dist/components/MapEditor/lib/state/reader.d.ts

@@ -1,4 +1,4 @@
-import type { StateElementLine, StateElementMarker, StateElementPolygon, StateRoot, StateStyle } from './types.js';
+import type { StateElementCircle, StateElementLine, StateElementMarker, StateElementPolygon, StateMetadata, StateRoot, StateStyle } from './types.js';
 export declare class StateReader {
     bits: boolean[];
     offset: number;
@@ -11,13 +11,15 @@ export declare class StateReader {
     read6pack(): number;
     readVarint(signed?: true): number;
     readArray<T>(cb: () => T): T[];
-    readPoint(level?: number): [number, number];
-    readPoints(level?: number): [number, number][];
+    readPoint(resolutionInMeters?: number): [number, number];
+    readPoints(resolutionInMeters?: number): [number, number][];
     readRoot(): StateRoot;
-    readMap(): NonNullable<StateRoot['map']>;
+    readMap(): StateRoot['map'];
+    readMetadata(): StateMetadata | undefined;
     readElementMarker(): StateElementMarker;
     readElementLine(): StateElementLine;
     readElementPolygon(): StateElementPolygon;
+    readElementCircle(): StateElementCircle;
     readStyle(): StateStyle;
     readColor(): string;
     readString(): string;

package/dist/components/MapEditor/lib/state/reader.js

@@ -83,29 +83,28 @@ export class StateReader {
             throw new Error(`Error reading array`, { cause });
         }
     }
-    readPoint(level = 14) {
+    readPoint(resolutionInMeters = 1) {
+        if (!resolutionInMeters || resolutionInMeters < 1)
+            resolutionInMeters = 1;
         try {
-            const scale = Math.pow(2, level + 2);
-            return [
-                this.readInteger(level + 11, true) / scale,
-                this.readInteger(level + 10, true) / scale
-            ];
+            const scale = Math.round(1e5 / resolutionInMeters);
+            return [this.readVarint(true) / scale, this.readVarint(true) / scale];
         }
         catch (cause) {
             throw new Error(`Error reading point`, { cause });
         }
     }
-    readPoints(level = 14) {
+    readPoints(resolutionInMeters = 1) {
         try {
             const length = this.readVarint();
-            const scale = Math.pow(2, -level - 2);
+            const scale = Math.round(1e5 / resolutionInMeters);
             let x = 0;
             let y = 0;
             const points = [];
             for (let i = 0; i < length; i++) {
                 x += this.readVarint(true);
                 y += this.readVarint(true);
-                points[i] = [x * scale, y * scale];
+                points[i] = [x / scale, y / scale];
             }
             return points;
         }
@@ -121,13 +120,13 @@ export class StateReader {
                 throw new Error(`Unsupported version: ${version}`);
             }
             // Read the map element
-            if (this.readBit()) {
-                root.map = this.readMap();
-            }
+            root.map = this.readMap();
+            if (!root.map)
+                delete root.map;
             // Read the metadata
-            if (this.readBit()) {
-                throw new Error(`Metadata not supported yet`);
-            }
+            root.meta = this.readMetadata();
+            if (!root.meta)
+                delete root.meta;
             // Read the elements
             while (true) {
                 let key;
@@ -149,6 +148,9 @@ export class StateReader {
                     case 3:
                         root.elements.push(this.readElementPolygon());
                         break;
+                    case 4:
+                        root.elements.push(this.readElementCircle());
+                        break;
                     default:
                         console.warn(`Unknown state key: ${key}`);
                 }
@@ -160,19 +162,48 @@ export class StateReader {
     }
     readMap() {
         try {
-            const zoom = this.readInteger(10) / 32;
-            const center = this.readPoint(Math.ceil(zoom));
-            return { zoom, center };
+            if (!this.readBit())
+                return undefined;
+            const radius = Math.pow(2, this.readInteger(10) / 40);
+            // effective resolution of coordinates is 1000 times the visible radius
+            const center = this.readPoint(radius / 1e3);
+            if (this.readBit())
+                throw new Error('Addtional map meta data is not supported yet');
+            return { radius, center };
         }
         catch (cause) {
             throw new Error(`Error reading map`, { cause });
         }
     }
+    readMetadata() {
+        try {
+            if (!this.readBit())
+                return undefined;
+            const metadata = {};
+            while (true) {
+                const key = this.readInteger(6);
+                switch (key) {
+                    case 0:
+                        return metadata;
+                    //case 1:
+                    //	metadata.heading = this.readString();
+                    //	break;
+                    default:
+                        throw new Error(`Invalid state key: ${key}`);
+                }
+            }
+        }
+        catch (cause) {
+            throw new Error(`Error reading metadata`, { cause });
+        }
+    }
     readElementMarker() {
         try {
             const element = { type: 'marker', point: this.readPoint() };
             if (this.readBit())
                 element.style = this.readStyle();
+            if (this.readBit())
+                throw new Error(`Tooltip not supported yet`);
             return element;
         }
         catch (cause) {
@@ -184,6 +215,8 @@ export class StateReader {
             const element = { type: 'line', points: this.readPoints() };
             if (this.readBit())
                 element.style = this.readStyle();
+            if (this.readBit())
+                throw new Error(`Tooltip not supported yet`);
             return element;
         }
         catch (cause) {
@@ -197,12 +230,31 @@ export class StateReader {
                 element.style = this.readStyle();
             if (this.readBit())
                 element.strokeStyle = this.readStyle();
+            if (this.readBit())
+                throw new Error(`Tooltip not supported yet`);
             return element;
         }
         catch (cause) {
             throw new Error(`Error reading polygon element`, { cause });
         }
     }
+    readElementCircle() {
+        try {
+            const point = this.readPoint();
+            const radius = this.readVarint();
+            const element = { type: 'circle', point, radius };
+            if (this.readBit())
+                element.style = this.readStyle();
+            if (this.readBit())
+                element.strokeStyle = this.readStyle();
+            if (this.readBit())
+                throw new Error(`Tooltip not supported yet`);
+            return element;
+        }
+        catch (cause) {
+            throw new Error(`Error reading circle element`, { cause });
+        }
+    }
     readStyle() {
         try {
             const style = {};

package/dist/components/MapEditor/lib/state/types.d.ts

@@ -1,26 +1,38 @@
 export interface StateRoot {
     map?: {
         center: [number, number];
-        zoom: number;
+        radius: number;
     };
+    meta?: StateMetadata;
     elements: StateElement[];
 }
-export type StateElement = StateElementMarker | StateElementLine | StateElementPolygon;
+export type StateElement = StateElementMarker | StateElementLine | StateElementPolygon | StateElementCircle;
 export interface StateElementMarker {
     type: 'marker';
     point: [number, number];
     style?: StateStyle;
+    tooltip?: StateTooltip;
 }
 export interface StateElementLine {
     type: 'line';
     points: [number, number][];
     style?: StateStyle;
+    tooltip?: StateTooltip;
 }
 export interface StateElementPolygon {
     type: 'polygon';
     points: [number, number][];
     style?: StateStyle;
     strokeStyle?: StateStyle;
+    tooltip?: StateTooltip;
+}
+export interface StateElementCircle {
+    type: 'circle';
+    point: [number, number];
+    radius: number;
+    style?: StateStyle;
+    strokeStyle?: StateStyle;
+    tooltip?: StateTooltip;
 }
 export interface StateStyle {
     halo?: number;
@@ -34,3 +46,8 @@ export interface StateStyle {
     label?: string;
     visible?: boolean;
 }
+export interface StateMetadata {
+}
+export interface StateTooltip {
+    text?: string;
+}

package/dist/components/MapEditor/lib/state/utils.d.ts

@@ -0,0 +1,2 @@
+import type { StateStyle } from './types.js';
+export declare function removeDefaultFields(value: StateStyle, def: StateStyle): Partial<StateStyle> | undefined;

package/dist/components/MapEditor/lib/state/utils.js

@@ -0,0 +1,12 @@
+export function removeDefaultFields(value, def) {
+    const entries = Object.entries(value).filter(([k, v]) => {
+        if (v === undefined)
+            return false;
+        if (v === def[k])
+            return false;
+        return true;
+    });
+    if (entries.length === 0)
+        return undefined;
+    return Object.fromEntries(entries);
+}

package/dist/components/MapEditor/lib/state/writer.d.ts

@@ -1,4 +1,4 @@
-import type { StateElementLine, StateElementMarker, StateElementPolygon, StateRoot, StateStyle } from './types.js';
+import type { StateElementCircle, StateElementLine, StateElementMarker, StateElementPolygon, StateMetadata, StateRoot, StateStyle } from './types.js';
 export declare class StateWriter {
     bits: boolean[];
     constructor();
@@ -8,13 +8,15 @@ export declare class StateWriter {
     writeInteger(value: number, bits: number): number;
     writeVarint(value: number, signed?: true): void;
     writeArray<T>(array: T[], cb: (v: T) => void): void;
-    writePoint(point: [number, number], level?: number): void;
-    writePoints(points: [number, number][], level?: number): void;
+    writePoint(point: [number, number], resolutionInMeters?: number): void;
+    writePoints(points: [number, number][], resolutionInMeters?: number): void;
     writeRoot(root: StateRoot): void;
-    writeMap(map: NonNullable<StateRoot['map']>): void;
+    writeMap(map: StateRoot['map']): void;
+    writeMetadata(metadata?: StateMetadata): void;
     writeElementMarker(element: StateElementMarker): StateElementMarker;
     writeElementLine(element: StateElementLine): StateElementLine;
     writeElementPolygon(element: StateElementPolygon): void;
+    writeElementCircle(element: StateElementCircle): void;
     writeStyle(style: StateStyle): void;
     writeColor(color: string): void;
     writeString(value: string): string;

package/dist/components/MapEditor/lib/state/writer.js

@@ -50,14 +50,16 @@ export class StateWriter {
         for (let i = 0; i < length; i++)
             cb(array[i]);
     }
-    writePoint(point, level = 14) {
-        const scale = Math.pow(2, level + 2);
-        this.writeInteger(Math.round(point[0] * scale), level + 11);
-        this.writeInteger(Math.round(point[1] * scale), level + 10);
-    }
-    writePoints(points, level = 14) {
+    writePoint(point, resolutionInMeters = 1) {
+        if (!resolutionInMeters || resolutionInMeters < 1)
+            resolutionInMeters = 1;
+        const scale = Math.round(1e5 / resolutionInMeters);
+        this.writeVarint(Math.round(point[0] * scale), true);
+        this.writeVarint(Math.round(point[1] * scale), true);
+    }
+    writePoints(points, resolutionInMeters = 1) {
         this.writeVarint(points.length);
-        const scale = Math.pow(2, level + 2);
+        const scale = Math.round(1e5 / resolutionInMeters);
         let x = 0;
         let y = 0;
         points.forEach((point) => {
@@ -72,15 +74,8 @@ export class StateWriter {
     writeRoot(root) {
         // Write the version
         this.writeInteger(0, 3);
-        if (root.map) {
-            this.writeBit(true);
-            this.writeMap(root.map);
-        }
-        else {
-            this.writeBit(false);
-        }
-        // metadata is not used yet
-        this.writeBit(false);
+        this.writeMap(root.map);
+        this.writeMetadata(root.meta);
         root.elements.forEach((element) => {
             switch (element.type) {
                 case 'marker':
@@ -95,12 +90,35 @@ export class StateWriter {
                     this.writeInteger(3, 3);
                     this.writeElementPolygon(element);
                     break;
+                case 'circle':
+                    this.writeInteger(4, 3);
+                    this.writeElementCircle(element);
+                    break;
             }
         });
     }
     writeMap(map) {
-        this.writeInteger(Math.round(map.zoom * 32), 10);
-        this.writePoint(map.center, Math.ceil(map.zoom));
+        if (!map) {
+            return this.writeBit(false);
+        }
+        this.writeBit(true);
+        const value = Math.round(Math.log2(map.radius) * 40);
+        const radius = Math.pow(2, value / 40);
+        this.writeInteger(value, 10);
+        // effective resolution of coordinates is 1000 times the visible radius
+        this.writePoint(map.center, radius / 1e3);
+        this.writeBit(false); // additional map data not supported yet
+    }
+    writeMetadata(metadata) {
+        if (!metadata || Object.keys(metadata).length === 0) {
+            return this.writeBit(false);
+        }
+        this.writeBit(true);
+        //if (metadata.heading) {
+        //	this.writeInteger(1, 6);
+        //	this.writeString(metadata.heading);
+        //}
+        this.writeInteger(0, 6);
     }
     writeElementMarker(element) {
         this.writePoint(element.point);
@@ -111,6 +129,7 @@ export class StateWriter {
         else {
             this.writeBit(false);
         }
+        this.writeBit(false); // tooltip not supported yet
         return element;
     }
     writeElementLine(element) {
@@ -122,6 +141,7 @@ export class StateWriter {
         else {
             this.writeBit(false);
         }
+        this.writeBit(false); // tooltip not supported yet
         return element;
     }
     writeElementPolygon(element) {
@@ -140,6 +160,26 @@ export class StateWriter {
         else {
             this.writeBit(false);
         }
+        this.writeBit(false); // tooltip not supported yet
+    }
+    writeElementCircle(element) {
+        this.writePoint(element.point);
+        this.writeVarint(Math.round(element.radius));
+        if (element.style) {
+            this.writeBit(true);
+            this.writeStyle(element.style);
+        }
+        else {
+            this.writeBit(false);
+        }
+        if (element.strokeStyle) {
+            this.writeBit(true);
+            this.writeStyle(element.strokeStyle);
+        }
+        else {
+            this.writeBit(false);
+        }
+        this.writeBit(false); // tooltip not supported yet
     }
     writeStyle(style) {
         if (style.halo != null) {
@@ -184,7 +224,7 @@ export class StateWriter {
         this.writeInteger(0, 4);
     }
     writeColor(color) {
-        const rgb = Color.parse(color).toRGB();
+        const rgb = Color.parse(color).asRGB();
         this.writeInteger(rgb.r, 8);
         this.writeInteger(rgb.g, 8);
         this.writeInteger(rgb.b, 8);

package/dist/components/MapEditor/lib/symbols.d.ts

@@ -11,6 +11,6 @@ export declare class SymbolLibrary {
     private map;
     constructor(map: maplibregl.Map);
     getSymbol(index: number): SymbolInfo;
-    drawSymbol(canvas: HTMLCanvasElement, index: number, halo?: boolean): void;
+    drawSymbol(canvas: HTMLCanvasElement, index: number, halo?: number): void;
     asList(): SymbolInfo[];
 }