planning

node_modules/ol/src/Observable.js

@@ -0,0 +1,192 @@
+/**
+ * @module ol/Observable
+ */
+import EventTarget from './events/Target.js';
+import EventType from './events/EventType.js';
+import {listen, listenOnce, unlistenByKey} from './events.js';
+
+/***
+ * @template {string} Type
+ * @template {Event|import("./events/Event.js").default} EventClass
+ * @template Return
+ * @typedef {(type: Type, listener: (event: EventClass) => ?) => Return} OnSignature
+ */
+
+/***
+ * @template {string} Type
+ * @template Return
+ * @typedef {(type: Type[], listener: (event: Event|import("./events/Event").default) => ?) => Return extends void ? void : Return[]} CombinedOnSignature
+ */
+
+/**
+ * @typedef {'change'|'error'} EventTypes
+ */
+
+/***
+ * @template Return
+ * @typedef {OnSignature<EventTypes, import("./events/Event.js").default, Return> & CombinedOnSignature<EventTypes, Return>} ObservableOnSignature
+ */
+
+/**
+ * @classdesc
+ * Abstract base class; normally only used for creating subclasses and not
+ * instantiated in apps.
+ * An event target providing convenient methods for listener registration
+ * and unregistration. A generic `change` event is always available through
+ * {@link module:ol/Observable~Observable#changed}.
+ *
+ * @fires import("./events/Event.js").default
+ * @api
+ */
+class Observable extends EventTarget {
+  constructor() {
+    super();
+
+    this.on =
+      /** @type {ObservableOnSignature<import("./events").EventsKey>} */ (
+        this.onInternal
+      );
+
+    this.once =
+      /** @type {ObservableOnSignature<import("./events").EventsKey>} */ (
+        this.onceInternal
+      );
+
+    this.un = /** @type {ObservableOnSignature<void>} */ (this.unInternal);
+
+    /**
+     * @private
+     * @type {number}
+     */
+    this.revision_ = 0;
+  }
+
+  /**
+   * Increases the revision counter and dispatches a 'change' event.
+   * @api
+   */
+  changed() {
+    ++this.revision_;
+    this.dispatchEvent(EventType.CHANGE);
+  }
+
+  /**
+   * Get the version number for this object.  Each time the object is modified,
+   * its version number will be incremented.
+   * @return {number} Revision.
+   * @api
+   */
+  getRevision() {
+    return this.revision_;
+  }
+
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onInternal(type, listener) {
+    if (Array.isArray(type)) {
+      const len = type.length;
+      const keys = new Array(len);
+      for (let i = 0; i < len; ++i) {
+        keys[i] = listen(this, type[i], listener);
+      }
+      return keys;
+    } else {
+      return listen(this, /** @type {string} */ (type), listener);
+    }
+  }
+
+  /**
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Event key.
+   * @protected
+   */
+  onceInternal(type, listener) {
+    let key;
+    if (Array.isArray(type)) {
+      const len = type.length;
+      key = new Array(len);
+      for (let i = 0; i < len; ++i) {
+        key[i] = listenOnce(this, type[i], listener);
+      }
+    } else {
+      key = listenOnce(this, /** @type {string} */ (type), listener);
+    }
+    /** @type {Object} */ (listener).ol_key = key;
+    return key;
+  }
+
+  /**
+   * Unlisten for a certain type of event.
+   * @param {string|Array<string>} type Type.
+   * @param {function((Event|import("./events/Event").default)): ?} listener Listener.
+   * @protected
+   */
+  unInternal(type, listener) {
+    const key = /** @type {Object} */ (listener).ol_key;
+    if (key) {
+      unByKey(key);
+    } else if (Array.isArray(type)) {
+      for (let i = 0, ii = type.length; i < ii; ++i) {
+        this.removeEventListener(type[i], listener);
+      }
+    } else {
+      this.removeEventListener(type, listener);
+    }
+  }
+}
+
+/**
+ * Listen for a certain type of event.
+ * @function
+ * @param {string|Array<string>} type The event type or array of event types.
+ * @param {function((Event|import("./events/Event").default)): ?} listener The listener function.
+ * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Unique key for the listener. If
+ *     called with an array of event types as the first argument, the return
+ *     will be an array of keys.
+ * @api
+ */
+Observable.prototype.on;
+
+/**
+ * Listen once for a certain type of event.
+ * @function
+ * @param {string|Array<string>} type The event type or array of event types.
+ * @param {function((Event|import("./events/Event").default)): ?} listener The listener function.
+ * @return {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} Unique key for the listener. If
+ *     called with an array of event types as the first argument, the return
+ *     will be an array of keys.
+ * @api
+ */
+Observable.prototype.once;
+
+/**
+ * Unlisten for a certain type of event.
+ * @function
+ * @param {string|Array<string>} type The event type or array of event types.
+ * @param {function((Event|import("./events/Event").default)): ?} listener The listener function.
+ * @api
+ */
+Observable.prototype.un;
+
+/**
+ * Removes an event listener using the key returned by `on()` or `once()`.
+ * @param {import("./events.js").EventsKey|Array<import("./events.js").EventsKey>} key The key returned by `on()`
+ *     or `once()` (or an array of keys).
+ * @api
+ */
+export function unByKey(key) {
+  if (Array.isArray(key)) {
+    for (let i = 0, ii = key.length; i < ii; ++i) {
+      unlistenByKey(key[i]);
+    }
+  } else {
+    unlistenByKey(/** @type {import("./events.js").EventsKey} */ (key));
+  }
+}
+
+export default Observable;