@versatiles/svelte 1.1.1 → 2.0.0

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

@@ -0,0 +1,22 @@
+export const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+export const BASE64_CODE2BITS = [];
+for (let i = 0; i < BASE64_CHARS.length; i++) {
+    BASE64_CODE2BITS[BASE64_CHARS.charCodeAt(i)] = [
+        (i & 32) > 0,
+        (i & 16) > 0,
+        (i & 8) > 0,
+        (i & 4) > 0,
+        (i & 2) > 0,
+        (i & 1) > 0
+    ];
+}
+export const CHAR_VALUE2CODE = [
+    32, 101, 116, 97, 110, 105, 111, 115, 114, 108, 100, 104, 99, 117, 109, 112, 102, 103, 46, 121,
+    98, 119, 44, 118, 48, 107, 49, 83, 84, 67, 50, 56, 53, 65, 57, 120, 51, 73, 45, 54, 52, 55, 77,
+    66, 34, 39, 80, 69, 78, 70, 82, 68, 85, 113, 76, 71, 74, 72, 79, 87, 106, 122, 47, 60, 62, 75, 41,
+    40, 86, 89, 58, 81, 90, 88, 59, 63, 94, 38, 43, 91, 93, 36, 33, 42, 61, 126, 95, 123, 64, 0, 1, 2,
+    3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+    29, 30, 31, 35, 37, 92, 96, 124, 125, 127
+];
+export const CHAR_CODE2VALUE = [];
+CHAR_VALUE2CODE.forEach((c, v) => (CHAR_CODE2VALUE[c] = v));

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

@@ -0,0 +1,16 @@
+import type { GeometryManager } from '../geometry_manager.js';
+export declare class StateManager {
+    geometryManager: GeometryManager;
+    constructor(geometryManager: GeometryManager);
+    getHash(): 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

@@ -0,0 +1,76 @@
+import { writable } from 'svelte/store';
+import { StateReader } from './reader.js';
+import { StateWriter } from './writer.js';
+const MAXLENGTH = 100;
+export class StateManager {
+    geometryManager;
+    constructor(geometryManager) {
+        this.geometryManager = geometryManager;
+        this.resetHistory();
+    }
+    getHash() {
+        const writer = new StateWriter();
+        writer.writeRoot(this.geometryManager.getState());
+        return writer.asBase64();
+    }
+    setHash(hash) {
+        if (!hash)
+            return;
+        try {
+            const state = StateReader.fromBase64(hash).readRoot();
+            this.geometryManager.setState(state);
+            this.resetHistory();
+        }
+        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() {
+        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();
+    }
+    undo() {
+        if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex++;
+            const state = this.history[this.historyIndex];
+            this.geometryManager.setState(state);
+            this.updateButtons();
+        }
+    }
+    redo() {
+        if (this.historyIndex > 0) {
+            this.historyIndex--;
+            const state = this.history[this.historyIndex];
+            this.geometryManager.setState(state);
+            this.updateButtons();
+        }
+    }
+    updateButtons() {
+        this.undoEnabled.set(this.historyIndex < this.history.length - 1);
+        this.redoEnabled.set(this.historyIndex > 0);
+    }
+}

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

@@ -1,17 +1,24 @@
-import type { StateObject } from './types.js';
+import type { StateElementLine, StateElementMarker, StateElementPolygon, StateRoot, StateStyle } from './types.js';
 export declare class StateReader {
-    private buffer;
-    private offset;
-    constructor(buffer: Uint8Array | number[]);
-    readByte(): number;
-    readUnsignedInteger(): number;
-    readSignedInteger(): number;
-    readString(): string;
-    readBoolean(): boolean;
-    static fromBase64compressed(base64: string): Promise<StateReader>;
-    static fromBase64(base64: string): Promise<StateReader>;
-    readObject(): StateObject;
-    readDifferential(count: number): number[];
+    bits: boolean[];
+    offset: number;
+    constructor(bits: boolean[]);
+    static fromBase64(text: string): StateReader;
+    static fromBitString(text: string): StateReader;
+    ended(): boolean;
+    readBit(): boolean;
+    readInteger(bits: number, signed?: true): number;
+    read6pack(): number;
+    readVarint(signed?: true): number;
+    readArray<T>(cb: () => T): T[];
+    readPoint(level?: number): [number, number];
+    readPoints(level?: number): [number, number][];
+    readRoot(): StateRoot;
+    readMap(): NonNullable<StateRoot['map']>;
+    readElementMarker(): StateElementMarker;
+    readElementLine(): StateElementLine;
+    readElementPolygon(): StateElementPolygon;
+    readStyle(): StateStyle;
     readColor(): string;
-    readType(): string;
+    readString(): string;
 }

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

@@ -1,161 +1,281 @@
 import { Color } from '@versatiles/style';
-import { base64ToUint8Array, decompress } from '../utils.js';
+import { BASE64_CODE2BITS, CHAR_VALUE2CODE } from './constants.js';
 export class StateReader {
-    buffer;
+    bits;
     offset = 0;
-    constructor(buffer) {
-        if (buffer instanceof Uint8Array) {
-            this.buffer = buffer;
+    constructor(bits) {
+        this.bits = bits;
+    }
+    static fromBase64(text) {
+        const bits = [];
+        for (let i = 0; i < text.length; i++) {
+            const charCode = text.charCodeAt(i);
+            const charBits = BASE64_CODE2BITS[charCode];
+            if (!charBits) {
+                throw new Error(`Invalid character in base64 string: ${text[i]}`);
+            }
+            bits.push(...charBits);
         }
-        else if (Array.isArray(buffer)) {
-            this.buffer = new Uint8Array(buffer);
+        return new StateReader(bits);
+    }
+    static fromBitString(text) {
+        return new StateReader(text.split('').map((c) => c === '1'));
+    }
+    ended() {
+        return this.offset >= this.bits.length;
+    }
+    readBit() {
+        if (this.ended())
+            throw new Error('End of bits');
+        return this.bits[this.offset++];
+    }
+    readInteger(bits, signed) {
+        try {
+            let value = 0;
+            for (let i = 0; i < bits; i++) {
+                value <<= 1;
+                if (this.readBit())
+                    value += 1;
+            }
+            if (signed && value >= 1 << (bits - 1)) {
+                value -= 1 << bits;
+            }
+            return value;
         }
-        else {
-            throw new TypeError('Invalid buffer type');
+        catch (cause) {
+            throw new Error(`Error reading integer`, { cause });
         }
     }
-    readByte() {
-        if (this.offset >= this.buffer.length) {
-            throw new RangeError('Attempt to read past end of buffer');
+    read6pack() {
+        let value = 0;
+        for (let i = 0; i < 6; i++) {
+            value <<= 1;
+            if (this.bits[this.offset++])
+                value += 1;
         }
-        return this.buffer[this.offset++];
+        return value;
     }
-    readUnsignedInteger() {
-        let result = 0, shift = 0, byte;
-        do {
-            if (this.offset >= this.buffer.length) {
-                throw new RangeError('Unexpected end of buffer while reading integer');
-            }
-            byte = this.readByte();
-            result |= (byte & 0x7f) << shift;
-            shift += 7;
-        } while (byte & 0x80);
-        return result;
+    readVarint(signed) {
+        try {
+            let value = 0;
+            let offset = 0;
+            do {
+                value += this.readInteger(5) << offset;
+                offset += 5;
+            } while (this.readBit());
+            if (!signed)
+                return value;
+            return value & 1 ? -((value >> 1) + 1) : value >> 1;
+        }
+        catch (cause) {
+            throw new Error(`Error reading readVarint`, { cause });
+        }
     }
-    readSignedInteger() {
-        const result = this.readUnsignedInteger();
-        if (result & 1) {
-            return -((result + 1) / 2);
+    readArray(cb) {
+        try {
+            const length = this.readVarint();
+            const array = [];
+            for (let i = 0; i < length; i++)
+                array.push(cb());
+            return array;
         }
-        else {
-            return result / 2;
+        catch (cause) {
+            throw new Error(`Error reading array`, { cause });
         }
     }
-    readString() {
-        const length = this.readUnsignedInteger();
-        let str = '';
-        for (let i = 0; i < length; i++) {
-            str += String.fromCharCode(this.readUnsignedInteger());
-        }
-        return str;
-    }
-    readBoolean() {
-        return this.readByte() !== 0;
-    }
-    static async fromBase64compressed(base64) {
-        return new StateReader(await decompress(base64ToUint8Array(base64)));
-    }
-    static async fromBase64(base64) {
-        return new StateReader(base64ToUint8Array(base64));
-    }
-    readObject() {
-        const state = {};
-        while (true) {
-            const key = this.readByte();
-            if (key === 0)
-                break;
-            switch (key) {
-                case 10:
-                    state.map = this.readObject();
-                    break;
-                case 11:
-                    state.style = this.readObject();
-                    break;
-                case 12:
-                    state.strokeStyle = this.readObject();
-                    break;
-                case 20:
-                    {
-                        const length = this.readUnsignedInteger();
-                        state.elements = Array.from({ length }, () => this.readObject());
-                    }
-                    break;
-                case 30:
-                    state.point = [this.readSignedInteger() / 1e5, this.readSignedInteger() / 1e5];
-                    break;
-                case 31:
-                    {
-                        const count = this.readUnsignedInteger();
-                        const x = this.readDifferential(count);
-                        const y = this.readDifferential(count);
-                        state.points = Array.from({ length: count }, (_, i) => [x[i] / 1e5, y[i] / 1e5]);
-                    }
-                    break;
-                case 40:
-                    state.color = this.readColor();
-                    break;
-                case 50:
-                    state.type = this.readType();
-                    break;
-                case 60:
-                    state.label = this.readString();
-                    break;
-                case 70:
-                    state.halo = this.readUnsignedInteger() / 10;
-                    break;
-                case 71:
-                    state.opacity = this.readUnsignedInteger() / 100;
-                    break;
-                case 72:
-                    state.pattern = this.readUnsignedInteger();
-                    break;
-                case 73:
-                    state.rotate = this.readUnsignedInteger();
-                    break;
-                case 74:
-                    state.size = this.readUnsignedInteger() / 10;
-                    break;
-                case 75:
-                    state.width = this.readUnsignedInteger() / 10;
-                    break;
-                case 76:
-                    state.zoom = this.readUnsignedInteger() / 20;
-                    break;
-                case 90:
-                    state.visible = this.readBoolean();
-                    break;
-                default:
-                    throw new Error(`Invalid state key: ${key}`);
+    readPoint(level = 14) {
+        try {
+            const scale = Math.pow(2, level + 2);
+            return [
+                this.readInteger(level + 11, true) / scale,
+                this.readInteger(level + 10, true) / scale
+            ];
+        }
+        catch (cause) {
+            throw new Error(`Error reading point`, { cause });
+        }
+    }
+    readPoints(level = 14) {
+        try {
+            const length = this.readVarint();
+            const scale = Math.pow(2, -level - 2);
+            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];
             }
+            return points;
+        }
+        catch (cause) {
+            throw new Error(`Error reading points`, { cause });
         }
-        return state;
     }
-    readDifferential(count) {
-        const values = [];
-        if (count === 0)
-            return values;
-        let value = this.readSignedInteger();
-        values.push(value);
-        for (let i = 1; i < count; i++) {
-            value += +this.readSignedInteger();
-            values.push(value);
+    readRoot() {
+        try {
+            const root = { elements: [] };
+            const version = this.readInteger(3);
+            if (version != 0) {
+                throw new Error(`Unsupported version: ${version}`);
+            }
+            // Read the map element
+            if (this.readBit()) {
+                root.map = this.readMap();
+            }
+            // Read the metadata
+            if (this.readBit()) {
+                throw new Error(`Metadata not supported yet`);
+            }
+            // Read the elements
+            while (true) {
+                let key;
+                try {
+                    key = this.readInteger(3);
+                }
+                catch (_) {
+                    key = 0;
+                }
+                switch (key) {
+                    case 0:
+                        return root;
+                    case 1:
+                        root.elements.push(this.readElementMarker());
+                        break;
+                    case 2:
+                        root.elements.push(this.readElementLine());
+                        break;
+                    case 3:
+                        root.elements.push(this.readElementPolygon());
+                        break;
+                    default:
+                        console.warn(`Unknown state key: ${key}`);
+                }
+            }
+        }
+        catch (cause) {
+            throw new Error(`Error reading root`, { cause });
+        }
+    }
+    readMap() {
+        try {
+            const zoom = this.readInteger(10) / 32;
+            const center = this.readPoint(Math.ceil(zoom));
+            return { zoom, center };
+        }
+        catch (cause) {
+            throw new Error(`Error reading map`, { cause });
+        }
+    }
+    readElementMarker() {
+        try {
+            const element = { type: 'marker', point: this.readPoint() };
+            if (this.readBit())
+                element.style = this.readStyle();
+            return element;
+        }
+        catch (cause) {
+            throw new Error(`Error reading marker element`, { cause });
+        }
+    }
+    readElementLine() {
+        try {
+            const element = { type: 'line', points: this.readPoints() };
+            if (this.readBit())
+                element.style = this.readStyle();
+            return element;
+        }
+        catch (cause) {
+            throw new Error(`Error reading line element`, { cause });
+        }
+    }
+    readElementPolygon() {
+        try {
+            const element = { type: 'polygon', points: this.readPoints() };
+            if (this.readBit())
+                element.style = this.readStyle();
+            if (this.readBit())
+                element.strokeStyle = this.readStyle();
+            return element;
+        }
+        catch (cause) {
+            throw new Error(`Error reading polygon element`, { cause });
+        }
+    }
+    readStyle() {
+        try {
+            const style = {};
+            while (true) {
+                const key = this.readInteger(4);
+                switch (key) {
+                    case 0:
+                        return style;
+                    case 1:
+                        style.halo = this.readVarint() / 10;
+                        break;
+                    case 2:
+                        style.opacity = this.readVarint() / 100;
+                        break;
+                    case 3:
+                        style.pattern = this.readVarint();
+                        break;
+                    case 4:
+                        style.rotate = this.readVarint(true);
+                        break;
+                    case 5:
+                        style.size = this.readVarint() / 10;
+                        break;
+                    case 6:
+                        style.width = this.readVarint() / 10;
+                        break;
+                    case 7:
+                        style.align = this.readVarint();
+                        break;
+                    case 8:
+                        style.color = this.readColor();
+                        break;
+                    case 9:
+                        style.label = this.readString();
+                        break;
+                    case 10:
+                        style.visible = false;
+                        break;
+                    default:
+                        throw new Error(`Invalid state key: ${key}`);
+                }
+            }
+        }
+        catch (cause) {
+            throw new Error(`Error reading style`, { cause });
         }
-        return values;
     }
     readColor() {
-        return new Color.RGB(this.readByte(), this.readByte(), this.readByte()).asHex();
-    }
-    readType() {
-        const type = this.readByte();
-        switch (type) {
-            case 0:
-                return 'marker';
-            case 1:
-                return 'line';
-            case 2:
-                return 'polygon';
-            default:
-                throw new Error(`Invalid type: ${type}`);
+        try {
+            const r = this.readInteger(8);
+            const g = this.readInteger(8);
+            const b = this.readInteger(8);
+            let a = 1;
+            if (this.readBit())
+                a = this.readInteger(8) / 255;
+            return new Color.RGB(r, g, b, a).asHex();
+        }
+        catch (cause) {
+            throw new Error(`Error reading color`, { cause });
+        }
+    }
+    readString() {
+        try {
+            const length = this.readVarint();
+            const charCodes = [];
+            for (let i = 0; i < length; i++) {
+                const value = this.readVarint();
+                charCodes.push(value < 128 ? CHAR_VALUE2CODE[value] : value);
+            }
+            return String.fromCharCode(...charCodes);
+        }
+        catch (cause) {
+            throw new Error(`Error reading string`, { cause });
         }
     }
 }

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

@@ -1,20 +1,36 @@
-export interface StateObject {
-    [key: string]: StateObject | StateObject[] | [number, number] | [number, number][] | string | number | boolean | undefined;
-    map?: StateObject;
-    style?: StateObject;
-    strokeStyle?: StateObject;
-    elements?: StateObject[];
-    point?: [number, number];
-    points?: [number, number][];
-    color?: string;
-    type?: string;
-    label?: string;
+export interface StateRoot {
+    map?: {
+        center: [number, number];
+        zoom: number;
+    };
+    elements: StateElement[];
+}
+export type StateElement = StateElementMarker | StateElementLine | StateElementPolygon;
+export interface StateElementMarker {
+    type: 'marker';
+    point: [number, number];
+    style?: StateStyle;
+}
+export interface StateElementLine {
+    type: 'line';
+    points: [number, number][];
+    style?: StateStyle;
+}
+export interface StateElementPolygon {
+    type: 'polygon';
+    points: [number, number][];
+    style?: StateStyle;
+    strokeStyle?: StateStyle;
+}
+export interface StateStyle {
     halo?: number;
     opacity?: number;
     pattern?: number;
     rotate?: number;
     size?: number;
     width?: number;
-    zoom?: number;
+    align?: number;
+    color?: string;
+    label?: string;
     visible?: boolean;
 }

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

@@ -1,17 +1,21 @@
-import type { StateObject } from './types.js';
+import type { StateElementLine, StateElementMarker, StateElementPolygon, StateRoot, StateStyle } from './types.js';
 export declare class StateWriter {
-    buffer: Uint8Array<ArrayBuffer>;
-    offset: number;
+    bits: boolean[];
     constructor();
-    writeByte(num: number): void;
-    writeUnsignedInteger(i: number): void;
-    writeSignedInteger(i: number): void;
-    writeString(str: string): void;
-    writeBoolean(b: boolean): void;
-    getBase64(): string;
-    getBase64compressed(): Promise<string>;
-    getBuffer(): Uint8Array;
-    writeObject(state: StateObject): void;
-    writeColor(color: unknown): void;
-    writeDifferential(values: number[]): void;
+    asBase64(): string;
+    asBitString(): string;
+    writeBit(value: boolean): void;
+    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;
+    writeRoot(root: StateRoot): void;
+    writeMap(map: NonNullable<StateRoot['map']>): void;
+    writeElementMarker(element: StateElementMarker): StateElementMarker;
+    writeElementLine(element: StateElementLine): StateElementLine;
+    writeElementPolygon(element: StateElementPolygon): void;
+    writeStyle(style: StateStyle): void;
+    writeColor(color: string): void;
+    writeString(value: string): string;
 }