@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/plugins/plugin-context.js

@@ -1,367 +0,0 @@
-// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
-// SPDX-License-Identifier: AGPL-3.0-only
-import { createId } from '../shared/utils/id.js';
-import { anchorElevationMeters, getAnchorElevationGeneration, projectAnchor, } from '../view/terrain/anchor.js';
-import { computeBoundingBox, } from '../view/ui/selection-ui/index.js';
-/**
- * Create a PluginContext
- *
- * @internal
- */
-export function createPluginContext(deps) {
-    const { store, eventEmitter, autoNameGenerator, spatialIndex, getActiveLayerId, findLayerForItem, findGroupForFeature, getModeManager, getDraw, terrain, selectionExtensions, } = deps;
-    /**
-     * Runs a write in a transaction whose notification carries the given source (the source
-     * of the outermost transaction applies, so inside batch() it is that of the batch)
-     */
-    function write(fn, source) {
-        store.transact(fn, source ?? 'local');
-    }
-    /**
-     * Convert features from the GeoJSON Feature form to Feature and add them to
-     * the Store
-     */
-    function addFeaturesToStore(features, source) {
-        const ids = [];
-        const layerId = getActiveLayerId();
-        write(() => {
-            for (const feature of features) {
-                const id = feature.id ?? createId();
-                const drawFeature = {
-                    id,
-                    type: feature.geometry.type,
-                    coordinates: feature.geometry.type === 'Point'
-                        ? feature.geometry.coordinates
-                        : feature.geometry
-                            .coordinates,
-                    layerId,
-                    properties: feature.properties ?? {},
-                    locked: false,
-                    visible: true,
-                };
-                // Note: adding to layer.order happens automatically inside createFeature().
-                // A write refused because the Store is read-only is not listed.
-                if (store.createFeature(drawFeature))
-                    ids.push(id);
-            }
-        }, source);
-        return ids;
-    }
-    return {
-        // === Reference to the MapLibreGLDraw instance itself (to call the extension point APIs) ===
-        get draw() {
-            return getDraw();
-        },
-        getStore: () => store,
-        autoNameGenerator,
-        // === Read API ===
-        getFeature: (id) => store.getFeature(id),
-        getAllFeatures: () => store.getAllFeatures(),
-        getGroup: (id) => store.getGroup(id),
-        getAllGroups: () => store.getAllGroups(),
-        getLayer: (id) => store.getLayer(id),
-        getAllLayers: () => store.getAllLayers(),
-        getSelection: () => store.getSelection(),
-        getSelectedIds: () => {
-            const selection = store.getSelection();
-            return selection.type === 'feature' ? [...selection.ids] : [];
-        },
-        // The name is confusing, but this is the order inside the active layer.
-        // Use getLayerIds for the stacking order of the layers.
-        getLayerOrder: () => {
-            const layer = store.getLayer(getActiveLayerId());
-            return layer?.order ?? [];
-        },
-        getLayerIds: () => store.getLayerOrder(),
-        getMode: () => store.getMode(),
-        // === Feature mutations ===
-        addFeatures: (features, source) => addFeaturesToStore(features, source),
-        updateFeature: (id, feature, source) => {
-            const existing = store.getFeature(id);
-            if (existing) {
-                const merged = {
-                    ...existing,
-                    ...feature,
-                    properties: { ...existing.properties, ...feature.properties },
-                };
-                write(() => store.updateFeature(id, merged), source);
-            }
-        },
-        deleteFeatures: (ids, source) => {
-            const idsArray = Array.isArray(ids) ? ids : [ids];
-            if (!idsArray.some((id) => store.getFeature(id) !== undefined))
-                return;
-            write(() => {
-                // Remove from the selection state (only when features are selected)
-                const selection = store.getSelection();
-                if (selection.type === 'feature') {
-                    const remainingSelection = selection.ids.filter((id) => !idsArray.includes(id));
-                    if (remainingSelection.length !== selection.ids.length) {
-                        if (remainingSelection.length === 0) {
-                            store.setSelection(null, []);
-                        }
-                        else {
-                            store.setSelection('feature', remainingSelection);
-                        }
-                    }
-                }
-                for (const id of idsArray) {
-                    // Remove from the group
-                    const groupId = findGroupForFeature(id);
-                    if (groupId) {
-                        const group = store.getGroup(groupId);
-                        if (group) {
-                            store.updateGroup(groupId, {
-                                featureIds: group.featureIds.filter((fid) => fid !== id),
-                            });
-                        }
-                    }
-                    // Remove from the order of the layer
-                    const layerId = findLayerForItem(id);
-                    if (layerId) {
-                        const layer = store.getLayer(layerId);
-                        if (layer) {
-                            store.updateLayer(layerId, { order: layer.order.filter((i) => i !== id) });
-                        }
-                    }
-                    store.deleteFeature(id);
-                }
-            }, source);
-        },
-        // === Group mutations ===
-        createGroup: (group, source) => {
-            const newGroup = {
-                id: group.id ?? createId(),
-                name: group.name,
-                visible: group.visible ?? true,
-                locked: group.locked ?? false,
-                featureIds: group.featureIds ?? [],
-            };
-            write(() => store.createGroup(newGroup), source);
-        },
-        updateGroup: (id, updates, source) => {
-            if (!store.getGroup(id))
-                return;
-            write(() => store.updateGroup(id, updates), source);
-        },
-        deleteGroup: (id, source) => {
-            if (!store.getGroup(id))
-                return;
-            write(() => store.deleteGroup(id), source);
-        },
-        addFeatureToGroup: (groupId, featureId, index, source) => {
-            write(() => {
-                const feature = store.getFeature(featureId);
-                const group = store.getGroup(groupId);
-                if (!feature || !group)
-                    return;
-                if (group.featureIds.includes(featureId))
-                    return; // Already contained in the group
-                // When the feature already belongs to another group, remove it from that group
-                if (feature.groupId && feature.groupId !== groupId) {
-                    const oldGroup = store.getGroup(feature.groupId);
-                    if (oldGroup) {
-                        store.updateGroup(feature.groupId, {
-                            featureIds: oldGroup.featureIds.filter((id) => id !== featureId),
-                        });
-                    }
-                }
-                // Remove the feature from the order of the layer (when it is contained
-                // in the order on its own)
-                const currentLayerId = findLayerForItem(featureId);
-                if (currentLayerId) {
-                    const currentLayer = store.getLayer(currentLayerId);
-                    if (currentLayer?.order.includes(featureId)) {
-                        store.updateLayer(currentLayerId, {
-                            order: currentLayer.order.filter((id) => id !== featureId),
-                        });
-                    }
-                }
-                // Add it to the featureIds of the group
-                const newFeatureIds = [...group.featureIds];
-                if (index !== undefined) {
-                    newFeatureIds.splice(index, 0, featureId);
-                }
-                else {
-                    newFeatureIds.push(featureId);
-                }
-                store.updateGroup(groupId, { featureIds: newFeatureIds });
-                // Get the layer the group belongs to
-                const targetLayerId = findLayerForItem(groupId);
-                // Update the groupId and the layerId of the feature
-                const updates = { groupId };
-                if (targetLayerId && feature.layerId !== targetLayerId) {
-                    updates.layerId = targetLayerId;
-                }
-                store.updateFeature(featureId, updates);
-            }, source);
-        },
-        removeFeatureFromGroup: (groupId, featureId, source) => {
-            write(() => {
-                const group = store.getGroup(groupId);
-                const feature = store.getFeature(featureId);
-                if (!group || !feature || feature.groupId !== groupId)
-                    return;
-                // Find the layer the group belongs to
-                const layerId = findLayerForItem(groupId);
-                // Remove the feature from the group
-                store.updateGroup(groupId, {
-                    featureIds: group.featureIds.filter((id) => id !== featureId),
-                });
-                // Clear the groupId of the feature
-                store.updateFeature(featureId, { groupId: undefined });
-                // Add the feature to the order of the layer (right after the group)
-                if (layerId) {
-                    const layer = store.getLayer(layerId);
-                    if (layer) {
-                        const groupIndex = layer.order.indexOf(groupId);
-                        const newOrder = [...layer.order];
-                        newOrder.splice(groupIndex + 1, 0, featureId);
-                        store.updateLayer(layerId, { order: newOrder });
-                    }
-                }
-            }, source);
-        },
-        findGroupForFeature,
-        // === Layer mutations ===
-        createLayer: (layer, source) => {
-            const newLayer = {
-                id: layer.id ?? createId(),
-                name: layer.name,
-                visible: layer.visible ?? true,
-                locked: layer.locked ?? false,
-                opacity: layer.opacity ?? 1.0,
-                order: layer.order ?? [],
-            };
-            write(() => store.createLayer(newLayer), source);
-        },
-        updateLayer: (id, updates, source) => {
-            if (!store.getLayer(id))
-                return;
-            write(() => store.updateLayer(id, updates), source);
-        },
-        deleteLayer: (id, source) => {
-            if (!store.getLayer(id))
-                return;
-            write(() => store.deleteLayer(id), source);
-        },
-        addToLayer: (layerId, featureId, source) => {
-            const layer = store.getLayer(layerId);
-            if (layer && !layer.order.includes(featureId)) {
-                write(() => store.updateLayer(layerId, { order: [...layer.order, featureId] }), source);
-            }
-        },
-        removeFromLayer: (layerId, featureId, source) => {
-            const layer = store.getLayer(layerId);
-            if (layer) {
-                const order = layer.order.filter((id) => id !== featureId);
-                write(() => store.updateLayer(layerId, { order }), source);
-            }
-        },
-        findLayerForFeature: findLayerForItem,
-        moveItemToLayer: (itemId, targetLayerId, targetIndex, source) => {
-            write(() => {
-                // Remove from the order of the current layer
-                const currentLayerId = findLayerForItem(itemId);
-                if (currentLayerId) {
-                    const currentLayer = store.getLayer(currentLayerId);
-                    if (currentLayer) {
-                        store.updateLayer(currentLayerId, {
-                            order: currentLayer.order.filter((id) => id !== itemId),
-                        });
-                    }
-                }
-                // When it belongs to a group, remove it from the group and clear the groupId as well
-                const groupId = findGroupForFeature(itemId);
-                if (groupId) {
-                    const group = store.getGroup(groupId);
-                    if (group) {
-                        store.updateGroup(groupId, {
-                            featureIds: group.featureIds.filter((id) => id !== itemId),
-                        });
-                    }
-                    // Clear the groupId of the feature
-                    const feature = store.getFeature(itemId);
-                    if (feature) {
-                        store.updateFeature(itemId, { groupId: undefined, layerId: targetLayerId });
-                    }
-                }
-                else {
-                    // When it does not belong to a group, update only the layerId
-                    const feature = store.getFeature(itemId);
-                    if (feature) {
-                        store.updateFeature(itemId, { layerId: targetLayerId });
-                    }
-                }
-                // Add it to the order of the target layer
-                const targetLayer = store.getLayer(targetLayerId);
-                if (targetLayer) {
-                    const newOrder = [...targetLayer.order];
-                    if (targetIndex !== undefined) {
-                        newOrder.splice(targetIndex, 0, itemId);
-                    }
-                    else {
-                        newOrder.push(itemId);
-                    }
-                    store.updateLayer(targetLayerId, { order: newOrder });
-                }
-                // For a group, update the layerId of every feature inside the group as well
-                const group = store.getGroup(itemId);
-                if (group) {
-                    for (const featureId of group.featureIds) {
-                        const groupFeature = store.getFeature(featureId);
-                        if (groupFeature) {
-                            store.updateFeature(featureId, { layerId: targetLayerId });
-                        }
-                    }
-                }
-            }, source);
-        },
-        setLayerItemOrder: (layerId, order, source) => {
-            const layer = store.getLayer(layerId);
-            if (!layer)
-                return;
-            write(() => store.updateLayer(layerId, { order: [...order] }), source);
-        },
-        setSelection: (type, ids, source) => {
-            write(() => store.setSelection(type, ids), source);
-            getModeManager().notifySelectionChange();
-        },
-        // === Event API ===
-        emit: (event, data) => eventEmitter.emit(event, data),
-        on: (event, handler) => {
-            eventEmitter.on(event, handler);
-            return () => eventEmitter.off(event, handler);
-        },
-        off: (event, handler) => eventEmitter.off(event, handler),
-        // === Batch mutations ===
-        // Wrapping in store.transact merges the StateChanges notifications into a
-        // single one, so a subscriber that groups changes (into steps, for example)
-        // sees one unit, and
-        // the mutation hooks of the batch share one batchId
-        batch: (fn) => store.transact(fn),
-        // === Mode control ===
-        setMode: (mode) => getModeManager().setMode(mode),
-        // === Notification of external state change ===
-        notifyStateReset: () => {
-            getModeManager().notifyStateReset();
-        },
-        // === Vertex undo/redo ===
-        undoVertex: () => {
-            return getModeManager().undoVertex();
-        },
-        redoVertex: () => {
-            return getModeManager().redoVertex();
-        },
-        // === Derived state ===
-        invalidateFeatures: (type) => {
-            spatialIndex.invalidateType(type);
-        },
-        // === Terrain anchors of this draw instance ===
-        projectAnchor: (lng, lat) => projectAnchor(terrain, lng, lat),
-        anchorElevationMeters: (lng, lat) => anchorElevationMeters(terrain, lng, lat),
-        getAnchorElevationGeneration: () => getAnchorElevationGeneration(terrain),
-        // === Selection extents of this draw instance ===
-        computeBoundingBox: (feature) => computeBoundingBox(feature, selectionExtensions),
-    };
-}

package/dist/plugins/plugin-manager.d.ts

@@ -1,103 +0,0 @@
-/**
- * Plugin Manager
- *
- * Component responsible for registering and managing plugins and running hooks.
- */
-import type { DragNormalizedEvent, KeyNormalizedEvent, MouseNormalizedEvent } from '../dispatcher/types.js';
-import type { ModeFactory } from '../modes/handler.js';
-import type { Hooks, Plugin } from './plugin.js';
-/** The name of a plugin hook (a key of Hooks) */
-export type HookName = keyof Hooks;
-/**
- * Interface of the plugin manager
- */
-export interface PluginManager {
-    /**
-     * Register a plugin
-     *
-     * @returns the function that unregisters it (it does nothing for a plugin of the same name
-     *   that was already registered, which is skipped)
-     */
-    register(plugin: Plugin): () => void;
-    /** Unregister a plugin */
-    unregister(name: string): void;
-    /** Run a hook */
-    runHook<K extends HookName>(hookName: K, ...args: Parameters<NonNullable<Hooks[K]>>): void;
-    /** Get the API of a plugin */
-    getPluginApi<T>(name: string): T | undefined;
-    /** Get the registered modes */
-    getModes(): Record<string, ModeFactory>;
-    /** Get the names of the registered plugins */
-    getPluginNames(): string[];
-    /**
-     * Handle a keyboard event
-     *
-     * Calls onKeyDown of the registered plugins in order.
-     * If any plugin returns true, the event is regarded as consumed.
-     *
-     * @param event Normalized keyboard event
-     * @returns true when any plugin consumed the event
-     */
-    handleKeyDown(event: KeyNormalizedEvent): boolean;
-    /**
-     * Handle a mouse move event
-     *
-     * Calls onMouseMove of the registered plugins in order.
-     *
-     * @param event Normalized mouse move event
-     */
-    handleMouseMove(event: MouseNormalizedEvent): void;
-    /**
-     * Handle a drag move event
-     *
-     * Calls onDragMove of the registered plugins in order (the counterpart of
-     * onMouseMove).
-     *
-     * @param event Normalized drag event
-     */
-    handleDragMove(event: DragNormalizedEvent): void;
-    /**
-     * Handle a mouse leave event
-     *
-     * Calls onMouseLeave of the registered plugins in order.
-     */
-    handleMouseLeave(): void;
-    /**
-     * Filter the selection candidates
-     *
-     * Applies filterSelection of the registered plugins in order.
-     */
-    filterSelectionCandidates(candidateIds: string[]): string[];
-    /**
-     * Notify the plugins that an already selected feature was clicked
-     *
-     * @returns true when any plugin handled it
-     */
-    handleFeatureClick(featureId: string): boolean;
-    /**
-     * Notify the plugins that a feature was double-clicked
-     *
-     * @returns true when any plugin handled it
-     */
-    handleFeatureDoubleClick(featureId: string): boolean;
-    /**
-     * Whether any plugin is in the middle of an interaction
-     */
-    isPluginInteracting(): boolean;
-    /**
-     * Complete the interaction of all plugins
-     */
-    finishPluginInteraction(): void;
-    /**
-     * Cancel the interaction of all plugins
-     */
-    cancelPluginInteraction(): void;
-    /**
-     * Get the DOM container of a plugin's interaction
-     */
-    getPluginInteractionContainer(): HTMLElement | null;
-    /**
-     * Notify the plugins that a feature was created
-     */
-    notifyFeatureCreated(featureId: string, featureType: string): void;
-}