@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/api/impl/input.js

@@ -0,0 +1,180 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { toPosition, toScreenPoint, toSnapResult } from './contexts.js';
+/**
+ * A pointer event of the engine as the contract gives it
+ *
+ * @param event - The event as it came, before snapping
+ * @param snapped - The same event after snapping (the event itself when it was not snapped)
+ * @param snap - The snapping result, or null when the position was not snapped
+ * @internal
+ */
+export function toPointerEvent(event, snapped = event, snap = null) {
+    return {
+        point: toScreenPoint(event.point),
+        lngLat: toPosition(event.lngLat),
+        snapped: toSnapResult(snap, toPosition(snapped.lngLat)),
+        modifiers: { ...event.modifiers },
+        pointerType: event.pointerType ?? 'mouse',
+        // The engine keeps the event of the browser it received: a pointer or mouse event, or a
+        // touch event for a finger
+        original: event.originalEvent,
+        ...('programmatic' in event && event.programmatic === true && { programmatic: true }),
+    };
+}
+/**
+ * A key event of the engine as the contract gives it
+ *
+ * @internal
+ */
+export function toKeyEvent(event) {
+    return { key: event.key, modifiers: { ...event.modifiers }, original: event.originalEvent };
+}
+/**
+ * Calls the receiver of an input of the contract for an event of the engine
+ *
+ * @returns True when the receiver consumed the event
+ * @internal
+ */
+export function deliver(receivers, event, snapped, snap) {
+    const pointer = () => toPointerEvent(event, snapped, snap);
+    switch (event.type) {
+        case 'click':
+            return receivers.onClick?.(pointer()) === true;
+        case 'dblclick':
+            return receivers.onDoubleClick?.(pointer()) === true;
+        case 'mousedown':
+            return receivers.onPointerDown?.(pointer()) === true;
+        case 'mouseup':
+            return receivers.onPointerUp?.(pointer()) === true;
+        case 'mousemove':
+            return receivers.onPointerMove?.(pointer()) === true;
+        case 'dragstart':
+            return receivers.onDragStart?.(pointer()) === true;
+        case 'dragmove':
+            return receivers.onDrag?.(pointer()) === true;
+        case 'dragend':
+            return receivers.onDragEnd?.(pointer()) === true;
+        case 'dragcancel':
+            return receivers.onDragCancel?.(pointer()) === true;
+        case 'keydown':
+            return receivers.onKeyDown?.(toKeyEvent(event)) === true;
+        case 'keyup':
+            return receivers.onKeyUp?.(toKeyEvent(event)) === true;
+        default:
+            return false;
+    }
+}
+/** The receiver of the contract each snapped input of the engine goes to */
+const SNAP_RECEIVERS = {
+    click: 'onClick',
+    mousemove: 'onPointerMove',
+    dragstart: 'onDragStart',
+    dragmove: 'onDrag',
+    dragend: 'onDragEnd',
+};
+/** Marks the handlers of the engine that run a mode of the contract */
+const BRIDGED = Symbol('extension mode');
+/**
+ * Wraps the handler of a mode of the contract into a handler of the mode manager of the
+ * engine. The input reaches it through {@link routeToMode}, not through the methods the
+ * engine calls on its own modes.
+ *
+ * @param onExit - Called after the mode was left, to end what its context holds
+ * @param entering - Runs the entering of the mode, so that its context knows the cursor the
+ *   mode sets then
+ * @internal
+ */
+export function bridgeMode(name, handler, onExit, entering = (run) => run()) {
+    const bridged = {
+        [BRIDGED]: handler,
+        modeName: name,
+        writesFeatures: handler.writes === true,
+        onStart() {
+            entering(() => handler.onEnter?.());
+        },
+        onStop() {
+            try {
+                handler.onExit?.();
+            }
+            finally {
+                onExit();
+            }
+        },
+        onExternalStateChange() {
+            handler.onCancel?.();
+        },
+        undoVertex: () => handler.onUndoVertex?.() === true,
+        redoVertex: () => handler.onRedoVertex?.() === true,
+        getSnapPreference: () => handler.snapPreference?.prefer ?? null,
+        isSnapEnabledFor(inputType) {
+            const unsnapped = handler.snapPreference?.unsnapped;
+            return !unsnapped?.includes(SNAP_RECEIVERS[inputType]);
+        },
+    };
+    return bridged;
+}
+/**
+ * The mode of the contract a handler of the engine runs, if it runs one
+ *
+ * @internal
+ */
+export function bridgedHandler(handler) {
+    return handler?.[BRIDGED];
+}
+/**
+ * Gives an event to a mode of the contract. An Escape that the mode does not consume
+ * interrupts it (`onCancel`).
+ *
+ * @returns Whether it consumed the event, or undefined when the handler runs no mode of the
+ *   contract
+ * @internal
+ */
+export function routeToMode(handler, event, snapped, snap) {
+    const mode = bridgedHandler(handler);
+    if (!mode)
+        return undefined;
+    const consumed = deliver(mode, event, snapped, snap);
+    if (!consumed && event.type === 'keydown' && event.key === 'Escape' && mode.onCancel) {
+        mode.onCancel();
+        return true;
+    }
+    return consumed;
+}
+/**
+ * The route of the input to the plugins and the modes of the contract
+ *
+ * @param plugins - The plugins in the order they were added
+ * @internal
+ */
+export function createInputRoute(plugins) {
+    return {
+        toPlugins(event, snapped, snap) {
+            for (const plugin of plugins()) {
+                if (!plugin.input)
+                    continue;
+                try {
+                    if (deliver(plugin.input, event, snapped, snap))
+                        return true;
+                }
+                catch (error) {
+                    console.error(`Error in the input of the plugin "${plugin.name}":`, error);
+                }
+            }
+            return false;
+        },
+        toMode: routeToMode,
+    };
+}
+/**
+ * Tells the plugins and the mode of the contract that the pointer left the map
+ *
+ * @internal
+ */
+export function deliverPointerLeave(plugins, handler) {
+    for (const plugin of plugins) {
+        if (plugin.input?.onPointerLeave?.() === true)
+            return;
+    }
+    bridgedHandler(handler)?.onPointerLeave?.();
+}

package/dist/api/impl/layers.js

@@ -0,0 +1,307 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { DrawError } from '../errors.js';
+import { featureLocked, filterEntries, invalidInput, isRecord, isTaken, layerLocked, locksIgnored, matches, notFound, onlyKeys, onlyLockOrVisibility, optionalBoolean, optionalIndex, optionalString, requireId, requireIds, requireRecord, } from './shared.js';
+const INPUT_KEYS = [
+    'id',
+    'name',
+    'visible',
+    'locked',
+    'opacity',
+    'styleRule',
+    'metadata',
+    'index',
+];
+const PATCH_KEYS = ['name', 'visible', 'locked', 'opacity', 'styleRule', 'metadata'];
+const FILTER_KEYS = ['visible', 'locked'];
+/**
+ * Creates `draw.layers`
+ *
+ * @param isStackEntry - Whether an ID that is not a layer may stand in the stacking order: a
+ *   dataset whose order is `layer-order`, or an entry the `isExternalEntry` option recognizes
+ * @internal
+ */
+export function createLayers(deps, isStackEntry = () => false) {
+    const { store } = deps;
+    const require = (id) => {
+        const layer = typeof id === 'string' ? store.getLayer(id) : undefined;
+        if (!layer)
+            throw notFound('layer', id);
+        return layer;
+    };
+    /** Every layer in stacking order, from the back; a layer off the order comes last */
+    const inOrder = () => {
+        const result = [];
+        for (const id of store.getLayerOrder()) {
+            const layer = store.getLayer(id);
+            if (layer)
+                result.push(layer);
+        }
+        if (result.length < store.listLayers().length) {
+            const listed = new Set(result.map((layer) => layer.id));
+            result.push(...store.listLayers().filter((layer) => !listed.has(layer.id)));
+        }
+        return result;
+    };
+    const list = (filter) => {
+        const entries = filterEntries(filter, FILTER_KEYS);
+        return inOrder().filter((layer) => matches(layer, entries));
+    };
+    /** Creates prepared layers and puts each at its index of the stacking order */
+    const createAll = (prepared) => {
+        store.transact(() => {
+            for (const entry of prepared)
+                insertLayer(store, entry);
+        });
+        return prepared.map(({ layer }) => store.getLayer(layer.id));
+    };
+    return {
+        get: (id) => store.getLayer(id),
+        getMany(ids) {
+            if (!Array.isArray(ids))
+                throw invalidInput('The IDs must be an array');
+            return ids.map((id) => store.getLayer(id));
+        },
+        list,
+        count: (filter) => list(filter).length,
+        has: (id) => store.getLayer(id) !== undefined,
+        create(input) {
+            const prepared = prepareLayer(deps, input, new Set());
+            if (store.isReadOnly())
+                return null;
+            return createAll([prepared])[0] ?? null;
+        },
+        createMany(inputs) {
+            if (!Array.isArray(inputs))
+                throw invalidInput('The inputs must be an array');
+            const pending = new Set();
+            const prepared = inputs.map((input) => {
+                const entry = prepareLayer(deps, input, pending);
+                pending.add(entry.layer.id);
+                return entry;
+            });
+            if (store.isReadOnly())
+                return null;
+            return createAll(prepared);
+        },
+        update(id, patch) {
+            const layer = require(id);
+            const updates = prepareLayerPatch(patch);
+            if (store.isReadOnly())
+                return null;
+            if (layerLocked(store, layer) && !onlyLockOrVisibility(patch))
+                return null;
+            store.updateLayer(layer.id, updates);
+            return store.getLayer(layer.id) ?? null;
+        },
+        updateMany(patches) {
+            if (!Array.isArray(patches))
+                throw invalidInput('The patches must be an array');
+            const seen = new Set();
+            const prepared = patches.map((entry) => {
+                requireRecord(entry, 'Each entry');
+                const layer = require(entry.id);
+                if (seen.has(layer.id))
+                    throw invalidInput(`The ID ${layer.id} is given twice`);
+                seen.add(layer.id);
+                return { layer, patch: entry.patch, updates: prepareLayerPatch(entry.patch) };
+            });
+            if (store.isReadOnly())
+                return null;
+            if (prepared.some(({ layer, patch }) => layerLocked(store, layer) && !onlyLockOrVisibility(patch))) {
+                return null;
+            }
+            store.transact(() => {
+                for (const { layer, updates } of prepared)
+                    store.updateLayer(layer.id, updates);
+            });
+            return prepared.map(({ layer }) => store.getLayer(layer.id));
+        },
+        delete(id) {
+            const layer = require(id);
+            if (store.isReadOnly() || holdsLock(store, layer))
+                return false;
+            return store.deleteLayer(layer.id);
+        },
+        deleteMany(ids) {
+            const layers = requireIds(ids).map(require);
+            if (store.isReadOnly() || layers.some((layer) => holdsLock(store, layer)))
+                return false;
+            store.transact(() => {
+                for (const layer of layers)
+                    store.deleteLayer(layer.id);
+            });
+            return true;
+        },
+        reorder(order) {
+            if (!Array.isArray(order) || order.some((id) => typeof id !== 'string')) {
+                throw invalidInput('The order must be an array of strings');
+            }
+            for (const id of order) {
+                if (!store.getLayer(id) && !isStackEntry(id))
+                    throw notFound('layer', id);
+            }
+            const listed = new Set(order);
+            const layerCount = order.filter((id) => store.getLayer(id)).length;
+            if (listed.size !== order.length || layerCount !== store.listLayers().length) {
+                throw invalidInput('The order must list every layer once, and no entry twice');
+            }
+            if (store.isReadOnly())
+                return false;
+            // An entry left out of the order keeps its position; the entries given fill the rest
+            const next = [...order];
+            const current = store.getLayerOrder();
+            const merged = current.map((id) => listed.has(id) || store.getLayer(id) ? next.shift() : id);
+            merged.push(...next);
+            return store.setLayerOrder(merged);
+        },
+        getOrder() {
+            return Object.freeze(store.getLayerOrder().filter((id) => store.getLayer(id) !== undefined || isStackEntry(id)));
+        },
+        getActive() {
+            const id = deps.getActiveLayerId();
+            return store.getLayer(id) ?? null;
+        },
+        setActive(id) {
+            const layer = require(id);
+            if (layer.locked)
+                return false;
+            deps.setActiveLayerId(layer.id);
+            return true;
+        },
+    };
+}
+/** Whether a deletion of the layer is refused: it, or a feature or group in it, is locked */
+function holdsLock(store, layer) {
+    if (locksIgnored(store))
+        return false;
+    if (layer.locked)
+        return true;
+    for (const itemId of layer.items) {
+        if (store.getGroup(itemId)?.locked)
+            return true;
+    }
+    return store
+        .listFeatures()
+        .some((feature) => feature.layerId === layer.id && featureLocked(store, feature));
+}
+/**
+ * Creates a prepared layer and puts it at its index of the stacking order, in the transaction
+ * of the caller
+ *
+ * @internal
+ */
+export function insertLayer(store, { layer, index }) {
+    store.createLayer(layer);
+    if (index !== undefined) {
+        const order = store.getLayerOrder().filter((id) => id !== layer.id);
+        order.splice(Math.min(index, order.length), 0, layer.id);
+        store.setLayerOrder(order);
+    }
+}
+/**
+ * Checks an input and builds the layer to store; throws DrawError on a wrong input
+ *
+ * @param pending - The IDs taken by the other entries of the same write
+ * @internal
+ */
+export function prepareLayer(deps, input, pending) {
+    const { store } = deps;
+    requireRecord(input, 'The input');
+    const record = input;
+    onlyKeys(record, INPUT_KEYS, 'The input');
+    checkLayerFields(record);
+    const index = optionalIndex(input.index);
+    let id;
+    if (input.id === undefined) {
+        id = deps.generateId();
+    }
+    else {
+        id = requireId(input.id);
+        if (isTaken(store, id) || pending.has(id) || store.getLayerOrder().includes(id)) {
+            throw new DrawError('already-exists', `The ID ${JSON.stringify(id)} is already taken`, {
+                id,
+            });
+        }
+    }
+    return {
+        layer: {
+            id,
+            name: input.name ?? deps.autoNameGenerator.generateLayerName(),
+            visible: input.visible ?? true,
+            locked: input.locked ?? false,
+            opacity: input.opacity ?? 1,
+            items: [],
+            styleRule: input.styleRule,
+            metadata: input.metadata,
+        },
+        index,
+    };
+}
+/** Checks a patch and builds the updates of the Store; throws DrawError on a wrong patch */
+function prepareLayerPatch(patch) {
+    requireRecord(patch, 'The patch');
+    const record = patch;
+    onlyKeys(record, PATCH_KEYS, 'The patch');
+    checkLayerFields(record);
+    const updates = {};
+    for (const key of PATCH_KEYS) {
+        if (!(key in record))
+            continue;
+        // A styleRule or a metadata given as undefined removes it; the other keys keep their value
+        if (record[key] === undefined && key !== 'styleRule' && key !== 'metadata')
+            continue;
+        updates[key] = record[key];
+    }
+    return updates;
+}
+/** Checks the fields of a layer input or patch */
+function checkLayerFields(record) {
+    optionalString(record, 'name');
+    optionalBoolean(record, 'visible');
+    optionalBoolean(record, 'locked');
+    const { opacity, styleRule, metadata } = record;
+    if (opacity !== undefined && (typeof opacity !== 'number' || !(opacity >= 0 && opacity <= 1))) {
+        throw invalidInput('opacity must be a number from 0 to 1');
+    }
+    if (styleRule !== undefined && !isStyleRule(styleRule)) {
+        throw invalidInput('styleRule is not a valid style rule');
+    }
+    if (metadata !== undefined && !isRecord(metadata)) {
+        throw invalidInput('metadata must be an object');
+    }
+}
+/** Whether the value has the shape of a style rule */
+function isStyleRule(value) {
+    if (!isRecord(value))
+        return false;
+    const isString = (v) => typeof v === 'string';
+    const isNumber = (v) => typeof v === 'number' && Number.isFinite(v);
+    switch (value.kind) {
+        case 'single':
+            return isString(value.color);
+        case 'categorical':
+            return (isString(value.property) &&
+                isRecord(value.map) &&
+                Object.values(value.map).every(isString) &&
+                isString(value.other));
+        case 'graduated':
+            return (isString(value.property) &&
+                Array.isArray(value.breaks) &&
+                value.breaks.every(isNumber) &&
+                Array.isArray(value.colors) &&
+                value.colors.every(isString) &&
+                value.colors.length === value.breaks.length + 1 &&
+                isString(value.other));
+        case 'continuous':
+            return (isString(value.property) &&
+                isNumber(value.min) &&
+                isNumber(value.max) &&
+                Array.isArray(value.ramp) &&
+                value.ramp.length === 2 &&
+                value.ramp.every(isString) &&
+                isString(value.other));
+        default:
+            return false;
+    }
+}

package/dist/api/impl/metadata.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/impl/metadata.js

@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { optionalString, requireRecord } from './shared.js';
+/**
+ * Creates `draw.metadata`
+ *
+ * @internal
+ */
+export function createMetadata(deps) {
+    const { store } = deps;
+    return {
+        get: () => store.getMetadata(),
+        update(patch) {
+            requireRecord(patch, 'The patch');
+            optionalString(patch, 'title');
+            optionalString(patch, 'description');
+            if (!store.setMetadata(patch))
+                return null;
+            return store.getMetadata();
+        },
+    };
+}

package/dist/api/impl/options.d.ts

@@ -0,0 +1 @@
+export {};