@antv/l7-map 2.25.7 → 2.25.10

package/es/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/es/map/util/abort_error.js

@@ -0,0 +1,21 @@
+/**
+ * An error message to use when an operation is aborted
+ */
+export 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 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"
+ */
+export function createAbortError() {
+  return new Error(ABORT_ERROR);
+}

package/es/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/es/map/util/browser.js

@@ -0,0 +1,30 @@
+import { createAbortError } from "./abort_error";
+const now = typeof performance !== 'undefined' && performance && performance.now ? performance.now.bind(performance) : Date.now.bind(Date);
+let reducedMotionQuery;
+
+/** */
+export const 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(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/es/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/es/map/util/dom.js

@@ -0,0 +1,105 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _class;
+import Point from '@mapbox/point-geometry';
+export 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 Point(
+    // 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);
+    }
+  }
+}
+_class = DOM;
+_defineProperty(DOM, "docStyle", typeof window !== 'undefined' && window.document && window.document.documentElement.style);
+_defineProperty(DOM, "userSelect", void 0);
+_defineProperty(DOM, "selectProp", _class.testProp(['userSelect', 'MozUserSelect', 'WebkitUserSelect', 'msUserSelect']));
+_defineProperty(DOM, "transformProp", _class.testProp(['transform', 'WebkitTransform']));

package/es/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/es/map/util/evented.js

@@ -0,0 +1,158 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { extend } from "./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
+ */
+export class Event {
+  constructor(type, data = {}) {
+    _defineProperty(this, "type", void 0);
+    extend(this, data);
+    this.type = type;
+  }
+}
+/**
+ * An error event
+ */
+export class ErrorEvent extends Event {
+  constructor(error, data = {}) {
+    super('error', data);
+    _defineProperty(this, "error", void 0);
+    this.error = error;
+  }
+}
+
+/**
+ * Methods mixed in to other classes for event capabilities.
+ *
+ * @group Event Related
+ */
+export class Evented {
+  constructor() {
+    _defineProperty(this, "_listeners", void 0);
+    _defineProperty(this, "_oneTimeListeners", void 0);
+    _defineProperty(this, "_eventedParent", void 0);
+    _defineProperty(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) {
+        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;
+  }
+}

package/es/map/util/simpleMapCoord.d.ts

@@ -0,0 +1,31 @@
+export interface ISimpleMapCoord {
+    setSize(size: number): void;
+    getSize(): [number, number];
+    project(lnglat: [number, number]): [number, number];
+    unproject(xy: [number, number]): [number, number];
+}
+export declare class SimpleMapCoord implements ISimpleMapCoord {
+    private size;
+    constructor(size?: number);
+    setSize(size: number): void;
+    getSize(): [number, number];
+    /**
+     * coord
+     * ^ y (y > 0)
+     * |
+     * |
+     * |
+     * |(x = 0, y = 0)
+     * ---------------> x (x > 0)
+     */
+    /***
+     * lng: [-180, 180] 360
+     * lat: [-85.05112877980659, 85.05112877980659] 170.10225755961318
+     */
+    mercatorXfromLng(lng: number): number;
+    mercatorYfromLat(lat: number): number;
+    lngFromMercatorX(x: number): number;
+    latFromMercatorY(y: number): number;
+    project(lnglat: [number, number]): [number, number];
+    unproject(xy: [number, number]): [number, number];
+}

package/es/map/util/simpleMapCoord.js

@@ -0,0 +1,54 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export class SimpleMapCoord {
+  constructor(size) {
+    _defineProperty(this, "size", 10000);
+    this.size = size ? size : 10000;
+  }
+  setSize(size) {
+    this.size = size;
+  }
+  getSize() {
+    return [this.size, this.size];
+  }
+
+  /**
+   * coord
+   * ^ y (y > 0)
+   * |
+   * |
+   * |
+   * |(x = 0, y = 0)
+   * ---------------> x (x > 0)
+   */
+
+  /***
+   * lng: [-180, 180] 360
+   * lat: [-85.05112877980659, 85.05112877980659] 170.10225755961318
+   */
+
+  mercatorXfromLng(lng) {
+    // (0 - 1) * this.size
+    return (180 + lng) / 360 * this.size;
+  }
+  mercatorYfromLat(lat) {
+    // (0 - 1) * this.size
+    return (1 - (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 360))) / 360) * this.size;
+  }
+  lngFromMercatorX(x) {
+    return x / this.size * 360 - 180;
+  }
+  latFromMercatorY(y) {
+    const y2 = 180 - (1 - y / this.size) * 360;
+    return 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+  project(lnglat) {
+    const x = this.mercatorXfromLng(lnglat[0]);
+    const y = this.mercatorYfromLat(lnglat[1]);
+    return [x, y];
+  }
+  unproject(xy) {
+    const lng = this.lngFromMercatorX(xy[0]);
+    const lat = this.latFromMercatorY(xy[1]);
+    return [lng, lat];
+  }
+}

package/es/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/es/map/util/task_queue.js

@@ -0,0 +1,54 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+export class TaskQueue {
+  constructor() {
+    _defineProperty(this, "_queue", void 0);
+    _defineProperty(this, "_id", void 0);
+    _defineProperty(this, "_cleared", void 0);
+    _defineProperty(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 = [];
+  }
+}