@sakuzu/maplibre-gl-draw 1.0.0

package/dist/plugins/plugin-manager.js

@@ -0,0 +1,316 @@
+// 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 };
+}