@sakuzu/maplibre-gl-draw 1.0.0 → 2.1.0

package/dist/plugins/plugin-manager.js

@@ -1,316 +0,0 @@
-// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
-// SPDX-License-Identifier: AGPL-3.0-only
-/**
- * Create a plugin manager
- *
- * @param getContext Function that obtains the PluginContext lazily (made lazy
- *   because of the circular initialization inside createMapLibreGLDraw)
- * @param modeManager Reference to the ModeManager used to register
- *   Plugin.modes automatically
- *
- * @internal
- */
-export function createPluginManager(getContext, modeManager) {
-    const plugins = new Map();
-    /** The cancel functions of the modes each plugin registered */
-    const pluginModes = new Map();
-    const hookHandlers = new Map();
-    // Remove the hook handlers of a plugin from hookHandlers.
-    // Shared by the rollback on a failed register and by unregister.
-    function removeHookHandlers(plugin) {
-        if (!plugin.hooks)
-            return;
-        for (const [hookName, handler] of Object.entries(plugin.hooks)) {
-            if (!handler)
-                continue;
-            const handlers = hookHandlers.get(hookName);
-            if (!handlers)
-                continue;
-            const index = handlers.indexOf(handler);
-            if (index !== -1) {
-                handlers.splice(index, 1);
-            }
-        }
-    }
-    /** Removes the modes a plugin registered (a mode it is running falls back to select) */
-    function removeModes(name) {
-        for (const cancel of pluginModes.get(name) ?? [])
-            cancel();
-        pluginModes.delete(name);
-    }
-    function register(plugin) {
-        if (plugins.has(plugin.name)) {
-            console.warn(`Plugin "${plugin.name}" is already registered. Skipping.`);
-            return () => { };
-        }
-        plugins.set(plugin.name, plugin);
-        // Register Plugin.modes with the ModeManager automatically.
-        // Done before onInstall so that setMode can be called inside onInstall.
-        if (plugin.modes) {
-            const cancels = [];
-            for (const [name, factory] of Object.entries(plugin.modes)) {
-                cancels.push(modeManager.registerMode(name, factory));
-            }
-            pluginModes.set(plugin.name, cancels);
-        }
-        // Register the hooks
-        if (plugin.hooks) {
-            for (const [hookName, handler] of Object.entries(plugin.hooks)) {
-                if (handler) {
-                    const name = hookName;
-                    if (!hookHandlers.has(name)) {
-                        hookHandlers.set(name, []);
-                    }
-                    hookHandlers.get(name)?.push(handler);
-                }
-            }
-        }
-        // Call onInstall. On failure, roll back the registered hooks, the modes and the
-        // plugin entry and rethrow the exception (so that no half-finished
-        // registration state is left behind).
-        try {
-            plugin.onInstall?.(getContext());
-        }
-        catch (error) {
-            removeHookHandlers(plugin);
-            removeModes(plugin.name);
-            plugins.delete(plugin.name);
-            throw error;
-        }
-        return () => {
-            if (plugins.get(plugin.name) === plugin)
-                unregister(plugin.name);
-        };
-    }
-    function unregister(name) {
-        const plugin = plugins.get(name);
-        if (!plugin) {
-            return;
-        }
-        // Isolate with try/finally so that an exception from onUninstall does not
-        // skip the unregistration work.
-        try {
-            // The modes go first, so a mode of the plugin that is running stops (falling back to
-            // select) while the plugin is still installed
-            removeModes(name);
-            plugin.onUninstall?.();
-        }
-        catch (error) {
-            console.error(`Error in plugin "${name}" onUninstall:`, error);
-        }
-        finally {
-            // Unregister the hooks (and the modes, when removing them threw)
-            removeHookHandlers(plugin);
-            removeModes(name);
-            plugins.delete(name);
-        }
-    }
-    function runHook(hookName, ...args) {
-        const handlers = hookHandlers.get(hookName);
-        if (!handlers)
-            return;
-        for (const handler of handlers) {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                handler(...args);
-            }
-            catch (error) {
-                console.error(`Error in plugin hook "${hookName}":`, error);
-            }
-        }
-    }
-    function getPluginApi(name) {
-        const plugin = plugins.get(name);
-        return plugin?.api;
-    }
-    function getModes() {
-        const modes = {};
-        for (const plugin of plugins.values()) {
-            if (plugin.modes) {
-                Object.assign(modes, plugin.modes);
-            }
-        }
-        return modes;
-    }
-    function getPluginNames() {
-        return Array.from(plugins.keys());
-    }
-    function handleKeyDown(event) {
-        for (const plugin of plugins.values()) {
-            if (plugin.onKeyDown) {
-                try {
-                    const consumed = plugin.onKeyDown(event);
-                    if (consumed) {
-                        return true;
-                    }
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" onKeyDown:`, error);
-                }
-            }
-        }
-        return false;
-    }
-    function handleMouseMove(event) {
-        for (const plugin of plugins.values()) {
-            if (plugin.onMouseMove) {
-                try {
-                    plugin.onMouseMove(event);
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" onMouseMove:`, error);
-                }
-            }
-        }
-    }
-    function handleDragMove(event) {
-        for (const plugin of plugins.values()) {
-            if (plugin.onDragMove) {
-                try {
-                    plugin.onDragMove(event);
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" onDragMove:`, error);
-                }
-            }
-        }
-    }
-    function handleMouseLeave() {
-        for (const plugin of plugins.values()) {
-            if (plugin.onMouseLeave) {
-                try {
-                    plugin.onMouseLeave();
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" onMouseLeave:`, error);
-                }
-            }
-        }
-    }
-    function filterSelectionCandidates(candidateIds) {
-        let filtered = candidateIds;
-        for (const plugin of plugins.values()) {
-            if (plugin.filterSelection) {
-                try {
-                    filtered = plugin.filterSelection(filtered);
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" filterSelection:`, error);
-                }
-            }
-        }
-        return filtered;
-    }
-    function handleFeatureClick(featureId) {
-        for (const plugin of plugins.values()) {
-            if (plugin.onFeatureClick) {
-                try {
-                    if (plugin.onFeatureClick(featureId)) {
-                        return true;
-                    }
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" onFeatureClick:`, error);
-                }
-            }
-        }
-        return false;
-    }
-    function handleFeatureDoubleClick(featureId) {
-        for (const plugin of plugins.values()) {
-            if (plugin.onFeatureDoubleClick) {
-                try {
-                    if (plugin.onFeatureDoubleClick(featureId)) {
-                        return true;
-                    }
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" onFeatureDoubleClick:`, error);
-                }
-            }
-        }
-        return false;
-    }
-    function isPluginInteracting() {
-        for (const plugin of plugins.values()) {
-            if (plugin.isInteracting?.()) {
-                return true;
-            }
-        }
-        return false;
-    }
-    function finishPluginInteraction() {
-        for (const plugin of plugins.values()) {
-            if (plugin.isInteracting?.()) {
-                try {
-                    plugin.finishInteraction?.();
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" finishInteraction:`, error);
-                }
-            }
-        }
-    }
-    function cancelPluginInteraction() {
-        for (const plugin of plugins.values()) {
-            if (plugin.isInteracting?.()) {
-                try {
-                    plugin.cancelInteraction?.();
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" cancelInteraction:`, error);
-                }
-            }
-        }
-    }
-    function getPluginInteractionContainer() {
-        for (const plugin of plugins.values()) {
-            if (plugin.isInteracting?.()) {
-                const container = plugin.getInteractionContainer?.();
-                if (container)
-                    return container;
-            }
-        }
-        return null;
-    }
-    function notifyFeatureCreated(featureId, featureType) {
-        for (const plugin of plugins.values()) {
-            if (plugin.onFeatureCreated) {
-                try {
-                    plugin.onFeatureCreated(featureId, featureType);
-                }
-                catch (error) {
-                    console.error(`Error in plugin "${plugin.name}" onFeatureCreated:`, error);
-                }
-            }
-        }
-    }
-    return {
-        register,
-        unregister,
-        runHook,
-        getPluginApi,
-        getModes,
-        getPluginNames,
-        handleKeyDown,
-        handleMouseMove,
-        handleDragMove,
-        handleMouseLeave,
-        filterSelectionCandidates,
-        handleFeatureClick,
-        handleFeatureDoubleClick,
-        isPluginInteracting,
-        finishPluginInteraction,
-        cancelPluginInteraction,
-        getPluginInteractionContainer,
-        notifyFeatureCreated,
-    };
-}
-/**
- * Create the default MutationContext
- *
- * @internal
- */
-export function createMutationContext(source = 'local', batchId) {
-    return { source, batchId };
-}