@antv/l7-map 2.21.11-beta.5 → 2.21.11-beta.6

package/lib/map/util/abort_error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An error message to use when an operation is aborted
+ */
+export declare const ABORT_ERROR = "AbortError";
+/**
+ * Check if an error is an abort error
+ * @param error - An error object
+ * @returns - true if the error is an abort error
+ */
+export declare function isAbortError(error: Error): boolean;
+/**
+ * Use this when you need to create an abort error.
+ * @returns An error object with the message "AbortError"
+ */
+export declare function createAbortError(): Error;

package/lib/map/util/abort_error.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ABORT_ERROR = void 0;
+exports.createAbortError = createAbortError;
+exports.isAbortError = isAbortError;
+/**
+ * An error message to use when an operation is aborted
+ */
+const ABORT_ERROR = exports.ABORT_ERROR = 'AbortError';
+
+/**
+ * Check if an error is an abort error
+ * @param error - An error object
+ * @returns - true if the error is an abort error
+ */
+function isAbortError(error) {
+  return error.message === ABORT_ERROR;
+}
+
+/**
+ * Use this when you need to create an abort error.
+ * @returns An error object with the message "AbortError"
+ */
+function createAbortError() {
+  return new Error(ABORT_ERROR);
+}

package/lib/map/util/browser.d.ts

@@ -0,0 +1,10 @@
+/** */
+export declare const browser: {
+    /**
+     * Provides a function that outputs milliseconds: either performance.now()
+     * or a fallback to Date.now()
+     */
+    now: any;
+    frameAsync(abortController: AbortController): Promise<number>;
+    readonly prefersReducedMotion: boolean;
+};

package/lib/map/util/browser.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.browser = void 0;
+var _abort_error = require("./abort_error");
+const now = typeof performance !== 'undefined' && performance && performance.now ? performance.now.bind(performance) : Date.now.bind(Date);
+let reducedMotionQuery;
+
+/** */
+const browser = exports.browser = {
+  /**
+   * Provides a function that outputs milliseconds: either performance.now()
+   * or a fallback to Date.now()
+   */
+  now,
+  frameAsync(abortController) {
+    return new Promise((resolve, reject) => {
+      const frame = requestAnimationFrame(resolve);
+      abortController.signal.addEventListener('abort', () => {
+        cancelAnimationFrame(frame);
+        reject((0, _abort_error.createAbortError)());
+      });
+    });
+  },
+  get prefersReducedMotion() {
+    // In case your test crashes when checking matchMedia, call setMatchMedia from 'src/util/test/util'
+    if (!window.matchMedia) return false;
+    //Lazily initialize media query
+    if (reducedMotionQuery == null) {
+      reducedMotionQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+    }
+    return reducedMotionQuery.matches;
+  }
+};

package/lib/map/util/dom.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="mapbox__point-geometry" />
+import Point from '@mapbox/point-geometry';
+export declare class DOM {
+    private static readonly docStyle;
+    private static userSelect;
+    private static selectProp;
+    private static transformProp;
+    private static testProp;
+    static create<K extends keyof HTMLElementTagNameMap>(tagName: K, className?: string, container?: HTMLElement): HTMLElementTagNameMap[K];
+    static createNS(namespaceURI: string, tagName: string): Element;
+    static disableDrag(): void;
+    static enableDrag(): void;
+    static setTransform(el: HTMLElement, value: string): void;
+    static addEventListener(target: HTMLElement | Window | Document, type: string, callback: EventListenerOrEventListenerObject, options?: {
+        passive?: boolean;
+        capture?: boolean;
+    }): void;
+    static removeEventListener(target: HTMLElement | Window | Document, type: string, callback: EventListenerOrEventListenerObject, options?: {
+        passive?: boolean;
+        capture?: boolean;
+    }): void;
+    private static suppressClickInternal;
+    static suppressClick(): void;
+    private static getScale;
+    private static getPoint;
+    static mousePos(el: HTMLElement, e: MouseEvent | Touch): Point;
+    static touchPos(el: HTMLElement, touches: TouchList): Point[];
+    static mouseButton(e: MouseEvent): number;
+    static remove(node: HTMLElement): void;
+}

package/lib/map/util/dom.js

@@ -0,0 +1,113 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DOM = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _pointGeometry = _interopRequireDefault(require("@mapbox/point-geometry"));
+var _class;
+class DOM {
+  static testProp(props) {
+    if (!DOM.docStyle) return props[0];
+    for (let i = 0; i < props.length; i++) {
+      if (props[i] in DOM.docStyle) {
+        return props[i];
+      }
+    }
+    return props[0];
+  }
+  static create(tagName, className, container) {
+    const el = window.document.createElement(tagName);
+    if (className !== undefined) el.className = className;
+    if (container) container.appendChild(el);
+    return el;
+  }
+  static createNS(namespaceURI, tagName) {
+    const el = window.document.createElementNS(namespaceURI, tagName);
+    return el;
+  }
+  static disableDrag() {
+    if (DOM.docStyle && DOM.selectProp) {
+      DOM.userSelect = DOM.docStyle[DOM.selectProp];
+      DOM.docStyle[DOM.selectProp] = 'none';
+    }
+  }
+  static enableDrag() {
+    if (DOM.docStyle && DOM.selectProp) {
+      DOM.docStyle[DOM.selectProp] = DOM.userSelect;
+    }
+  }
+  static setTransform(el, value) {
+    el.style[DOM.transformProp] = value;
+  }
+  static addEventListener(target, type, callback, options = {}) {
+    if ('passive' in options) {
+      target.addEventListener(type, callback, options);
+    } else {
+      target.addEventListener(type, callback, options.capture);
+    }
+  }
+  static removeEventListener(target, type, callback, options = {}) {
+    if ('passive' in options) {
+      target.removeEventListener(type, callback, options);
+    } else {
+      target.removeEventListener(type, callback, options.capture);
+    }
+  }
+
+  // Suppress the next click, but only if it's immediate.
+  static suppressClickInternal(e) {
+    e.preventDefault();
+    e.stopPropagation();
+    window.removeEventListener('click', DOM.suppressClickInternal, true);
+  }
+  static suppressClick() {
+    window.addEventListener('click', DOM.suppressClickInternal, true);
+    window.setTimeout(() => {
+      window.removeEventListener('click', DOM.suppressClickInternal, true);
+    }, 0);
+  }
+  static getScale(element) {
+    const rect = element.getBoundingClientRect();
+    return {
+      x: rect.width / element.offsetWidth || 1,
+      y: rect.height / element.offsetHeight || 1,
+      boundingClientRect: rect
+    };
+  }
+  static getPoint(el, scale, e) {
+    const rect = scale.boundingClientRect;
+    return new _pointGeometry.default(
+    // rect.left/top values are in page scale (like clientX/Y),
+    // whereas clientLeft/Top (border width) values are the original values (before CSS scale applies).
+    (e.clientX - rect.left) / scale.x - el.clientLeft, (e.clientY - rect.top) / scale.y - el.clientTop);
+  }
+  static mousePos(el, e) {
+    const scale = DOM.getScale(el);
+    return DOM.getPoint(el, scale, e);
+  }
+  static touchPos(el, touches) {
+    const points = [];
+    const scale = DOM.getScale(el);
+    for (let i = 0; i < touches.length; i++) {
+      points.push(DOM.getPoint(el, scale, touches[i]));
+    }
+    return points;
+  }
+  static mouseButton(e) {
+    return e.button;
+  }
+  static remove(node) {
+    if (node.parentNode) {
+      node.parentNode.removeChild(node);
+    }
+  }
+}
+exports.DOM = DOM;
+_class = DOM;
+(0, _defineProperty2.default)(DOM, "docStyle", typeof window !== 'undefined' && window.document && window.document.documentElement.style);
+(0, _defineProperty2.default)(DOM, "userSelect", void 0);
+(0, _defineProperty2.default)(DOM, "selectProp", _class.testProp(['userSelect', 'MozUserSelect', 'WebkitUserSelect', 'msUserSelect']));
+(0, _defineProperty2.default)(DOM, "transformProp", _class.testProp(['transform', 'WebkitTransform']));

package/lib/map/util/evented.d.ts

@@ -0,0 +1,75 @@
+/**
+ * A listener method used as a callback to events
+ */
+export type Listener = (a: any) => any;
+type Listeners = {
+    [_: string]: Array<Listener>;
+};
+/**
+ * The event class
+ */
+export declare class Event {
+    readonly type: string;
+    constructor(type: string, data?: any);
+}
+interface ErrorLike {
+    message: string;
+}
+/**
+ * An error event
+ */
+export declare class ErrorEvent extends Event {
+    error: ErrorLike;
+    constructor(error: ErrorLike, data?: any);
+}
+/**
+ * Methods mixed in to other classes for event capabilities.
+ *
+ * @group Event Related
+ */
+export declare class Evented {
+    _listeners: Listeners;
+    _oneTimeListeners: Listeners;
+    _eventedParent: Evented;
+    _eventedParentData: any | (() => any);
+    /**
+     * Adds a listener to a specified event type.
+     *
+     * @param type - The event type to add a listen for.
+     * @param listener - The function to be called when the event is fired.
+     * The listener function is called with the data object passed to `fire`,
+     * extended with `target` and `type` properties.
+     */
+    on(type: string, listener: Listener): this;
+    /**
+     * Removes a previously registered event listener.
+     *
+     * @param type - The event type to remove listeners for.
+     * @param listener - The listener function to remove.
+     */
+    off(type: string, listener: Listener): this;
+    /**
+     * Adds a listener that will be called only once to a specified event type.
+     *
+     * The listener will be called first time the event fires after the listener is registered.
+     *
+     * @param type - The event type to listen for.
+     * @param listener - The function to be called when the event is fired the first time.
+     * @returns `this` or a promise if a listener is not provided
+     */
+    once(type: string, listener?: Listener): this | Promise<any>;
+    fire(event: Event | string, properties?: any): this;
+    emit(event: Event | string, properties?: any): this;
+    /**
+     * Returns a true if this instance of Evented or any forwardeed instances of Evented have a listener for the specified type.
+     *
+     * @param type - The event type
+     * @returns `true` if there is at least one registered listener for specified event type, `false` otherwise
+     */
+    listens(type: string): boolean;
+    /**
+     * Bubble all events fired by this instance of Evented to this parent instance of Evented.
+     */
+    setEventedParent(parent?: Evented | null, data?: any | (() => any)): this;
+}
+export {};

package/lib/map/util/evented.js

@@ -0,0 +1,167 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Evented = exports.Event = exports.ErrorEvent = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _util = require("./util");
+/**
+ * A listener method used as a callback to events
+ */
+
+function _addEventListener(type, listener, listenerList) {
+  const listenerExists = listenerList[type] && listenerList[type].indexOf(listener) !== -1;
+  if (!listenerExists) {
+    listenerList[type] = listenerList[type] || [];
+    listenerList[type].push(listener);
+  }
+}
+function _removeEventListener(type, listener, listenerList) {
+  if (listenerList && listenerList[type]) {
+    const index = listenerList[type].indexOf(listener);
+    if (index !== -1) {
+      listenerList[type].splice(index, 1);
+    }
+  }
+}
+
+/**
+ * The event class
+ */
+class Event {
+  constructor(type, data = {}) {
+    (0, _defineProperty2.default)(this, "type", void 0);
+    (0, _util.extend)(this, data);
+    this.type = type;
+  }
+}
+exports.Event = Event;
+/**
+ * An error event
+ */
+class ErrorEvent extends Event {
+  constructor(error, data = {}) {
+    super('error', data);
+    (0, _defineProperty2.default)(this, "error", void 0);
+    this.error = error;
+  }
+}
+
+/**
+ * Methods mixed in to other classes for event capabilities.
+ *
+ * @group Event Related
+ */
+exports.ErrorEvent = ErrorEvent;
+class Evented {
+  constructor() {
+    (0, _defineProperty2.default)(this, "_listeners", void 0);
+    (0, _defineProperty2.default)(this, "_oneTimeListeners", void 0);
+    (0, _defineProperty2.default)(this, "_eventedParent", void 0);
+    (0, _defineProperty2.default)(this, "_eventedParentData", void 0);
+  }
+  /**
+   * Adds a listener to a specified event type.
+   *
+   * @param type - The event type to add a listen for.
+   * @param listener - The function to be called when the event is fired.
+   * The listener function is called with the data object passed to `fire`,
+   * extended with `target` and `type` properties.
+   */
+  on(type, listener) {
+    this._listeners = this._listeners || {};
+    _addEventListener(type, listener, this._listeners);
+    return this;
+  }
+
+  /**
+   * Removes a previously registered event listener.
+   *
+   * @param type - The event type to remove listeners for.
+   * @param listener - The listener function to remove.
+   */
+  off(type, listener) {
+    _removeEventListener(type, listener, this._listeners);
+    _removeEventListener(type, listener, this._oneTimeListeners);
+    return this;
+  }
+
+  /**
+   * Adds a listener that will be called only once to a specified event type.
+   *
+   * The listener will be called first time the event fires after the listener is registered.
+   *
+   * @param type - The event type to listen for.
+   * @param listener - The function to be called when the event is fired the first time.
+   * @returns `this` or a promise if a listener is not provided
+   */
+  once(type, listener) {
+    if (!listener) {
+      return new Promise(resolve => this.once(type, resolve));
+    }
+    this._oneTimeListeners = this._oneTimeListeners || {};
+    _addEventListener(type, listener, this._oneTimeListeners);
+    return this;
+  }
+  fire(event, properties) {
+    // Compatibility with (type: string, properties: Object) signature from previous versions.
+    // See https://github.com/mapbox/mapbox-gl-js/issues/6522,
+    //     https://github.com/mapbox/mapbox-gl-draw/issues/766
+    if (typeof event === 'string') {
+      event = new Event(event, properties || {});
+    }
+    const type = event.type;
+    if (this.listens(type)) {
+      event.target = this;
+
+      // make sure adding or removing listeners inside other listeners won't cause an infinite loop
+      const listeners = this._listeners && this._listeners[type] ? this._listeners[type].slice() : [];
+      for (const listener of listeners) {
+        listener.call(this, event);
+      }
+      const oneTimeListeners = this._oneTimeListeners && this._oneTimeListeners[type] ? this._oneTimeListeners[type].slice() : [];
+      for (const listener of oneTimeListeners) {
+        _removeEventListener(type, listener, this._oneTimeListeners);
+        listener.call(this, event);
+      }
+      const parent = this._eventedParent;
+      if (parent) {
+        (0, _util.extend)(event, typeof this._eventedParentData === 'function' ? this._eventedParentData() : this._eventedParentData);
+        parent.fire(event);
+      }
+
+      // To ensure that no error events are dropped, print them to the
+      // console if they have no listeners.
+    } else if (event instanceof ErrorEvent) {
+      console.error(event.error);
+    }
+    return this;
+  }
+  emit(event, properties) {
+    return this.fire(event, properties);
+  }
+
+  /**
+   * Returns a true if this instance of Evented or any forwardeed instances of Evented have a listener for the specified type.
+   *
+   * @param type - The event type
+   * @returns `true` if there is at least one registered listener for specified event type, `false` otherwise
+   */
+  listens(type) {
+    return this._listeners && this._listeners[type] && this._listeners[type].length > 0 || this._oneTimeListeners && this._oneTimeListeners[type] && this._oneTimeListeners[type].length > 0 || this._eventedParent && this._eventedParent.listens(type);
+  }
+
+  /**
+   * Bubble all events fired by this instance of Evented to this parent instance of Evented.
+   */
+  setEventedParent(parent, data) {
+    if (parent) {
+      this._eventedParent = parent;
+    }
+    this._eventedParentData = data;
+    return this;
+  }
+}
+exports.Evented = Evented;

package/lib/map/util/task_queue.d.ts

@@ -0,0 +1,18 @@
+export type TaskID = number;
+type Task = {
+    callback: (timeStamp: number) => void;
+    id: TaskID;
+    cancelled: boolean;
+};
+export declare class TaskQueue {
+    _queue: Array<Task>;
+    _id: TaskID;
+    _cleared: boolean;
+    _currentlyRunning: Array<Task> | false;
+    constructor();
+    add(callback: (timeStamp: number) => void): TaskID;
+    remove(id: TaskID): void;
+    run(timeStamp?: number): void;
+    clear(): void;
+}
+export {};

package/lib/map/util/task_queue.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TaskQueue = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+class TaskQueue {
+  constructor() {
+    (0, _defineProperty2.default)(this, "_queue", void 0);
+    (0, _defineProperty2.default)(this, "_id", void 0);
+    (0, _defineProperty2.default)(this, "_cleared", void 0);
+    (0, _defineProperty2.default)(this, "_currentlyRunning", void 0);
+    this._queue = [];
+    this._id = 0;
+    this._cleared = false;
+    this._currentlyRunning = false;
+  }
+  add(callback) {
+    const id = ++this._id;
+    const queue = this._queue;
+    queue.push({
+      callback,
+      id,
+      cancelled: false
+    });
+    return id;
+  }
+  remove(id) {
+    const running = this._currentlyRunning;
+    const queue = running ? this._queue.concat(running) : this._queue;
+    for (const task of queue) {
+      if (task.id === id) {
+        task.cancelled = true;
+        return;
+      }
+    }
+  }
+  run(timeStamp = 0) {
+    if (this._currentlyRunning) throw new Error('Attempting to run(), but is already running.');
+    const queue = this._currentlyRunning = this._queue;
+
+    // Tasks queued by callbacks in the current queue should be executed
+    // on the next run, not the current run.
+    this._queue = [];
+    for (const task of queue) {
+      if (task.cancelled) continue;
+      task.callback(timeStamp);
+      if (this._cleared) break;
+    }
+    this._cleared = false;
+    this._currentlyRunning = false;
+  }
+  clear() {
+    if (this._currentlyRunning) {
+      this._cleared = true;
+    }
+    this._queue = [];
+  }
+}
+exports.TaskQueue = TaskQueue;

package/lib/map/util/util.d.ts

@@ -0,0 +1,104 @@
+export declare const interpolates: {
+    number: (from: number, to: number, t: number) => number;
+};
+/**
+ * constrain n to the given range via min + max
+ *
+ * @param n - value
+ * @param min - the minimum value to be returned
+ * @param max - the maximum value to be returned
+ * @returns the clamped value
+ */
+export declare function clamp(n: number, min: number, max: number): number;
+/**
+ * constrain n to the given range, excluding the minimum, via modular arithmetic
+ *
+ * @param n - value
+ * @param min - the minimum value to be returned, exclusive
+ * @param max - the maximum value to be returned, inclusive
+ * @returns constrained number
+ */
+export declare function wrap(n: number, min: number, max: number): number;
+/**
+ * Return a unique numeric id, starting at 1 and incrementing with
+ * each call.
+ *
+ * @returns unique numeric id.
+ */
+export declare function uniqueId(): number;
+/**
+ * Given a destination object and optionally many source objects,
+ * copy all properties from the source objects into the destination.
+ * The last source object given overrides properties from previous
+ * source objects.
+ *
+ * @param dest - destination object
+ * @param sources - sources from which properties are pulled
+ */
+export declare function extend<T extends {}, U>(dest: T, source: U): T & U;
+export declare function extend<T extends {}, U, V>(dest: T, source1: U, source2: V): T & U & V;
+export declare function extend<T extends {}, U, V, W>(dest: T, source1: U, source2: V, source3: W): T & U & V & W;
+export declare function extend(dest: Record<string, any>, ...sources: Array<any>): any;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+/**
+ * Given an object and a number of properties as strings, return version
+ * of that object with only those properties.
+ *
+ * @param src - the object
+ * @param properties - an array of property names chosen
+ * to appear on the resulting object.
+ * @returns object with limited properties.
+ * @example
+ * ```ts
+ * let foo = { name: 'Charlie', age: 10 };
+ * let justName = pick(foo, ['name']); // justName = { name: 'Charlie' }
+ * ```
+ */
+export declare function pick<T extends object>(src: T, properties: Array<KeysOfUnion<T>>): Partial<T>;
+/**
+ * Makes optional keys required and add the the undefined type.
+ *
+ * ```
+ * interface Test {
+ *  foo: number;
+ *  bar?: number;
+ *  baz: number | undefined;
+ * }
+ *
+ * Complete<Test> {
+ *  foo: number;
+ *  bar: number | undefined;
+ *  baz: number | undefined;
+ * }
+ *
+ * ```
+ *
+ * See https://medium.com/terria/typescript-transforming-optional-properties-to-required-properties-that-may-be-undefined-7482cb4e1585
+ */
+export type Complete<T> = {
+    [P in keyof Required<T>]: Pick<T, P> extends Required<Pick<T, P>> ? T[P] : T[P] | undefined;
+};
+/**
+ * Given given (x, y), (x1, y1) control points for a bezier curve,
+ * return a function that interpolates along that curve.
+ *
+ * @param p1x - control point 1 x coordinate
+ * @param p1y - control point 1 y coordinate
+ * @param p2x - control point 2 x coordinate
+ * @param p2y - control point 2 y coordinate
+ */
+export declare function bezier(p1x: number, p1y: number, p2x: number, p2y: number): (t: number) => number;
+/**
+ * A default bezier-curve powered easing function with
+ * control points (0.25, 0.1) and (0.25, 1)
+ */
+export declare const defaultEasing: (t: number) => number;
+export declare function warnOnce(message: string): void;
+/**
+ * This method converts degrees to radians.
+ * The return value is the radian value.
+ * @param degrees - The number of degrees
+ * @returns radians
+ */
+export declare function degreesToRadians(degrees: number): number;
+export {};