planning

node_modules/ol/src/events/Event.js

@@ -0,0 +1,77 @@
+/**
+ * @module ol/events/Event
+ */
+
+/**
+ * @classdesc
+ * Stripped down implementation of the W3C DOM Level 2 Event interface.
+ * See https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-interface.
+ *
+ * This implementation only provides `type` and `target` properties, and
+ * `stopPropagation` and `preventDefault` methods. It is meant as base class
+ * for higher level events defined in the library, and works with
+ * {@link module:ol/events/Target~Target}.
+ */
+class BaseEvent {
+  /**
+   * @param {string} type Type.
+   */
+  constructor(type) {
+    /**
+     * @type {boolean}
+     */
+    this.propagationStopped;
+
+    /**
+     * @type {boolean}
+     */
+    this.defaultPrevented;
+
+    /**
+     * The event type.
+     * @type {string}
+     * @api
+     */
+    this.type = type;
+
+    /**
+     * The event target.
+     * @type {Object}
+     * @api
+     */
+    this.target = null;
+  }
+
+  /**
+   * Prevent default. This means that no emulated `click`, `singleclick` or `doubleclick` events
+   * will be fired.
+   * @api
+   */
+  preventDefault() {
+    this.defaultPrevented = true;
+  }
+
+  /**
+   * Stop event propagation.
+   * @api
+   */
+  stopPropagation() {
+    this.propagationStopped = true;
+  }
+}
+
+/**
+ * @param {Event|import("./Event.js").default} evt Event
+ */
+export function stopPropagation(evt) {
+  evt.stopPropagation();
+}
+
+/**
+ * @param {Event|import("./Event.js").default} evt Event
+ */
+export function preventDefault(evt) {
+  evt.preventDefault();
+}
+
+export default BaseEvent;

node_modules/ol/src/events/EventType.js

@@ -0,0 +1,39 @@
+/**
+ * @module ol/events/EventType
+ */
+
+/**
+ * @enum {string}
+ * @const
+ */
+export default {
+  /**
+   * Generic change event. Triggered when the revision counter is increased.
+   * @event module:ol/events/Event~BaseEvent#change
+   * @api
+   */
+  CHANGE: 'change',
+
+  /**
+   * Generic error event. Triggered when an error occurs.
+   * @event module:ol/events/Event~BaseEvent#error
+   * @api
+   */
+  ERROR: 'error',
+
+  BLUR: 'blur',
+  CLEAR: 'clear',
+  CONTEXTMENU: 'contextmenu',
+  CLICK: 'click',
+  DBLCLICK: 'dblclick',
+  DRAGENTER: 'dragenter',
+  DRAGOVER: 'dragover',
+  DROP: 'drop',
+  FOCUS: 'focus',
+  KEYDOWN: 'keydown',
+  KEYPRESS: 'keypress',
+  LOAD: 'load',
+  RESIZE: 'resize',
+  TOUCHMOVE: 'touchmove',
+  WHEEL: 'wheel',
+};

node_modules/ol/src/events/KeyCode.js

@@ -0,0 +1,14 @@
+/**
+ * @module ol/events/KeyCode
+ */
+
+/**
+ * @enum {number}
+ * @const
+ */
+export default {
+  LEFT: 37,
+  UP: 38,
+  RIGHT: 39,
+  DOWN: 40,
+};

node_modules/ol/src/events/Target.js

@@ -0,0 +1,188 @@
+/**
+ * @module ol/events/Target
+ */
+import Disposable from '../Disposable.js';
+import Event from './Event.js';
+import {VOID} from '../functions.js';
+import {clear} from '../obj.js';
+
+/**
+ * @typedef {EventTarget|Target} EventTargetLike
+ */
+
+/**
+ * @classdesc
+ * A simplified implementation of the W3C DOM Level 2 EventTarget interface.
+ * See https://www.w3.org/TR/2000/REC-DOM-Level-2-Events-20001113/events.html#Events-EventTarget.
+ *
+ * There are two important simplifications compared to the specification:
+ *
+ * 1. The handling of `useCapture` in `addEventListener` and
+ *    `removeEventListener`. There is no real capture model.
+ * 2. The handling of `stopPropagation` and `preventDefault` on `dispatchEvent`.
+ *    There is no event target hierarchy. When a listener calls
+ *    `stopPropagation` or `preventDefault` on an event object, it means that no
+ *    more listeners after this one will be called. Same as when the listener
+ *    returns false.
+ */
+class Target extends Disposable {
+  /**
+   * @param {*} [opt_target] Default event target for dispatched events.
+   */
+  constructor(opt_target) {
+    super();
+
+    /**
+     * @private
+     * @type {*}
+     */
+    this.eventTarget_ = opt_target;
+
+    /**
+     * @private
+     * @type {Object<string, number>}
+     */
+    this.pendingRemovals_ = null;
+
+    /**
+     * @private
+     * @type {Object<string, number>}
+     */
+    this.dispatching_ = null;
+
+    /**
+     * @private
+     * @type {Object<string, Array<import("../events.js").Listener>>}
+     */
+    this.listeners_ = null;
+  }
+
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  addEventListener(type, listener) {
+    if (!type || !listener) {
+      return;
+    }
+    const listeners = this.listeners_ || (this.listeners_ = {});
+    const listenersForType = listeners[type] || (listeners[type] = []);
+    if (listenersForType.indexOf(listener) === -1) {
+      listenersForType.push(listener);
+    }
+  }
+
+  /**
+   * Dispatches an event and calls all listeners listening for events
+   * of this type. The event parameter can either be a string or an
+   * Object with a `type` property.
+   *
+   * @param {import("./Event.js").default|string} event Event object.
+   * @return {boolean|undefined} `false` if anyone called preventDefault on the
+   *     event object or if any of the listeners returned false.
+   * @api
+   */
+  dispatchEvent(event) {
+    const isString = typeof event === 'string';
+    const type = isString ? event : event.type;
+    const listeners = this.listeners_ && this.listeners_[type];
+    if (!listeners) {
+      return;
+    }
+
+    const evt = isString ? new Event(event) : /** @type {Event} */ (event);
+    if (!evt.target) {
+      evt.target = this.eventTarget_ || this;
+    }
+    const dispatching = this.dispatching_ || (this.dispatching_ = {});
+    const pendingRemovals =
+      this.pendingRemovals_ || (this.pendingRemovals_ = {});
+    if (!(type in dispatching)) {
+      dispatching[type] = 0;
+      pendingRemovals[type] = 0;
+    }
+    ++dispatching[type];
+    let propagate;
+    for (let i = 0, ii = listeners.length; i < ii; ++i) {
+      if ('handleEvent' in listeners[i]) {
+        propagate = /** @type {import("../events.js").ListenerObject} */ (
+          listeners[i]
+        ).handleEvent(evt);
+      } else {
+        propagate = /** @type {import("../events.js").ListenerFunction} */ (
+          listeners[i]
+        ).call(this, evt);
+      }
+      if (propagate === false || evt.propagationStopped) {
+        propagate = false;
+        break;
+      }
+    }
+    if (--dispatching[type] === 0) {
+      let pr = pendingRemovals[type];
+      delete pendingRemovals[type];
+      while (pr--) {
+        this.removeEventListener(type, VOID);
+      }
+      delete dispatching[type];
+    }
+    return propagate;
+  }
+
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    this.listeners_ && clear(this.listeners_);
+  }
+
+  /**
+   * Get the listeners for a specified event type. Listeners are returned in the
+   * order that they will be called in.
+   *
+   * @param {string} type Type.
+   * @return {Array<import("../events.js").Listener>|undefined} Listeners.
+   */
+  getListeners(type) {
+    return (this.listeners_ && this.listeners_[type]) || undefined;
+  }
+
+  /**
+   * @param {string} [opt_type] Type. If not provided,
+   *     `true` will be returned if this event target has any listeners.
+   * @return {boolean} Has listeners.
+   */
+  hasListener(opt_type) {
+    if (!this.listeners_) {
+      return false;
+    }
+    return opt_type
+      ? opt_type in this.listeners_
+      : Object.keys(this.listeners_).length > 0;
+  }
+
+  /**
+   * @param {string} type Type.
+   * @param {import("../events.js").Listener} listener Listener.
+   */
+  removeEventListener(type, listener) {
+    const listeners = this.listeners_ && this.listeners_[type];
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        if (this.pendingRemovals_ && type in this.pendingRemovals_) {
+          // make listener a no-op, and remove later in #dispatchEvent()
+          listeners[index] = VOID;
+          ++this.pendingRemovals_[type];
+        } else {
+          listeners.splice(index, 1);
+          if (listeners.length === 0) {
+            delete this.listeners_[type];
+          }
+        }
+      }
+    }
+  }
+}
+
+export default Target;

node_modules/ol/src/events/condition.js

@@ -0,0 +1,328 @@
+/**
+ * @module ol/events/condition
+ */
+import MapBrowserEventType from '../MapBrowserEventType.js';
+import {FALSE, TRUE} from '../functions.js';
+import {MAC, WEBKIT} from '../has.js';
+import {assert} from '../asserts.js';
+
+/**
+ * A function that takes an {@link module:ol/MapBrowserEvent~MapBrowserEvent} and returns a
+ * `{boolean}`. If the condition is met, true should be returned.
+ *
+ * @typedef {function(this: ?, import("../MapBrowserEvent.js").default): boolean} Condition
+ */
+
+/**
+ * Creates a condition function that passes when all provided conditions pass.
+ * @param {...Condition} var_args Conditions to check.
+ * @return {Condition} Condition function.
+ */
+export function all(var_args) {
+  const conditions = arguments;
+  /**
+   * @param {import("../MapBrowserEvent.js").default} event Event.
+   * @return {boolean} All conditions passed.
+   */
+  return function (event) {
+    let pass = true;
+    for (let i = 0, ii = conditions.length; i < ii; ++i) {
+      pass = pass && conditions[i](event);
+      if (!pass) {
+        break;
+      }
+    }
+    return pass;
+  };
+}
+
+/**
+ * Return `true` if only the alt-key is pressed, `false` otherwise (e.g. when
+ * additionally the shift-key is pressed).
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if only the alt key is pressed.
+ * @api
+ */
+export const altKeyOnly = function (mapBrowserEvent) {
+  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (
+    mapBrowserEvent.originalEvent
+  );
+  return (
+    originalEvent.altKey &&
+    !(originalEvent.metaKey || originalEvent.ctrlKey) &&
+    !originalEvent.shiftKey
+  );
+};
+
+/**
+ * Return `true` if only the alt-key and shift-key is pressed, `false` otherwise
+ * (e.g. when additionally the platform-modifier-key is pressed).
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if only the alt and shift keys are pressed.
+ * @api
+ */
+export const altShiftKeysOnly = function (mapBrowserEvent) {
+  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (
+    mapBrowserEvent.originalEvent
+  );
+  return (
+    originalEvent.altKey &&
+    !(originalEvent.metaKey || originalEvent.ctrlKey) &&
+    originalEvent.shiftKey
+  );
+};
+
+/**
+ * Return `true` if the map has the focus. This condition requires a map target
+ * element with a `tabindex` attribute, e.g. `<div id="map" tabindex="1">`.
+ *
+ * @param {import("../MapBrowserEvent.js").default} event Map browser event.
+ * @return {boolean} The map has the focus.
+ * @api
+ */
+export const focus = function (event) {
+  const targetElement = event.map.getTargetElement();
+  const activeElement = event.map.getOwnerDocument().activeElement;
+  return targetElement.contains(activeElement);
+};
+
+/**
+ * Return `true` if the map has the focus or no 'tabindex' attribute set.
+ *
+ * @param {import("../MapBrowserEvent.js").default} event Map browser event.
+ * @return {boolean} The map container has the focus or no 'tabindex' attribute.
+ */
+export const focusWithTabindex = function (event) {
+  return event.map.getTargetElement().hasAttribute('tabindex')
+    ? focus(event)
+    : true;
+};
+
+/**
+ * Return always true.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True.
+ * @api
+ */
+export const always = TRUE;
+
+/**
+ * Return `true` if the event is a `click` event, `false` otherwise.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if the event is a map `click` event.
+ * @api
+ */
+export const click = function (mapBrowserEvent) {
+  return mapBrowserEvent.type == MapBrowserEventType.CLICK;
+};
+
+/**
+ * Return `true` if the event has an "action"-producing mouse button.
+ *
+ * By definition, this includes left-click on windows/linux, and left-click
+ * without the ctrl key on Macs.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} The result.
+ */
+export const mouseActionButton = function (mapBrowserEvent) {
+  const originalEvent = /** @type {MouseEvent} */ (
+    mapBrowserEvent.originalEvent
+  );
+  return originalEvent.button == 0 && !(WEBKIT && MAC && originalEvent.ctrlKey);
+};
+
+/**
+ * Return always false.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} False.
+ * @api
+ */
+export const never = FALSE;
+
+/**
+ * Return `true` if the browser event is a `pointermove` event, `false`
+ * otherwise.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if the browser event is a `pointermove` event.
+ * @api
+ */
+export const pointerMove = function (mapBrowserEvent) {
+  return mapBrowserEvent.type == 'pointermove';
+};
+
+/**
+ * Return `true` if the event is a map `singleclick` event, `false` otherwise.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if the event is a map `singleclick` event.
+ * @api
+ */
+export const singleClick = function (mapBrowserEvent) {
+  return mapBrowserEvent.type == MapBrowserEventType.SINGLECLICK;
+};
+
+/**
+ * Return `true` if the event is a map `dblclick` event, `false` otherwise.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if the event is a map `dblclick` event.
+ * @api
+ */
+export const doubleClick = function (mapBrowserEvent) {
+  return mapBrowserEvent.type == MapBrowserEventType.DBLCLICK;
+};
+
+/**
+ * Return `true` if no modifier key (alt-, shift- or platform-modifier-key) is
+ * pressed.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True only if there no modifier keys are pressed.
+ * @api
+ */
+export const noModifierKeys = function (mapBrowserEvent) {
+  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (
+    mapBrowserEvent.originalEvent
+  );
+  return (
+    !originalEvent.altKey &&
+    !(originalEvent.metaKey || originalEvent.ctrlKey) &&
+    !originalEvent.shiftKey
+  );
+};
+
+/**
+ * Return `true` if only the platform-modifier-key (the meta-key on Mac,
+ * ctrl-key otherwise) is pressed, `false` otherwise (e.g. when additionally
+ * the shift-key is pressed).
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if only the platform modifier key is pressed.
+ * @api
+ */
+export const platformModifierKeyOnly = function (mapBrowserEvent) {
+  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (
+    mapBrowserEvent.originalEvent
+  );
+  return (
+    !originalEvent.altKey &&
+    (MAC ? originalEvent.metaKey : originalEvent.ctrlKey) &&
+    !originalEvent.shiftKey
+  );
+};
+
+/**
+ * Return `true` if only the shift-key is pressed, `false` otherwise (e.g. when
+ * additionally the alt-key is pressed).
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if only the shift key is pressed.
+ * @api
+ */
+export const shiftKeyOnly = function (mapBrowserEvent) {
+  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (
+    mapBrowserEvent.originalEvent
+  );
+  return (
+    !originalEvent.altKey &&
+    !(originalEvent.metaKey || originalEvent.ctrlKey) &&
+    originalEvent.shiftKey
+  );
+};
+
+/**
+ * Return `true` if the target element is not editable, i.e. not an `input`,
+ * `select`, or `textarea` element and no `contenteditable` attribute is
+ * set or inherited, `false` otherwise.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True only if the target element is not editable.
+ * @api
+ */
+export const targetNotEditable = function (mapBrowserEvent) {
+  const originalEvent = /** @type {KeyboardEvent|MouseEvent|TouchEvent} */ (
+    mapBrowserEvent.originalEvent
+  );
+  const tagName = /** @type {Element} */ (originalEvent.target).tagName;
+  return (
+    tagName !== 'INPUT' &&
+    tagName !== 'SELECT' &&
+    tagName !== 'TEXTAREA' &&
+    // `isContentEditable` is only available on `HTMLElement`, but it may also be a
+    // different type like `SVGElement`.
+    // @ts-ignore
+    !originalEvent.target.isContentEditable
+  );
+};
+
+/**
+ * Return `true` if the event originates from a mouse device.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if the event originates from a mouse device.
+ * @api
+ */
+export const mouseOnly = function (mapBrowserEvent) {
+  const pointerEvent = /** @type {import("../MapBrowserEvent").default} */ (
+    mapBrowserEvent
+  ).originalEvent;
+  assert(pointerEvent !== undefined, 56); // mapBrowserEvent must originate from a pointer event
+  // see https://www.w3.org/TR/pointerevents/#widl-PointerEvent-pointerType
+  return pointerEvent.pointerType == 'mouse';
+};
+
+/**
+ * Return `true` if the event originates from a touchable device.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if the event originates from a touchable device.
+ * @api
+ */
+export const touchOnly = function (mapBrowserEvent) {
+  const pointerEvt = /** @type {import("../MapBrowserEvent").default} */ (
+    mapBrowserEvent
+  ).originalEvent;
+  assert(pointerEvt !== undefined, 56); // mapBrowserEvent must originate from a pointer event
+  // see https://www.w3.org/TR/pointerevents/#widl-PointerEvent-pointerType
+  return pointerEvt.pointerType === 'touch';
+};
+
+/**
+ * Return `true` if the event originates from a digital pen.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if the event originates from a digital pen.
+ * @api
+ */
+export const penOnly = function (mapBrowserEvent) {
+  const pointerEvt = /** @type {import("../MapBrowserEvent").default} */ (
+    mapBrowserEvent
+  ).originalEvent;
+  assert(pointerEvt !== undefined, 56); // mapBrowserEvent must originate from a pointer event
+  // see https://www.w3.org/TR/pointerevents/#widl-PointerEvent-pointerType
+  return pointerEvt.pointerType === 'pen';
+};
+
+/**
+ * Return `true` if the event originates from a primary pointer in
+ * contact with the surface or if the left mouse button is pressed.
+ * See https://www.w3.org/TR/pointerevents/#button-states.
+ *
+ * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+ * @return {boolean} True if the event originates from a primary pointer.
+ * @api
+ */
+export const primaryAction = function (mapBrowserEvent) {
+  const pointerEvent = /** @type {import("../MapBrowserEvent").default} */ (
+    mapBrowserEvent
+  ).originalEvent;
+  assert(pointerEvent !== undefined, 56); // mapBrowserEvent must originate from a pointer event
+  return pointerEvent.isPrimary && pointerEvent.button === 0;
+};