@emuanalytics/flow-rdf-core 4.0.4 → 4.0.5

package/dist/lib/map/plugins/keyboard-shortcut-manager.mjs

@@ -0,0 +1,120 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class KeyboardShortcutManager {
+  constructor() {
+    __publicField(this, "listeners");
+    /**
+     * Handles key events of the root handler and passes them down to listeners.
+     * @param event
+     */
+    __publicField(this, "handleKeyboardEvent", (event) => {
+      if (this.isInputEvent(event))
+        return;
+      const key = this.keyDefinitionFromEvent(event);
+      for (const listener of this.listeners) {
+        const handler = listener.bindings[key];
+        if (handler) {
+          const propagate = handler(event);
+          if (propagate === true) {
+            continue;
+          } else {
+            event.stopPropagation();
+            return;
+          }
+        }
+      }
+    });
+    this.listeners = [];
+    document.addEventListener("keydown", this.handleKeyboardEvent);
+  }
+  /**
+   * Adds listener to keyboard events.
+   * @param bindings Object containing key/value pairs of keyCode/eventHandler function. Can add multiple comma separated `,` keyCodes for the same handler. Can optionally return `false` to stop propagation of other handlers.
+   * @param priority Can optionally set the priority of event handler, higher value means higher priority. Defaults to 0.
+   * @returns Function that can be used to unbind the listener.
+   */
+  addListener(bindings, priority) {
+    bindings = this.splitEventBindings(bindings);
+    const listener = this.addToListeners({ bindings, priority: priority ?? 0 });
+    const removeListener = () => {
+      this.removeFromListeners(listener);
+    };
+    return removeListener;
+  }
+  /**
+   * Splits multiple keyCode events and creates a new bindings map.
+   * @param bindings
+   */
+  splitEventBindings(bindings) {
+    const splitBindings = {};
+    for (const event in bindings) {
+      event.split(",").forEach((splitEvent) => {
+        splitBindings[this.normalizeKeyDefinition(splitEvent)] = bindings[event];
+      });
+    }
+    return splitBindings;
+  }
+  /**
+   * Checks is the event comes from an input type.
+   * @param event
+   */
+  isInputEvent(event) {
+    if (event.target instanceof Node) {
+      switch (event.target.nodeName) {
+        case "INPUT":
+        case "SELECT":
+        case "TEXTAREA":
+          return true;
+        default:
+          return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * Adds listener into internal array of listeners and sorts in `descending` order.
+   * @param listener
+   */
+  addToListeners(listener) {
+    this.listeners.push(listener);
+    this.listeners.sort((a, b) => b.priority - a.priority);
+    return listener;
+  }
+  /**
+   * Removes listener from internal array of listeners.
+   * @param listenerToRemove
+   */
+  removeFromListeners(listenerToRemove) {
+    this.listeners = this.listeners.filter((listener) => listener !== listenerToRemove);
+  }
+  normalizeKeyDefinition(keyDef) {
+    const parts = keyDef.split("+");
+    const ev = {
+      ctrlKey: parts.includes("Ctrl"),
+      shiftKey: parts.includes("Shift"),
+      altKey: parts.includes("Alt"),
+      metaKey: parts.includes("Meta"),
+      code: parts[parts.length - 1]
+    };
+    return this.keyDefinitionFromEvent(ev);
+  }
+  keyDefinitionFromEvent(ev) {
+    let keyDef = "";
+    if (ev.ctrlKey)
+      keyDef += "Ctrl+";
+    if (ev.shiftKey)
+      keyDef += "Shift+";
+    if (ev.altKey)
+      keyDef += "Alt+";
+    if (ev.metaKey)
+      keyDef += "Meta+";
+    keyDef += ev.code;
+    return keyDef;
+  }
+}
+
+export { KeyboardShortcutManager };

package/dist/lib/map/plugins/map-plugin-base.mjs

@@ -0,0 +1,25 @@
+import { EventEmitter } from 'eventemitter3';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class MapPluginBase extends EventEmitter {
+  constructor(pluginManager, options) {
+    super();
+    __publicField(this, "_pluginManager");
+    __publicField(this, "options");
+    this._pluginManager = pluginManager;
+    this.options = options ?? {};
+  }
+  get map() {
+    return this._pluginManager.map;
+  }
+  get pluginManager() {
+    return this._pluginManager;
+  }
+}
+
+export { MapPluginBase };

package/dist/lib/map/plugins/plugin-manager.mjs

@@ -0,0 +1,135 @@
+import Debug from 'debug';
+import { capitalize } from '../../utils/string-utils.mjs';
+import { isString } from '../../utils/type-checks.mjs';
+import { KeyboardShortcutManager } from './keyboard-shortcut-manager.mjs';
+import { FlowCoreError } from '../../errors/flow-error.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const debug = Debug("flow:map-plugin-manager");
+class PluginManager {
+  constructor(map) {
+    __publicField(this, "_map");
+    __publicField(this, "_keyboardShortcutManager", new KeyboardShortcutManager());
+    __publicField(this, "_plugins", /* @__PURE__ */ new Map());
+    __publicField(this, "_initialized", false);
+    __publicField(this, "_exclusivePlugins", /* @__PURE__ */ new Set());
+    this._map = map;
+    this.map.initialized.then(() => {
+      this._initialized = true;
+      for (const plugin of this._plugins.values()) {
+        if (plugin.initialize) {
+          plugin.initialize();
+        }
+      }
+    });
+  }
+  get map() {
+    return this._map;
+  }
+  usePlugin(plugin, options) {
+    if (this._plugins.has(plugin)) {
+      const oldInstance = this._plugins.get(plugin);
+      if (oldInstance.destroy) {
+        oldInstance.destroy();
+      }
+    }
+    const pluginInstance = new plugin(this, options);
+    this._plugins.set(plugin, pluginInstance);
+    debug(`FlowMap<${this.map.id}>: Using plugin '${pluginInstance.name}'`);
+    if (this._initialized && pluginInstance.initialize)
+      pluginInstance.initialize();
+    return pluginInstance;
+  }
+  getPlugin(pluginOrName) {
+    let name;
+    let pluginInstance;
+    if (isString(pluginOrName)) {
+      pluginInstance = Array.from(this._plugins.values()).find((p) => p.name === pluginOrName);
+      name = pluginOrName;
+    } else {
+      pluginInstance = this._plugins.get(pluginOrName);
+      name = pluginOrName.name;
+    }
+    if (!pluginInstance) {
+      throw new FlowCoreError(`<${name}>: plugin not registered`);
+    }
+    return pluginInstance;
+  }
+  removePlugin(pluginOrName) {
+    let pluginConstructor;
+    let pluginInstance;
+    if (isString(pluginOrName)) {
+      const pair = Array.from(this._plugins.entries()).find(([_, p]) => p.name === pluginOrName);
+      pluginConstructor = pair && pair[0];
+      pluginInstance = pair && pair[1];
+    } else {
+      pluginConstructor = pluginOrName;
+      pluginInstance = this._plugins.get(pluginOrName);
+    }
+    if (pluginInstance && pluginInstance.destroy) {
+      pluginInstance.destroy();
+    }
+    if (pluginConstructor)
+      this._plugins.delete(pluginConstructor);
+    return this;
+  }
+  removeAllPlugins() {
+    this._plugins.forEach((plugin) => {
+      if (plugin.destroy)
+        plugin.destroy();
+    });
+    this._plugins.clear();
+    return this;
+  }
+  setExclusivePlugin(plugin) {
+    this._exclusivePlugins.add(plugin);
+    this.forwardSetExclusivePlugin();
+    return this;
+  }
+  removeExclusivePlugin(plugin) {
+    this._exclusivePlugins.delete(plugin);
+    this.forwardSetExclusivePlugin();
+    return this;
+  }
+  addKeyboardShortcuts(keyboardShortcuts, priority = 0) {
+    return this._keyboardShortcutManager.addListener(keyboardShortcuts, priority);
+  }
+  forwardEvent(eventName, ...args) {
+    const handlerName = `handle${capitalize(eventName)}`;
+    this._plugins.forEach((plugin) => {
+      if (this._exclusivePlugins.size && !this._exclusivePlugins.has(plugin))
+        return;
+      const handler = plugin[handlerName];
+      if (handler) {
+        handler.apply(plugin, args);
+      }
+    });
+  }
+  forwardStyleChangeEvent(event) {
+    this._plugins.forEach((plugin) => {
+      if (this._exclusivePlugins.size && !this._exclusivePlugins.has(plugin))
+        return;
+      if (plugin.handleBeforeStyleChanged) {
+        const result = plugin.handleBeforeStyleChanged(event);
+        if (result) {
+          event.newStyle = result;
+        }
+      }
+    });
+    return event.newStyle;
+  }
+  forwardSetExclusivePlugin() {
+    this._plugins.forEach((plugin) => {
+      if (plugin.handleSetExclusivePlugin) {
+        plugin.handleSetExclusivePlugin(Array.from(this._exclusivePlugins));
+      }
+    });
+  }
+}
+
+export { PluginManager };

package/dist/lib/map/plugins/popup.plugin.mjs

@@ -0,0 +1,55 @@
+import { ensureArray } from '../../utils/ensure-array.mjs';
+import { isArray } from '../../utils/type-checks.mjs';
+import { MapPopup } from '../support/map-popup.mjs';
+import { MapPluginBase } from './map-plugin-base.mjs';
+import { FlowCoreError } from '../../errors/flow-error.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class PopupPlugin extends MapPluginBase {
+  constructor(pluginManager) {
+    super(pluginManager);
+    __publicField(this, "_popupTemplates", /* @__PURE__ */ new Map());
+    __publicField(this, "_popups", /* @__PURE__ */ new Set());
+    __publicField(this, "name", "PopupPlugin");
+  }
+  registerPopup(id, options) {
+    this._popupTemplates.set(id, options);
+  }
+  openPopup(id, eventOrLngLat, feature) {
+    const popupOptions = this._popupTemplates.get(id);
+    if (!popupOptions) {
+      throw new FlowCoreError(`MapPopup: no popup with id '${id}'`);
+    }
+    const popup = new MapPopup(this.map, popupOptions);
+    this._popups.add(popup);
+    popup.once("closed", () => {
+      this._popups.delete(popup);
+    });
+    if (isArray(eventOrLngLat)) {
+      popup.open(eventOrLngLat, feature);
+    } else {
+      popup.open(eventOrLngLat);
+    }
+    return popup;
+  }
+  closeAllPopups() {
+    this._popups.forEach((popup) => popup.close());
+    this._popups.clear();
+  }
+  closePopupsForSources(sources) {
+    sources = ensureArray(sources);
+    this._popups.forEach((popup) => {
+      if (popup.feature?.source && sources.indexOf(popup.feature?.source) >= 0) {
+        popup.close();
+        this._popups.delete(popup);
+      }
+    });
+  }
+}
+
+export { PopupPlugin };

package/dist/lib/map/plugins/selection/selection.events.mjs

@@ -0,0 +1,21 @@
+import { MapEvent } from '../../support/map-events.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class SelectionEvent extends MapEvent {
+  constructor(type, map, sourceIdentifier, features) {
+    super(type, map);
+    __publicField(this, "source");
+    __publicField(this, "sourceLayer");
+    __publicField(this, "features");
+    this.source = sourceIdentifier.source;
+    this.sourceLayer = sourceIdentifier.sourceLayer;
+    this.features = features;
+  }
+}
+
+export { SelectionEvent };

package/dist/lib/map/plugins/selection/selection.plugin.mjs

@@ -0,0 +1,136 @@
+import { FlowMapError } from '../../../errors/flow-map-error.mjs';
+import { ensureArray } from '../../../utils/ensure-array.mjs';
+import { isStringFull } from '../../../utils/type-checks.mjs';
+import { MapPluginBase } from '../map-plugin-base.mjs';
+import { PopupPlugin } from '../popup.plugin.mjs';
+import { SourceSelection } from './source-selection.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class SelectionPlugin extends MapPluginBase {
+  constructor(pluginManager) {
+    super(pluginManager);
+    __publicField(this, "_sourceSelections", /* @__PURE__ */ new Map());
+    __publicField(this, "_enablePopups", true);
+    __publicField(this, "name", "SelectionPlugin");
+  }
+  clearSelection(source) {
+    const sourceSelection = this._sourceSelections.get(source);
+    if (!sourceSelection) {
+      return;
+    }
+    switch (sourceSelection.options.mode) {
+      case "single":
+      case "multi":
+        sourceSelection.updateSelection(/* @__PURE__ */ new Set());
+    }
+  }
+  deselectFeatures(source, features) {
+    const sourceSelection = this._sourceSelections.get(source);
+    if (!sourceSelection) {
+      return;
+    }
+    features = ensureArray(features);
+    const currentSelection = new Set(sourceSelection.selectedFeatureIds);
+    switch (sourceSelection.options.mode) {
+      case "single":
+      case "multi":
+        features.forEach((f) => currentSelection.delete(f));
+        sourceSelection.updateSelection(currentSelection);
+    }
+  }
+  destroy() {
+    this._sourceSelections.forEach((sel) => sel.destroy());
+    this._sourceSelections.clear();
+  }
+  disableSelection(source) {
+    if (this._sourceSelections.has(source)) {
+      this._sourceSelections.get(source).destroy();
+      this._sourceSelections.delete(source);
+    }
+  }
+  enableSelection(source, options) {
+    if (options.popup) {
+      try {
+        this.map.getPlugin(PopupPlugin);
+      } catch (e) {
+        throw new FlowMapError(`enableSelection(): Popup plugin is required for automatic selection popups`);
+      }
+    }
+    this.disableSelection(source);
+    this._sourceSelections.set(source, new SourceSelection(this, source, options));
+  }
+  handleBeforeSourceRemoved(event) {
+    if (this._sourceSelections.has(event.source)) {
+      this._sourceSelections.get(event.source)?.destroy();
+      this._sourceSelections.delete(event.source);
+    }
+  }
+  handleClick(event) {
+    const multiSelect = event.originalEvent.shiftKey || event.originalEvent.altKey || event.originalEvent.metaKey;
+    const clickedFeature = event.features[0];
+    const clickedSource = clickedFeature?.source;
+    const selectionOptions = this._sourceSelections.get(clickedSource)?.options;
+    this._sourceSelections.forEach(
+      (sel) => sel.handleClick(event.lngLat, clickedFeature, selectionOptions, multiSelect, this._enablePopups)
+    );
+  }
+  selectFeatures(source, features) {
+    const sourceSelection = this._sourceSelections.get(source);
+    if (!sourceSelection) {
+      return;
+    }
+    features = ensureArray(features);
+    if (features.length === 0) {
+      this.clearSelection(source);
+      return;
+    }
+    let currentSelection = new Set(sourceSelection.selectedFeatureIds);
+    switch (sourceSelection.options.mode) {
+      case "single":
+        currentSelection = /* @__PURE__ */ new Set([features[0]]);
+        sourceSelection.updateSelection(currentSelection);
+        break;
+      case "multi":
+        features.forEach((f) => currentSelection.add(f));
+        sourceSelection.updateSelection(currentSelection);
+        break;
+    }
+    if (sourceSelection.selectedFeatureIds.size && isStringFull(sourceSelection.options.group)) {
+      this._sourceSelections.forEach((s) => {
+        if (s != sourceSelection && s.options.clear === "group" && s.options.group == sourceSelection.options.group) {
+          s.updateSelection(/* @__PURE__ */ new Set());
+        }
+      });
+    }
+  }
+  selectedFeatureIds(source) {
+    const sourceSelection = this._sourceSelections.get(source);
+    if (!sourceSelection) {
+      return [];
+    }
+    return Array.from(sourceSelection.selectedFeatureIds);
+  }
+  selectedFeatureStream(source) {
+    const sourceSelection = this._sourceSelections.get(source);
+    if (!sourceSelection) {
+      throw new FlowMapError("no source selection");
+    }
+    return sourceSelection.selectedFeatureStream;
+  }
+  enablePopups(enabled = true) {
+    this._enablePopups = true;
+  }
+  disablePopups() {
+    if (this._enablePopups) {
+      this.map.getPlugin(PopupPlugin).closeAllPopups();
+      this._enablePopups = false;
+    }
+  }
+}
+
+export { SelectionPlugin };

package/dist/lib/map/plugins/selection/source-selection.mjs

@@ -0,0 +1,156 @@
+import { assert } from '../../../utils/assert.mjs';
+import { ensureArray } from '../../../utils/ensure-array.mjs';
+import { isStringFull } from '../../../utils/type-checks.mjs';
+import { isFeatureWithId } from '../../types.mjs';
+import { PopupPlugin } from '../popup.plugin.mjs';
+import { SelectionEvent } from './selection.events.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class SourceSelection {
+  constructor(plugin, source, options) {
+    __publicField(this, "_featureStream");
+    __publicField(this, "_map");
+    __publicField(this, "_options");
+    __publicField(this, "_plugin");
+    __publicField(this, "_popups", /* @__PURE__ */ new Map());
+    __publicField(this, "_selectedFeatureIds", /* @__PURE__ */ new Set());
+    __publicField(this, "_sourceId");
+    __publicField(this, "_stateSubscription", null);
+    this._plugin = plugin;
+    this._map = plugin.map;
+    this._options = options;
+    const sourceType = plugin.map.getSource(source).type;
+    this._sourceId = {
+      source,
+      sourceLayer: sourceType === "vector" ? options.sourceLayer ?? "geometry" : void 0
+    };
+    this._featureStream = this._map.featureStream({
+      source,
+      sourceLayer: options.sourceLayer,
+      featureIds: []
+    });
+    if (options.selectionState) {
+      this._stateSubscription = this._map.context.state.toStream(options.selectionState, true).subscribe((val) => {
+        val = new Set(ensureArray(val));
+        this.updateSelection(val);
+      });
+    }
+  }
+  get options() {
+    return this._options;
+  }
+  get selectedFeatureIds() {
+    return this._selectedFeatureIds;
+  }
+  get selectedFeatureStream() {
+    return this._featureStream;
+  }
+  destroy() {
+    this._popups.forEach((popup) => popup.close());
+    this._stateSubscription?.unsubscribe();
+    this._selectedFeatureIds = /* @__PURE__ */ new Set();
+    this.updateMapSelectionState();
+  }
+  handleClick(lngLat, feature, selectionOptions, multiSelect, enablePopups) {
+    if (this._options.mode === "none") {
+      return;
+    }
+    const selectedFeatureIDs = new Set(this._selectedFeatureIds);
+    let clearSelection = false;
+    let toggleFeature = false;
+    let showPopup = false;
+    if (feature && feature.source === this._sourceId.source) {
+      if (this._options.mode === "single") {
+        if (selectedFeatureIDs.has(feature.id)) {
+          toggleFeature = true;
+        } else {
+          clearSelection = true;
+          toggleFeature = true;
+        }
+      } else {
+        if (!multiSelect) {
+          clearSelection = true;
+        }
+        toggleFeature = true;
+      }
+    } else if (feature && feature.source !== this._sourceId.source) {
+      clearSelection = this._options.clear === "group" ? selectionOptions?.group === this._options.group : !!this._options.clear;
+    } else {
+      clearSelection = !multiSelect;
+    }
+    if (clearSelection) {
+      selectedFeatureIDs.clear();
+    }
+    if (toggleFeature) {
+      assert(isFeatureWithId(feature));
+      if (selectedFeatureIDs.has(feature.id) && multiSelect) {
+        selectedFeatureIDs.delete(feature.id);
+        if (this._popups.has(feature.id))
+          this._popups.get(feature.id).close();
+      } else {
+        selectedFeatureIDs.add(feature.id);
+        showPopup = true;
+      }
+    }
+    this.updateSelection(selectedFeatureIDs);
+    if (enablePopups && showPopup && this._options.popup) {
+      assert(isFeatureWithId(feature));
+      if (!this._popups.has(feature.id)) {
+        const popup = this._map.getPlugin(PopupPlugin).openPopup(this._options.popup, lngLat, feature);
+        if (popup) {
+          popup.on("closed", () => {
+            this._popups.delete(feature.id);
+          });
+          this._popups.set(feature.id, popup);
+        }
+      }
+    }
+  }
+  updateSelection(featureIds) {
+    if (!this.areSetsEqual(featureIds, this._selectedFeatureIds)) {
+      this._selectedFeatureIds = featureIds;
+      this.updateMapSelectionState();
+      this.updateStateStore();
+      this._featureStream.featureIds = Array.from(featureIds);
+      this._popups.forEach((popup) => {
+        assert(isFeatureWithId(popup.feature));
+        if (popup.feature.id && !featureIds.has(popup.feature.id)) {
+          popup.close();
+        }
+      });
+      const event = new SelectionEvent(
+        "selectionChanged",
+        this._map,
+        this._sourceId,
+        Array.from(this._selectedFeatureIds)
+      );
+      this._plugin.emit(event.type, event);
+    }
+  }
+  areSetsEqual(a, b) {
+    return a.size === b.size && [...a].every((value) => b.has(value));
+  }
+  updateMapSelectionState() {
+    this._map.removeFeatureState(this._sourceId, "selected", false);
+    this._selectedFeatureIds.forEach(
+      (id) => this._map.setFeatureState({ ...this._sourceId, id }, { selected: true }, false)
+    );
+  }
+  updateStateStore() {
+    if (isStringFull(this._options.selectionState)) {
+      const selectedIds = Array.from(this._selectedFeatureIds);
+      if (this._options.mode === "single") {
+        this._map.context.state.set(this._options.selectionState, selectedIds[0]);
+      } else if (this._options.mode === "multi") {
+        this._map.context.state.set(this._options.selectionState, selectedIds);
+      }
+    }
+  }
+}
+
+export { SourceSelection };