@mapwhit/tilerenderer 0.47.1

package/src/util/actor.js

@@ -0,0 +1,104 @@
+const { serialize, deserialize } = require('./web_worker_transfer');
+
+module.exports = actor;
+
+/**
+ * An implementation of the [Actor design pattern](http://en.wikipedia.org/wiki/Actor_model)
+ * that maintains the relationship between asynchronous tasks and the objects
+ * that spin them off - in this case, tasks like parsing parts of styles,
+ * owned by the styles
+ *
+ * @param {WebWorker} target
+ * @param {WebWorker} parent
+ * @param {string|number} mapId A unique identifier for the Map instance using this Actor.
+ * @private
+ */
+
+function actor(target, parent, mapId, name) {
+  const callbacks = {};
+  let callbackID = 0;
+  target.addEventListener('message', receive, false);
+
+  function postMessage(targetMapId, id, type, data, err) {
+    const buffers = [];
+    const payload = {
+      targetMapId,
+      sourceMapId: mapId,
+      type,
+      id,
+      data: serialize(data, buffers)
+    };
+    if (err) {
+      payload.error = serialize(err);
+    }
+    target.postMessage(payload, buffers);
+  }
+
+  /**
+   * Sends a message from a main-thread map to a Worker or from a Worker back to
+   * a main-thread map instance.
+   *
+   * @param type The name of the target method to invoke or '[source-type].[source-name].name' for a method on a WorkerSource.
+   * @param targetMapId A particular mapId to which to send this message.
+   * @private
+   */
+  function send(type, data, callback, targetMapId) {
+    let id = 'null';
+    if (callback) {
+      id = `${mapId}:${callbackID++}`;
+      callbacks[id] = callback;
+    }
+    postMessage(targetMapId, id, type, data);
+  }
+
+  function receive(message) {
+    const { data } = message;
+    const { id, type, targetMapId } = data;
+
+    if (targetMapId && mapId !== targetMapId) return;
+
+    const done = (err, data) => postMessage(undefined, id, '<response>', data, err);
+
+    if (type === '<response>') {
+      const callback = callbacks[id];
+      delete callbacks[id];
+      if (callback) {
+        if (data.error) {
+          callback(deserialize(data.error));
+        } else {
+          callback(null, deserialize(data.data));
+        }
+      }
+      return;
+    }
+
+    if (typeof id !== 'undefined') {
+      if (parent[type]) {
+        // data.type == 'loadTile', 'removeTile', etc.
+        parent[type](data.sourceMapId, deserialize(data.data), done);
+        return;
+      }
+      if (parent.getWorkerSource) {
+        // data.type == sourcetype.method
+        const [sourcetype, method] = type.split('.');
+        const params = deserialize(data.data);
+        const workerSource = parent.getWorkerSource(data.sourceMapId, sourcetype, params.source);
+        workerSource[method](params, done);
+        return;
+      }
+    }
+
+    parent[type](deserialize(data.data));
+  }
+
+  function remove() {
+    target.removeEventListener('message', receive, false);
+  }
+
+  return {
+    send,
+    receive,
+    remove,
+    name
+  };
+}

package/src/util/async.js

@@ -0,0 +1,23 @@
+/*
+ * Call an asynchronous function on an array of arguments,
+ * calling `callback` with the completed results of all calls.
+ *
+ * @param array input to each call of the async function.
+ * @param fn an async function with signature (data, callback)
+ * @param callback a callback run after all async work is done.
+ * called with an array, containing the results of each async call.
+ * @private
+ */
+exports.all = function (array, fn, callback) {
+  if (!array.length) return callback(null, []);
+  let remaining = array.length;
+  const results = new Array(array.length);
+  let error = null;
+  array.forEach((item, i) => {
+    fn(item, (err, result) => {
+      if (err) error = err;
+      results[i] = result;
+      if (--remaining === 0) callback(error, results);
+    });
+  });
+};

package/src/util/browser.js

@@ -0,0 +1,61 @@
+// TODO move code that assumes that `window` may not be set to relevant tests
+
+const now =
+  typeof window === 'object' && window.performance?.now
+    ? window.performance.now.bind(window.performance)
+    : Date.now.bind(Date);
+
+const raf =
+  typeof window === 'object'
+    ? window.requestAnimationFrame ||
+      window.mozRequestAnimationFrame ||
+      window.webkitRequestAnimationFrame ||
+      window.msRequestAnimationFrame
+    : fn => setTimeout(fn, 0);
+
+const cancel =
+  typeof window === 'object'
+    ? window.cancelAnimationFrame ||
+      window.mozCancelAnimationFrame ||
+      window.webkitCancelAnimationFrame ||
+      window.msCancelAnimationFrame
+    : id => clearTimeout(id);
+
+/**
+ * @private
+ */
+const exported = {
+  /**
+   * Provides a function that outputs milliseconds: either performance.now()
+   * or a fallback to Date.now()
+   */
+  now,
+
+  frame(fn) {
+    return raf(fn);
+  },
+
+  cancelFrame(id) {
+    return cancel(id);
+  },
+
+  getImageData(img) {
+    const canvas = window.document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    if (!context) {
+      throw new Error('failed to create canvas 2d context');
+    }
+    canvas.width = img.width;
+    canvas.height = img.height;
+    context.drawImage(img, 0, 0, img.width, img.height);
+    return context.getImageData(0, 0, img.width, img.height);
+  },
+
+  hardwareConcurrency: typeof window === 'object' ? window.navigator.hardwareConcurrency : 4,
+
+  get devicePixelRatio() {
+    return typeof window === 'object' ? window.devicePixelRatio : 1;
+  }
+};
+
+module.exports = exported;

package/src/util/callback.js

@@ -0,0 +1,26 @@
+module.exports = {
+  callback,
+  callbackWithSpread,
+  callbackWithNoResult
+};
+
+function callback(fn, promise) {
+  if (fn) {
+    promise.then(result => fn(null, result), fn);
+  }
+  return promise;
+}
+
+function callbackWithSpread(fn, promise) {
+  if (fn) {
+    promise.then(result => fn(null, ...result), fn);
+  }
+  return promise;
+}
+
+function callbackWithNoResult(fn, promise) {
+  if (fn) {
+    promise.then(() => fn(null), fn);
+  }
+  return promise;
+}

package/src/util/classify_rings.js

@@ -0,0 +1,43 @@
+const quickselect = require('quickselect');
+
+const { calculateSignedArea } = require('./util');
+
+// classifies an array of rings into polygons with outer rings and holes
+module.exports = function classifyRings(rings, maxRings) {
+  if (rings.length <= 1) return [rings];
+
+  const polygons = [];
+  let polygon;
+  let ccw;
+
+  for (const ring of rings) {
+    const area = calculateSignedArea(ring);
+    if (area === 0) continue;
+
+    ring.area = Math.abs(area);
+
+    if (ccw === undefined) ccw = area < 0;
+
+    if (ccw === area < 0) {
+      append(polygon);
+      polygon = [ring];
+    } else {
+      polygon.push(ring);
+    }
+  }
+  append(polygon);
+  return polygons;
+
+  function append(polygon) {
+    if (!polygon) {
+      return;
+    }
+    // Earcut performance degrades with the # of rings in a polygon. For this
+    // reason, we limit strip out all but the `maxRings` largest rings.
+    if (maxRings > 1 && maxRings < polygon.length) {
+      quickselect(polygon, maxRings, 1, polygon.length - 1, (a, b) => b.area - a.area);
+      polygon.length = maxRings;
+    }
+    polygons.push(polygon);
+  }
+};

package/src/util/color_ramp.js

@@ -0,0 +1,24 @@
+const { RGBAImage } = require('./image');
+
+/**
+ * Given an expression that should evaluate to a color ramp, return
+ * a 256x1 px RGBA image representing that ramp expression.
+ *
+ * @private
+ */
+module.exports = function renderColorRamp(expression, colorRampEvaluationParameter) {
+  const colorRampData = new Uint8Array(256 * 4);
+  const evaluationGlobals = {};
+  for (let i = 0, j = 0; i < 256; i++, j += 4) {
+    evaluationGlobals[colorRampEvaluationParameter] = i / 255;
+    const pxColor = expression.evaluate(evaluationGlobals);
+    // the colors are being unpremultiplied because Color uses
+    // premultiplied values, and the Texture class expects unpremultiplied ones
+    colorRampData[j + 0] = Math.floor((pxColor.r * 255) / pxColor.a);
+    colorRampData[j + 1] = Math.floor((pxColor.g * 255) / pxColor.a);
+    colorRampData[j + 2] = Math.floor((pxColor.b * 255) / pxColor.a);
+    colorRampData[j + 3] = Math.floor(pxColor.a * 255);
+  }
+
+  return new RGBAImage({ width: 256, height: 1 }, colorRampData);
+};

package/src/util/config.js

@@ -0,0 +1,24 @@
+const { Evented } = require('./evented');
+
+function getDefaultWorkerCount() {
+  const browser = require('./browser');
+  return Math.max(Math.floor(browser.hardwareConcurrency / 2), 1);
+}
+
+const config = new Evented();
+
+config.set = function set(c) {
+  Object.assign(config, c);
+  config.notify();
+};
+
+config.notify = function () {
+  config.fire('change', config);
+};
+
+config.set({
+  WORKER_COUNT: getDefaultWorkerCount(),
+  WORKER_URL: ''
+});
+
+module.exports = config;

package/src/util/dictionary_coder.js

@@ -0,0 +1,25 @@
+const assert = require('assert');
+
+class DictionaryCoder {
+  constructor(strings) {
+    this._stringToNumber = {};
+    this._numberToString = [];
+    for (let i = 0; i < strings.length; i++) {
+      const string = strings[i];
+      this._stringToNumber[string] = i;
+      this._numberToString[i] = string;
+    }
+  }
+
+  encode(string) {
+    assert(string in this._stringToNumber);
+    return this._stringToNumber[string];
+  }
+
+  decode(n) {
+    assert(n < this._numberToString.length);
+    return this._numberToString[n];
+  }
+}
+
+module.exports = DictionaryCoder;

package/src/util/dispatcher.js

@@ -0,0 +1,68 @@
+const async = require('./async');
+const uniqueId = require('./unique_id');
+const actor = require('./actor');
+
+module.exports = dispatcher;
+
+const noop = () => {};
+
+/**
+ * Responsible for sending messages from a {@link Source} to an associated
+ * {@link WorkerSource}.
+ *
+ * @private
+ */
+function dispatcher(workerPool, parent, makeActor = actor) {
+  // exposed to allow stubbing in unit tests
+
+  let currentActor = 0;
+  const id = uniqueId();
+  const workers = workerPool.acquire(id);
+  const actors = workers.map((worker, i) => makeActor(worker, parent, id, `Worker ${i}`));
+
+  /**
+   * Broadcast a message to all Workers.
+   */
+  function broadcast(type, data, cb = noop) {
+    async.all(actors, (actor, done) => actor.send(type, data, done), cb);
+  }
+
+  // Use round robin to send requests to web workers.
+  function nextActorId() {
+    currentActor += 1;
+    if (currentActor === actors.length) {
+      currentActor = 0;
+    }
+    return currentActor;
+  }
+
+  /**
+   * Send a message to a Worker.
+   * @param targetID The ID of the Worker to which to send this message. Omit to allow the dispatcher to choose.
+   * @returns The ID of the worker to which the message was sent.
+   */
+  function send(type, data, callback, targetID) {
+    if (typeof targetID !== 'number' || isNaN(targetID)) {
+      targetID = nextActorId();
+    }
+
+    const actor = actors[targetID];
+    if (actor) {
+      actor.send(type, data, callback);
+    }
+    return targetID;
+  }
+
+  function remove() {
+    actors.forEach(actor => actor.remove());
+    actors.length = 0;
+    workerPool.release(id);
+  }
+
+  return {
+    id,
+    broadcast,
+    send,
+    remove
+  };
+}

package/src/util/dom.js

@@ -0,0 +1,102 @@
+const Point = require('@mapbox/point-geometry');
+
+const assert = require('assert');
+
+const DOM = {};
+module.exports = DOM;
+
+DOM.create = function (tagName, className, container) {
+  const el = window.document.createElement(tagName);
+  if (className) el.className = className;
+  if (container) container.appendChild(el);
+  return el;
+};
+
+DOM.createNS = function (namespaceURI, tagName) {
+  const el = window.document.createElementNS(namespaceURI, tagName);
+  return el;
+};
+
+let docStyle;
+let selectProp;
+
+DOM.initEnableDisableDrag = function () {
+  docStyle = window.document ? window.document.documentElement.style : null;
+
+  function testProp(props) {
+    if (!docStyle) return null;
+    for (let i = 0; i < props.length; i++) {
+      if (props[i] in docStyle) {
+        return props[i];
+      }
+    }
+    return props[0];
+  }
+
+  selectProp = testProp(['userSelect', 'MozUserSelect', 'WebkitUserSelect', 'msUserSelect']);
+};
+
+let userSelect;
+
+DOM.disableDrag = function () {
+  if (docStyle && selectProp) {
+    userSelect = docStyle[selectProp];
+    docStyle[selectProp] = 'none';
+  }
+};
+
+DOM.enableDrag = function () {
+  if (docStyle && selectProp) {
+    docStyle[selectProp] = userSelect;
+  }
+};
+
+// Suppress the next click, but only if it's immediate.
+const suppressClick = function (e) {
+  e.preventDefault();
+  e.stopPropagation();
+  window.removeEventListener('click', suppressClick, true);
+};
+
+DOM.suppressClick = function () {
+  window.addEventListener('click', suppressClick, true);
+  window.setTimeout(() => {
+    if (typeof window === 'object' && window) {
+      window.removeEventListener('click', suppressClick, true);
+    }
+  }, 0);
+};
+
+DOM.mousePos = function (el, e) {
+  const rect = el.getBoundingClientRect();
+  e = e.touches ? e.touches[0] : e;
+  return new Point(e.clientX - rect.left - el.clientLeft, e.clientY - rect.top - el.clientTop);
+};
+
+DOM.touchPos = function (el, e) {
+  const rect = el.getBoundingClientRect();
+  const points = [];
+  const touches = e.type === 'touchend' ? e.changedTouches : e.touches;
+  for (let i = 0; i < touches.length; i++) {
+    points.push(
+      new Point(touches[i].clientX - rect.left - el.clientLeft, touches[i].clientY - rect.top - el.clientTop)
+    );
+  }
+  return points;
+};
+
+DOM.mouseButton = function (e) {
+  assert(e.type === 'mousedown' || e.type === 'mouseup');
+  if (
+    typeof window.InstallTrigger !== 'undefined' &&
+    e.button === 2 &&
+    e.ctrlKey &&
+    window.navigator.platform.toUpperCase().indexOf('MAC') >= 0
+  ) {
+    // Fix for https://github.com/mapbox/mapbox-gl-js/issues/3131:
+    // Firefox (detected by InstallTrigger) on Mac determines e.button = 2 when
+    // using Control + left click
+    return 0;
+  }
+  return e.button;
+};

package/src/util/evented.js

@@ -0,0 +1,182 @@
+class Event {
+  constructor(type, data) {
+    Object.assign(this, data);
+    this.type = type;
+  }
+}
+
+class ErrorEvent extends Event {
+  constructor(error, data) {
+    super('error', Object.assign({ error }, data));
+  }
+}
+
+/**
+ * Methods mixed in to other classes for event capabilities.
+ *
+ * @mixin Evented
+ */
+class Evented {
+  #listeners;
+  #oneTimeListeners;
+  #parent;
+  #parentData;
+
+  /**
+   * Adds a listener to a specified event type.
+   *
+   * @param {string} type The event type to add a listen for.
+   * @param {Function} 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.
+   * @returns {Object} `this`
+   */
+  on(type, listener) {
+    this.#listeners ??= listeners();
+    this.#listeners.add(type, listener);
+
+    return this;
+  }
+
+  /**
+   * Removes a previously registered event listener.
+   *
+   * @param {string} type The event type to remove listeners for.
+   * @param {Function} listener The listener function to remove.
+   * @returns {Object} `this`
+   */
+  off(type, listener) {
+    this.#listeners?.remove(type, listener);
+    this.#oneTimeListeners?.remove(type, listener);
+
+    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 {string} type The event type to listen for.
+   * @param {Function} listener The function to be called when the event is fired the first time.
+   * @returns {Object} `this`
+   */
+  once(type, listener) {
+    this.#oneTimeListeners ??= listeners({ once: true });
+    this.#oneTimeListeners.add(type, listener);
+
+    return this;
+  }
+
+  fire(event) {
+    // 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, arguments[1]);
+    }
+
+    const { type } = event;
+
+    if (this.listens(type)) {
+      event.target = this;
+      this.#listeners?.fire(type, this, event);
+      this.#oneTimeListeners?.fire(type, this, event);
+
+      const parent = this.#parent;
+      if (parent) {
+        const data = typeof this.#parentData === 'function' ? this.#parentData() : this.#parentData;
+        Object.assign(event, data);
+        parent.fire(event);
+      }
+    } else if (event instanceof ErrorEvent) {
+      // To ensure that no error events are dropped, print them to the
+      // console if they have no listeners.
+      console.error(event.error);
+    }
+
+    return this;
+  }
+
+  /**
+   * Returns a true if this instance of Evented or any forwardeed instances of Evented have a listener for the specified type.
+   *
+   * @param {string} type The event type
+   * @returns {boolean} `true` if there is at least one registered listener for specified event type, `false` otherwise
+   */
+  listens(type) {
+    return this.#listeners?.listens(type) || this.#oneTimeListeners?.listens(type) || this.#parent?.listens(type);
+  }
+
+  /**
+   * Bubble all events fired by this instance of Evented to this parent instance of Evented.
+   *
+   * @returns {Object} `this`
+   */
+  setEventedParent(parent, data) {
+    this.#parent = parent;
+    this.#parentData = data;
+
+    return this;
+  }
+}
+
+module.exports = {
+  Event,
+  ErrorEvent,
+  Evented
+};
+
+function listeners({ once } = {}) {
+  const bag = new Map();
+
+  return {
+    add,
+    remove,
+    fire,
+    listens
+  };
+
+  function add(type, listener) {
+    const list = bag.get(type);
+    if (!list) {
+      bag.set(type, [listener]);
+    } else if (!list.includes(listener)) {
+      list.push(listener);
+    }
+  }
+
+  function remove(type, listener) {
+    const list = bag.get(type);
+    if (!list) {
+      return;
+    }
+    const index = list.indexOf(listener);
+    if (index !== -1) {
+      list.splice(index, 1);
+    }
+    if (list.length === 0) {
+      bag.delete(type);
+    }
+  }
+
+  function fire(type, thisArg, data) {
+    let list = bag.get(type);
+    if (!list || list.length === 0) {
+      return;
+    }
+    if (once) {
+      bag.delete(type);
+    } else {
+      // make sure adding or removing listeners inside other listeners won't cause an infinite loop
+      list = list.slice();
+    }
+    for (const listener of list) {
+      listener.call(thisArg, data);
+    }
+  }
+
+  function listens(type) {
+    return bag.get(type)?.length > 0;
+  }
+}