@versatiles/svelte 1.0.1 → 1.1.0

package/dist/components/MapEditor/lib/symbols.js

@@ -0,0 +1,173 @@
+const entries = [
+    [0, 'none'],
+    [1, 'airplane', 'basics:icon-airfield'],
+    [2, 'airport', 'basics:icon-airport'],
+    [3, 'alcohol shop', 'basics:icon-alcohol_shop'],
+    [4, 'art gallery', 'basics:icon-art_gallery'],
+    [5, 'artwork', 'basics:icon-artwork'],
+    [6, 'atm', 'basics:icon-atm'],
+    [7, 'bakery', 'basics:icon-bakery'],
+    [8, 'bank', 'basics:icon-bank'],
+    [9, 'beauty', 'basics:icon-beauty'],
+    [10, 'beer', 'basics:icon-beer'],
+    [11, 'beergarden', 'basics:icon-beergarden'],
+    [12, 'bench', 'basics:icon-bench'],
+    [13, 'beverages', 'basics:icon-beverages'],
+    [14, 'bicycle share', 'basics:icon-bicycle_share'],
+    [15, 'books', 'basics:icon-books'],
+    [16, 'bus', 'basics:icon-bus'],
+    [17, 'butcher', 'basics:icon-butcher'],
+    [18, 'cafe', 'basics:icon-cafe', [2, 0]],
+    [19, 'car rental', 'basics:icon-car_rental'],
+    [20, 'car wash', 'basics:icon-car_wash'],
+    [21, 'castle', 'basics:icon-castle'],
+    [22, 'cemetery', 'basics:icon-cemetery'],
+    [23, 'chalet', 'basics:icon-chalet'],
+    [24, 'chemist', 'basics:icon-chemist'],
+    [25, 'cinema', 'basics:icon-cinema'],
+    [26, 'clothes', 'basics:icon-clothes'],
+    [27, 'college', 'basics:icon-college'],
+    [28, 'community', 'basics:icon-community'],
+    [29, 'defibrillator', 'basics:icon-defibrillator'],
+    [30, 'doctor', 'basics:icon-doctor'],
+    [31, 'dog park', 'basics:icon-dog_park'],
+    [32, 'doityourself', 'basics:icon-doityourself'],
+    [33, 'drinking water', 'basics:icon-drinking_water'],
+    [34, 'drycleaning', 'basics:icon-drycleaning'],
+    [35, 'emergency phone', 'basics:icon-emergency_phone'],
+    [36, 'fast food', 'basics:icon-fast_food'],
+    [37, 'fire station', 'basics:icon-fire_station'],
+    [38, 'flag', 'basics:icon-embassy', [0, 0]],
+    [39, 'florist', 'basics:icon-florist'],
+    [40, 'fountain', 'basics:icon-fountain'],
+    [41, 'furniture', 'basics:icon-furniture'],
+    [42, 'garden centre', 'basics:icon-garden_centre'],
+    [43, 'gift', 'basics:icon-gift'],
+    [44, 'glasses', 'basics:icon-optician'],
+    [45, 'golf', 'basics:icon-golf'],
+    [46, 'greengrocer', 'basics:icon-greengrocer'],
+    [47, 'hardware', 'basics:icon-hardware'],
+    [48, 'hospital', 'basics:icon-hospital'],
+    [49, 'huntingstand', 'basics:icon-huntingstand'],
+    [50, 'hydrant', 'basics:icon-hydrant'],
+    [51, 'icerink', 'basics:icon-icerink'],
+    [52, 'information', 'basics:transport-information'],
+    [53, 'jewelry store', 'basics:icon-jewelry_store'],
+    [54, 'kiosk', 'basics:icon-kiosk'],
+    [55, 'laundry', 'basics:icon-laundry'],
+    [56, 'letter', 'basics:icon-post'],
+    [57, 'library', 'basics:icon-library'],
+    [58, 'lighthouse', 'basics:icon-lighthouse'],
+    [59, 'marketplace', 'basics:icon-marketplace'],
+    [60, 'money', 'basics:icon-bar'],
+    [61, 'monument', 'basics:icon-monument'],
+    [62, 'newsagent', 'basics:icon-newsagent'],
+    [63, 'nightclub', 'basics:icon-nightclub'],
+    [64, 'nursinghome', 'basics:icon-nursinghome'],
+    [65, 'observation tower', 'basics:icon-observation_tower'],
+    [66, 'outdoor', 'basics:icon-outdoor'],
+    [67, 'pharmacy', 'basics:icon-pharmacy'],
+    [68, 'picnic site', 'basics:icon-picnic_site'],
+    [69, 'place of worship', 'basics:icon-place_of_worship'],
+    [70, 'playground', 'basics:icon-playground'],
+    [71, 'police', 'basics:icon-police', [-1, -3]],
+    [72, 'postbox', 'basics:icon-postbox'],
+    [73, 'prison', 'basics:icon-prison'],
+    [74, 'rail light', 'basics:icon-rail_light'],
+    [75, 'rail metro', 'basics:icon-rail_metro'],
+    [76, 'rail', 'basics:icon-rail'],
+    [77, 'recycling', 'basics:icon-recycling'],
+    [78, 'restaurant', 'basics:icon-restaurant'],
+    [79, 'run', 'basics:icon-pitch'],
+    [80, 'school', 'basics:icon-school'],
+    [81, 'scissor', 'basics:icon-hairdresser'],
+    [82, 'shield', 'basics:icon-historic', [0, -10]],
+    [83, 'shoes', 'basics:icon-shoes', [-5, 0]],
+    [84, 'shop', 'basics:icon-shop'],
+    [85, 'shop', 'basics:icon-shop'],
+    [86, 'shrine', 'basics:icon-shrine'],
+    [87, 'sports', 'basics:icon-sports'],
+    [88, 'stadium', 'basics:icon-stadium'],
+    [89, 'stationery', 'basics:icon-stationery'],
+    [90, 'surveillance', 'basics:icon-surveillance'],
+    [91, 'swimming', 'basics:icon-swimming'],
+    [92, 'telephone', 'basics:icon-telephone'],
+    [93, 'theatre', 'basics:icon-theatre'],
+    [94, 'toilet', 'basics:icon-toilet'],
+    [95, 'tooth', 'basics:icon-dentist'],
+    [96, 'town hall', 'basics:icon-town_hall'],
+    [97, 'toys', 'basics:icon-toys'],
+    [98, 'tram', 'basics:transport-tram'],
+    [99, 'travel agent', 'basics:icon-travel_agent'],
+    [100, 'vendingmachine', 'basics:icon-vendingmachine'],
+    [101, 'veterinary', 'basics:icon-veterinary'],
+    [102, 'video', 'basics:icon-video'],
+    [103, 'viewpoint', 'basics:icon-viewpoint', [0, -6]],
+    [104, 'waste basket', 'basics:icon-waste_basket'],
+    [105, 'watermill', 'basics:icon-watermill'],
+    [106, 'waterpark', 'basics:icon-waterpark'],
+    [107, 'windmill', 'basics:icon-windmill'],
+    [108, 'zoo', 'basics:icon-zoo']
+];
+const symbols = new Map(entries.map(([index, name, image, offset]) => [index, { index, name, image, offset }]));
+const defaultSymbol = symbols.get(38);
+export function getSymbol(index) {
+    return symbols.get(index) ?? defaultSymbol;
+}
+export function getSymbolIndexByName(name) {
+    const entry = entries.find((entry) => entry[1] === name);
+    return entry ? entry[0] : undefined;
+}
+export class SymbolLibrary {
+    map;
+    constructor(map) {
+        this.map = map;
+    }
+    getSymbol(index) {
+        return symbols.get(index) ?? defaultSymbol;
+    }
+    drawSymbol(canvas, index, halo = false) {
+        const symbol = this.getSymbol(index);
+        if (!symbol.image)
+            return;
+        const { sdf, data: imageData0 } = this.map.getImage(symbol.image);
+        const { data: data0, width: width0, height: height0 } = imageData0;
+        const { width: width1, height: height1 } = canvas;
+        const data1 = new Uint8ClampedArray(width1 * height1 * 4);
+        for (let y1 = 0; y1 < height1; y1++) {
+            const y0 = Math.floor((y1 / height1) * height0);
+            for (let x1 = 0; x1 < width1; x1++) {
+                const x0 = Math.floor((x1 / width1) * width0);
+                const i0 = (y0 * width0 + x0) * 4;
+                const i1 = (y1 * width1 + x1) * 4;
+                if (sdf) {
+                    const v = (data0[i0 + 3] - 191) * 16;
+                    let a, b;
+                    if (halo) {
+                        b = Math.min(255, Math.max(0, 255 - v));
+                        a = Math.min(255, Math.max(0, 256 * 6 + v));
+                    }
+                    else {
+                        b = 0;
+                        a = Math.min(255, Math.max(0, v));
+                    }
+                    data1[i1] = b;
+                    data1[i1 + 1] = b;
+                    data1[i1 + 2] = b;
+                    data1[i1 + 3] = a;
+                }
+                else {
+                    data1[i1] = data0[i0];
+                    data1[i1 + 1] = data0[i0 + 1];
+                    data1[i1 + 2] = data0[i0 + 2];
+                    data1[i1 + 3] = data0[i0 + 3];
+                }
+            }
+        }
+        const ctx = canvas.getContext('2d');
+        ctx.putImageData(new ImageData(data1, width1, height1), 0, 0);
+    }
+    asList() {
+        return Array.from(symbols.values());
+    }
+}

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

@@ -1,2 +1,9 @@
-import type { ElementPoint } from './types.js';
+import type { ElementPoint } from './element/types.js';
 export declare function getMiddlePoint(p0: ElementPoint, p1: ElementPoint): ElementPoint;
+export declare function lat2mercator(lat: number): number;
+export declare function mercator2lat(y: number): number;
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+export declare function uint8ArrayToBase64(data: Uint8Array): string;
+export declare function compress(data: Uint8Array): Promise<Uint8Array>;
+export declare function decompress(data: Uint8Array): Promise<Uint8Array>;
+export declare function removeDefaultFields<T extends Record<string, unknown>>(value: T, def: T): Partial<T> | undefined;

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

@@ -3,9 +3,40 @@ export function getMiddlePoint(p0, p1) {
     const y1 = lat2mercator(p1[1]);
     return [(p0[0] + p1[0]) / 2, mercator2lat((y0 + y1) / 2)];
 }
-function lat2mercator(lat) {
+export function lat2mercator(lat) {
     return Math.log(Math.tan(Math.PI / 4 + (lat * Math.PI) / 360));
 }
-function mercator2lat(y) {
+export function mercator2lat(y) {
     return ((2 * Math.atan(Math.exp(y)) - Math.PI / 2) * 180) / Math.PI;
 }
+export function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    return Uint8Array.from(binaryString, (c) => c.charCodeAt(0));
+}
+export function uint8ArrayToBase64(data) {
+    const binaryString = String.fromCharCode(...data);
+    return btoa(binaryString);
+}
+export async function compress(data) {
+    const stream = new Blob([data]).stream();
+    const compressedStream = stream.pipeThrough(new CompressionStream('deflate-raw'));
+    return new Uint8Array(await new Response(compressedStream).arrayBuffer());
+}
+export async function decompress(data) {
+    const stream = new Blob([data]).stream();
+    const decompressedStream = stream.pipeThrough(new DecompressionStream('deflate-raw'));
+    const arrayBuffer = await new Response(decompressedStream).arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+}
+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/utils/draw/bbox.d.ts

@@ -1,5 +1,6 @@
 import type geojson from 'geojson';
 import { type Writable } from 'svelte/store';
+import maplibregl from 'maplibre-gl';
 type DragPoint = 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw' | false;
 export declare const DragPointMap: Map<DragPoint, {
     cursor: string;

package/dist/utils/draw/bbox.js

@@ -1,5 +1,5 @@
 import { get, writable } from 'svelte/store';
-const maplibregl = await import('maplibre-gl');
+import maplibregl from 'maplibre-gl';
 const { LngLatBounds } = maplibregl;
 // prettier-ignore
 export const DragPointMap = new Map([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versatiles/svelte",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "license": "MIT",
   "scripts": {
     "build": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json && vite build && npm run package",
@@ -10,16 +10,16 @@
     "format": "prettier --write .",
     "lint": "prettier --check . && eslint --color .",
     "package": "svelte-kit sync && svelte-package && publint",
-    "prepack": "npm run package",
+    "prepack": "npm run build",
     "prepublishOnly": "npm run package",
     "preview": "vite preview",
     "screenshots": "npm run build && npx tsx ./scripts/screenshots.ts && pngquant --nofs --force --ext .png screenshots/*.png && optipng -quiet screenshots/*.png",
-    "release": "npm run build && npx vrt release-npm",
+    "release": "vrt release-npm",
     "test:integration": "playwright test",
     "test:unit": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test": "npm run test:unit && npm run test:integration",
-    "upgrade": "npm-check-updates -u && rm -f package-lock.json; rm -rf node_modules; npm update --save && npm install"
+    "upgrade": "vrt deps-upgrade"
   },
   "exports": {
     ".": {
@@ -35,46 +35,45 @@
     "!dist/BBoxMap/helpers/*"
   ],
   "peerDependencies": {
-    "svelte": "^5.0.3",
-    "sass-embedded": "^1.83.4"
+    "sass-embedded": "^1.86.0",
+    "svelte": "^5.0.3"
   },
   "devDependencies": {
-    "@playwright/test": "^1.50.0",
+    "@playwright/test": "^1.51.1",
     "@sveltejs/adapter-static": "^3.0.8",
-    "@sveltejs/kit": "^2.16.1",
-    "@sveltejs/package": "^2.3.9",
+    "@sveltejs/kit": "^2.20.0",
+    "@sveltejs/package": "^2.3.10",
     "@sveltejs/vite-plugin-svelte": "^5.0.3",
     "@turf/turf": "^7.2.0",
     "@types/eslint": "^9.6.1",
-    "@types/node": "^22.12.0",
-    "@versatiles/release-tool": "^1.2.6",
-    "@vitest/coverage-v8": "^3.0.4",
+    "@types/node": "^22.13.10",
+    "@versatiles/release-tool": "^2.4.2",
+    "@vitest/coverage-v8": "^3.0.9",
     "cookie": "^1.0.2",
-    "eslint": "^9.19.0",
-    "eslint-config-prettier": "^10.0.1",
-    "eslint-plugin-svelte": "^2.46.1",
+    "eslint": "^9.22.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-svelte": "^3.3.2",
     "geojson": "^0.5.0",
-    "globals": "^15.14.0",
-    "happy-dom": "^16.7.3",
-    "npm-check-updates": "^17.1.14",
-    "prettier": "^3.4.2",
+    "globals": "^16.0.0",
+    "happy-dom": "^17.4.4",
+    "prettier": "^3.5.3",
     "prettier-plugin-svelte": "^3.3.3",
-    "publint": "^0.3.2",
-    "sass": "^1.83.4",
-    "svelte": "^5.19.6",
-    "svelte-check": "^4.1.4",
+    "publint": "^0.3.9",
+    "sass": "^1.86.0",
+    "svelte": "^5.23.1",
+    "svelte-check": "^4.1.5",
     "svelte-preprocess": "^6.0.3",
-    "tsx": "^4.19.2",
-    "typescript": "^5.7.3",
-    "typescript-eslint": "^8.22.0",
-    "vite": "^6.0.11",
-    "vitest": "^3.0.4"
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.26.1",
+    "vite": "^6.2.2",
+    "vitest": "^3.0.9"
   },
   "svelte": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
   "dependencies": {
-    "@versatiles/style": "^5.2.9",
-    "maplibre-gl": "^5.1.0"
+    "@versatiles/style": "^5.6.0",
+    "maplibre-gl": "^5.2.0"
   }
 }

package/dist/components/MapEditor/Editor.svelte

@@ -1,25 +0,0 @@
-<script lang="ts">import {} from './editor.scss';
-import EditorMarker from './EditorMarker.svelte';
-import EditorLine from './EditorLine.svelte';
-import { LineElement } from './lib/element_line.js';
-import { MarkerElement } from './lib/element_marker.js';
-const { element } = $props();
-let name = $state(element.name);
-$effect(() => {
-    name = element.name;
-});
-$effect(() => {
-    //element.name = name;
-});
-</script>
-
-{#if element}
-	<label for="input-name">Name</label>
-	<input id="input-name" type="text" bind:value={name} />
-	{#if element instanceof MarkerElement}
-		<EditorMarker {element} />
-	{/if}
-	{#if element instanceof LineElement}
-		<EditorLine {element} />
-	{/if}
-{/if}

package/dist/components/MapEditor/EditorLine.svelte

@@ -1,27 +0,0 @@
-<script lang="ts">import {} from './editor.scss';
-import { get } from 'svelte/store';
-import { dashArrays } from './lib/element_line.js';
-const dashedList = Array.from(dashArrays.keys()).sort();
-let { element } = $props();
-let color = $state(get(element.color));
-let width = $state(get(element.width));
-let dashed = $state(get(element.dashed));
-$effect(() => element.color.set(color));
-$effect(() => element.width.set(width));
-$effect(() => element.dashed.set(dashed));
-</script>
-
-<div class="row">
-	<label for="dashed-input">Dashed</label>
-	<select id="dashed-input" bind:value={dashed}>
-		{#each dashedList as d}
-			<option value={d}>{d}</option>
-		{/each}
-	</select>
-
-	<label for="color-input">Color</label>
-	<input id="color-input" type="color" bind:value={color} />
-
-	<label for="width-input">Width</label>
-	<input id="width-input" type="range" min="0.5" max="5" step="0.5" bind:value={width} />
-</div>

package/dist/components/MapEditor/EditorLine.svelte.d.ts

@@ -1,7 +0,0 @@
-import type { LineElement } from './lib/element_line.js';
-type $$ComponentProps = {
-    element: LineElement;
-};
-declare const EditorLine: import("svelte").Component<$$ComponentProps, {}, "">;
-type EditorLine = ReturnType<typeof EditorLine>;
-export default EditorLine;

package/dist/components/MapEditor/EditorMarker.svelte

@@ -1,42 +0,0 @@
-<script lang="ts">import {} from './editor.scss';
-import { get } from 'svelte/store';
-import { symbols } from './lib/element_marker.js';
-const symbolList = Array.from(symbols.keys()).sort();
-let { element } = $props();
-let color = $state(get(element.color));
-let halo = $state(get(element.halo));
-let rotate = $state(get(element.rotate));
-let size = $state(get(element.size));
-let symbol = $state(get(element.symbol));
-let label = $state(get(element.label));
-$effect(() => element.color.set(color));
-$effect(() => element.halo.set(halo));
-$effect(() => element.rotate.set(rotate));
-$effect(() => element.size.set(size));
-$effect(() => element.label.set(label));
-$effect(() => element.symbol.set(symbol));
-</script>
-
-<div class="row">
-	<label for="symbol-input">Symbol</label>
-	<select id="symbol-input" bind:value={symbol}>
-		{#each symbolList as s}
-			<option value={s}>{s}</option>
-		{/each}
-	</select>
-
-	<label for="color-input">Color</label>
-	<input id="color-input" type="color" bind:value={color} />
-
-	<label for="size-input">Size</label>
-	<input id="size-input" type="range" min="0.5" max="3" step="0.1" bind:value={size} />
-
-	<label for="rotate-input">Rotation</label>
-	<input id="rotate-input" type="range" min="-180" max="180" step="15" bind:value={rotate} />
-
-	<label for="halo-input">Halo</label>
-	<input id="halo-input" type="range" min="0" max="3" step="0.5" bind:value={halo} />
-
-	<label for="label-input">Label</label>
-	<input id="label-input" type="text" bind:value={label} />
-</div>

package/dist/components/MapEditor/EditorMarker.svelte.d.ts

@@ -1,7 +0,0 @@
-import type { MarkerElement } from './lib/element_marker.js';
-type $$ComponentProps = {
-    element: MarkerElement;
-};
-declare const EditorMarker: import("svelte").Component<$$ComponentProps, {}, "">;
-type EditorMarker = ReturnType<typeof EditorMarker>;
-export default EditorMarker;

package/dist/components/MapEditor/editor.scss

@@ -1,16 +0,0 @@
-input {
-	width: 100%;
-}
-
-label,
-div.label {
-	opacity: 0.7;
-	font-size: 0.8em;
-	display: block;
-	margin-top: 1.5em;
-	margin-bottom: 0.2em;
-}
-
-select {
-	width: 100%;
-}

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

@@ -1,20 +0,0 @@
-import type { Feature } from 'geojson';
-import type maplibregl from 'maplibre-gl';
-import { MapLayer } from './map_layer.js';
-import type { ElementPoint, LayerFill, LayerLine, LayerSymbol, SelectionNode } from './types.js';
-import type { GeometryManager } from './geometry_manager.js';
-export declare abstract class AbstractElement<T extends LayerSymbol | LayerFill | LayerLine = LayerSymbol | LayerFill | LayerLine> {
-    name: string;
-    protected canvas: HTMLElement;
-    protected manager: GeometryManager;
-    protected map: maplibregl.Map;
-    protected layer: MapLayer<T>;
-    protected source: maplibregl.GeoJSONSource;
-    private isActive;
-    private slug;
-    constructor(manager: GeometryManager, name: string, type: 'symbol' | 'fill' | 'line');
-    protected randomPositions(name: string, length: number): ElementPoint[];
-    abstract getFeature(): Feature;
-    abstract getSelectionNodes(): SelectionNode[];
-    abstract getSelectionNodeUpdater(properties?: Record<string, unknown>): ((lng: number, lat: number) => void) | undefined;
-}

package/dist/components/MapEditor/lib/element_abstract.js

@@ -1,58 +0,0 @@
-import { MapLayer } from './map_layer.js';
-export class AbstractElement {
-    name;
-    canvas;
-    manager;
-    map;
-    layer;
-    source;
-    isActive = true;
-    slug = '_' + Math.random().toString(36).slice(2);
-    constructor(manager, name, type) {
-        this.manager = manager;
-        this.map = manager.map;
-        this.canvas = this.map.getCanvasContainer();
-        this.name = name;
-        this.map.addSource('source' + this.slug, {
-            type: 'geojson',
-            data: { type: 'FeatureCollection', features: [] }
-        });
-        this.source = this.map.getSource('source' + this.slug);
-        this.layer = new MapLayer(this.map, type + this.slug, 'source' + this.slug, type);
-        this.map.on('mouseenter', this.layer.id, () => {
-            if (this.isActive)
-                this.canvas.style.cursor = 'pointer';
-        });
-        this.map.on('mouseleave', this.layer.id, () => {
-            if (this.isActive)
-                this.canvas.style.cursor = 'default';
-        });
-        this.map.on('click', this.layer.id, (e) => {
-            if (this.isActive) {
-                this.manager.setActiveElement(this);
-                e.preventDefault();
-            }
-        });
-    }
-    randomPositions(name, length) {
-        let seed = name
-            .split('')
-            .reduce((acc, char) => (acc * 0x101 + char.charCodeAt(0)) % 0x100000000, 0);
-        const points = [];
-        for (let i = 0; i < length; i++) {
-            const xr = random() * 0.5 + 0.25;
-            const yr = random() * 0.5 + 0.25;
-            const bounds = this.map.getBounds();
-            points.push([
-                (1 - xr) * bounds.getWest() + xr * bounds.getEast(),
-                (1 - yr) * bounds.getSouth() + yr * bounds.getNorth()
-            ]);
-        }
-        return points;
-        function random() {
-            for (let i = 0; i < 10; i++)
-                seed = ((Math.cos(seed * 3.14 + 0.0159) + 1.1) * 9631) % 1;
-            return seed;
-        }
-    }
-}

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

@@ -1,14 +0,0 @@
-import { AbstractElement } from './element_abstract.js';
-import type { GeometryManager } from './geometry_manager.js';
-import type { ElementLine, LayerLine, SelectionNode } from './types.js';
-export declare const dashArrays: Map<string, number[] | undefined>;
-export declare class LineElement extends AbstractElement<LayerLine> {
-    readonly color: import("svelte/store").Writable<string>;
-    readonly dashed: import("svelte/store").Writable<string>;
-    readonly width: import("svelte/store").Writable<number>;
-    private line;
-    constructor(manager: GeometryManager, name: string, line?: ElementLine);
-    getFeature(): GeoJSON.Feature<GeoJSON.LineString>;
-    getSelectionNodes(): SelectionNode[];
-    getSelectionNodeUpdater(properties?: Record<string, unknown>): ((lng: number, lat: number) => void) | undefined;
-}

package/dist/components/MapEditor/lib/element_line.js

@@ -1,76 +0,0 @@
-import { Color } from '@versatiles/style';
-import { AbstractElement } from './element_abstract.js';
-import { get, writable } from 'svelte/store';
-import { getMiddlePoint } from './utils.js';
-export const dashArrays = new Map([
-    ['solid', undefined],
-    ['dashed', [2, 4]],
-    ['dotted', [0, 2]]
-]);
-export class LineElement extends AbstractElement {
-    color = writable('#ff0000');
-    dashed = writable('solid');
-    width = writable(2);
-    line = [
-        [0, 0],
-        [0, 0]
-    ];
-    constructor(manager, name, line) {
-        super(manager, name, 'line');
-        this.line = line ?? this.randomPositions(name, 2);
-        const getDashArray = () => dashArrays.get(get(this.dashed));
-        this.layer.setLayout({
-            'line-cap': 'round',
-            'line-join': 'round'
-        });
-        this.layer.setPaint({
-            'line-color': Color.parse(get(this.color)).asString(),
-            'line-dasharray': getDashArray(),
-            'line-width': get(this.width)
-        });
-        this.color.subscribe((value) => this.layer.updatePaint('line-color', Color.parse(value)));
-        this.width.subscribe((value) => this.layer.updatePaint('line-width', value));
-        this.dashed.subscribe(() => this.layer.updatePaint('line-dasharray', getDashArray()));
-        this.source.setData(this.getFeature());
-    }
-    getFeature() {
-        return {
-            type: 'Feature',
-            properties: {},
-            geometry: { type: 'LineString', coordinates: this.line }
-        };
-    }
-    getSelectionNodes() {
-        const points = [];
-        for (let i = 0; i < this.line.length; i++) {
-            points.push({ index: i, coordinates: this.line[i] });
-            if (i === this.line.length - 1)
-                continue;
-            points.push({
-                index: i + 0.5,
-                transparent: true,
-                coordinates: getMiddlePoint(this.line[i], this.line[i + 1])
-            });
-        }
-        return points;
-    }
-    getSelectionNodeUpdater(properties) {
-        if (properties == undefined)
-            return;
-        const index = properties.index;
-        let point;
-        if (index % 1 === 0) {
-            point = this.line[index];
-        }
-        else {
-            const i = Math.ceil(index);
-            this.line.splice(i, 0, [0, 0]);
-            point = this.line[i];
-        }
-        return (lng, lat) => {
-            point[0] = lng;
-            point[1] = lat;
-            this.source.setData(this.getFeature());
-        };
-    }
-}