@mapwhit/tilerenderer 0.52.0 → 1.0.0

package/src/style-spec/group_by_layout.js

@@ -1,46 +0,0 @@
-const refProperties = require('./util/ref_properties');
-
-function stringify(obj) {
-  if (obj == null) return 'null';
-  const type = typeof obj;
-  if (type === 'number' || type === 'boolean' || type === 'string') return obj;
-
-  if (Array.isArray(obj)) {
-    return '[' + obj.map(val => stringify(val)).join(',') + ']';
-  }
-
-  const keys = Object.keys(obj).sort();
-  return '{' + keys.map(key => `${key}:${stringify(obj[key])}`).join(',') + '}';
-}
-
-function getKey(layer) {
-  return refProperties.map(k => stringify(layer[k])).join('/');
-}
-
-module.exports = groupByLayout;
-
-/**
- * Given an array of layers, return an array of arrays of layers where all
- * layers in each group have identical layout-affecting properties. These
- * are the properties that were formerly used by explicit `ref` mechanism
- * for layers: 'type', 'source', 'source-layer', 'minzoom', 'maxzoom',
- * 'filter', and 'layout'.
- *
- * The input is not modified. The output layers are references to the
- * input layers.
- *
- * @private
- * @param {Array<Layer>} layers
- * @returns {Array<Array<Layer>>}
- */
-function groupByLayout(layers) {
-  const groups = {};
-
-  for (const l of layers) {
-    const k = getKey(l);
-    const group = (groups[k] ??= []);
-    group.push(l);
-  }
-
-  return Object.values(groups);
-}

package/src/util/actor.js

@@ -1,108 +0,0 @@
-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 promises = new Map();
-  let callbackID = Number.MIN_SAFE_INTEGER;
-  target.addEventListener('message', receive, false);
-
-  return {
-    send,
-    receive,
-    remove,
-    name
-  };
-
-  /**
-   * 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, targetMapId) {
-    const id = `${mapId}:${callbackID++}`;
-    const p = Promise.withResolvers();
-    promises.set(id, p);
-    postMessage(targetMapId, id, type, data);
-    return p.promise;
-  }
-
-  async function receive(message) {
-    const { data } = message;
-    const { id, type, targetMapId } = data;
-
-    if (targetMapId && mapId !== targetMapId) return;
-
-    if (type === '<response>') {
-      const p = promises.get(id);
-      if (p) {
-        promises.delete(id);
-        if (data.error) {
-          p.reject(deserialize(data.error));
-        } else {
-          p.resolve(deserialize(data.data));
-        }
-      }
-      return;
-    }
-
-    if (typeof id !== 'undefined') {
-      let perform;
-      if (parent[type]) {
-        // data.type == 'loadTile' etc.
-        perform = () => parent[type](data.sourceMapId, deserialize(data.data));
-      } else 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);
-        perform = () => workerSource[method](params);
-      } else {
-        return;
-      }
-      try {
-        const result = await perform();
-        postMessage(data.sourceMapId, id, '<response>', result);
-      } catch (err) {
-        postMessage(data.sourceMapId, id, '<response>', undefined, err);
-      }
-      return;
-    }
-
-    parent[type](deserialize(data.data));
-  }
-
-  function remove() {
-    target.removeEventListener('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);
-  }
-}

package/src/util/dispatcher.js

@@ -1,65 +0,0 @@
-const uniqueId = require('./unique_id');
-const actor = require('./actor');
-
-module.exports = dispatcher;
-
-/**
- * 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 = -1;
-  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) {
-    const tasks = actors.map(actor => actor.send(type, data));
-    return Promise.all(tasks);
-  }
-
-  // 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, targetID = nextActorId()) {
-    return actors[targetID]?.send(type, data) ?? Promise.resolve();
-  }
-
-  function remove() {
-    actors.forEach(actor => actor.remove());
-    actors.length = 0;
-    workerPool.release(id);
-  }
-
-  function nextWorkerId(workerId = nextActorId()) {
-    return workerId;
-  }
-
-  return {
-    get id() {
-      return id;
-    },
-    broadcast,
-    send,
-    nextWorkerId,
-    remove
-  };
-}

package/src/util/global_worker_pool.js

@@ -1,15 +0,0 @@
-const workerPool = require('./worker_pool');
-
-let globalWorkerPool;
-
-/**
- * Creates (if necessary) and returns the single, global WorkerPool instance
- * to be shared across each Map
- * @private
- */
-module.exports = function getGlobalWorkerPool() {
-  if (!globalWorkerPool) {
-    globalWorkerPool = workerPool();
-  }
-  return globalWorkerPool;
-};

package/src/util/transfer_registry.js

@@ -1,168 +0,0 @@
-const assert = require('assert');
-
-module.exports = {
-  register,
-  serialize,
-  deserialize
-};
-
-const registry = new Map();
-
-/**
- * Register the given class as serializable.
- *
- * @param options
- * @param options.omit List of properties to omit from serialization (e.g., cached/computed properties)
- * @param options.shallow List of properties that should be serialized by a simple shallow copy, rather than by a recursive call to serialize().
- *
- * @private
- */
-function register(name, klass, { omit, shallow } = {}) {
-  assert(!registry.has(name), `${name} is already registered.`);
-  Object.defineProperty(klass, '_classRegistryKey', {
-    value: name,
-    writeable: false
-  });
-  registry.set(name, { klass, omit, shallow });
-}
-
-register('Object', Object);
-register('Set', Set);
-
-/**
- * Serialize the given object for transfer to or from a web worker.
- *
- * For non-builtin types, recursively serialize each property (possibly
- * omitting certain properties - see register()), and package the result along
- * with the constructor's `name` so that the appropriate constructor can be
- * looked up in `deserialize()`.
- *
- * If a `transferables` array is provided, add any transferable objects (i.e.,
- * any ArrayBuffers or ArrayBuffer views) to the list. (If a copy is needed,
- * this should happen in the client code, before using serialize().)
- *
- * @private
- */
-function serialize(input, transferables) {
-  if (isSerializablePrimitive(input)) {
-    return input;
-  }
-
-  if (input instanceof ArrayBuffer) {
-    transferables?.push(input);
-    return input;
-  }
-
-  if (ArrayBuffer.isView(input)) {
-    transferables?.push(input.buffer);
-    return input;
-  }
-
-  if (input instanceof ImageData) {
-    transferables?.push(input.data.buffer);
-    return input;
-  }
-
-  if (Array.isArray(input)) {
-    return input.map(item => serialize(item, transferables));
-  }
-
-  if (typeof input === 'object') {
-    const klass = input.constructor;
-    const name = klass._classRegistryKey;
-    if (!name) {
-      throw new Error(`can't serialize object of unregistered class`);
-    }
-    assert(registry.has(name));
-
-    // (Temporary workaround) allow a class to provide static
-    // `serialize()` and `deserialize()` methods to bypass the generic
-    // approach.
-    // This temporary workaround lets us use the generic serialization
-    // approach for objects whose members include instances of dynamic
-    // StructArray types. Once we refactor StructArray to be static,
-    // we can remove this complexity.
-    const properties = klass.serialize ? klass.serialize(input, transferables) : {};
-
-    if (!klass.serialize) {
-      const { omit, shallow } = registry.get(name);
-      for (const key in input) {
-        if (!Object.hasOwn(input, key)) continue;
-        if (omit?.includes(key)) continue;
-        const value = input[key];
-        properties[key] = shallow?.includes(key) ? value : serialize(value, transferables);
-      }
-      if (input instanceof Error) {
-        properties.message = input.message;
-      }
-    } else {
-      // make sure statically serialized object survives transfer of $name property
-      assert(!transferables || properties !== transferables[transferables.length - 1]);
-    }
-
-    if (properties.$name) {
-      throw new Error('$name property is reserved for worker serialization logic.');
-    }
-    if (name !== 'Object') {
-      properties.$name = name;
-    }
-
-    return properties;
-  }
-
-  throw new Error(`can't serialize object of type ${typeof input}`);
-}
-
-function deserialize(input) {
-  if (
-    isSerializablePrimitive(input) ||
-    input instanceof ArrayBuffer ||
-    ArrayBuffer.isView(input) ||
-    input instanceof ImageData
-  ) {
-    return input;
-  }
-
-  if (Array.isArray(input)) {
-    return input.map(deserialize);
-  }
-
-  if (typeof input === 'object') {
-    const name = input.$name ?? 'Object';
-
-    const { klass, shallow } = registry.get(name);
-    if (!klass) {
-      throw new Error(`can't deserialize unregistered class ${name}`);
-    }
-
-    if (klass.deserialize) {
-      return klass.deserialize(input);
-    }
-
-    const result = Object.create(klass.prototype);
-
-    for (const key of Object.keys(input)) {
-      if (key === '$name') continue;
-      const value = input[key];
-      result[key] = shallow?.includes(key) ? value : deserialize(value);
-    }
-
-    return result;
-  }
-
-  throw new Error(`can't deserialize object of type ${typeof input}`);
-}
-
-function isSerializablePrimitive(input) {
-  return (
-    input == null ||
-    typeof input === 'boolean' ||
-    typeof input === 'number' ||
-    typeof input === 'string' ||
-    input instanceof Date ||
-    input instanceof RegExp ||
-    input instanceof Boolean ||
-    input instanceof Number ||
-    input instanceof String
-  );
-}

package/src/util/web_worker_transfer.js

@@ -1,43 +0,0 @@
-const Grid = require('grid-index');
-const { Color } = require('@mapwhit/style-expressions');
-const {
-  CompoundExpression,
-  definitions: expressions,
-  StylePropertyFunction,
-  StyleExpression,
-  ZoomDependentExpression,
-  ZoomConstantExpression
-} = require('@mapwhit/style-expressions');
-
-const { register, serialize, deserialize } = require('./transfer_registry');
-module.exports = {
-  serialize,
-  deserialize
-};
-
-Grid.serialize = function serializeGrid(grid, transferables) {
-  const buffer = grid.toArrayBuffer();
-  if (transferables) {
-    transferables.push(buffer);
-  }
-  return { buffer };
-};
-
-Grid.deserialize = function deserializeGrid(serialized) {
-  return new Grid(serialized.buffer);
-};
-register('Grid', Grid);
-
-register('Color', Color);
-register('Error', Error);
-
-register('StylePropertyFunction', StylePropertyFunction);
-register('StyleExpression', StyleExpression, { omit: ['_evaluator'] });
-
-register('ZoomDependentExpression', ZoomDependentExpression);
-register('ZoomConstantExpression', ZoomConstantExpression);
-register('CompoundExpression', CompoundExpression, { omit: ['_evaluate'] });
-for (const name in expressions) {
-  if (expressions[name]._classRegistryKey) continue;
-  register(`Expression_${name}`, expressions[name]);
-}

package/src/util/worker_pool.js

@@ -1,41 +0,0 @@
-const assert = require('assert');
-const WebWorker = require('./web_worker');
-const config = require('./config');
-
-module.exports = workerPool;
-
-/**
- * Constructs a worker pool.
- * @private
- */
-function workerPool(workerCount = config.WORKER_COUNT) {
-  const active = {};
-  let workers;
-
-  function acquire(mapId) {
-    if (!workers) {
-      assert(typeof workerCount === 'number' && workerCount < Number.POSITIVE_INFINITY);
-
-      workers = new Array(workerCount);
-      for (let i = 0; i < workerCount; i++) {
-        workers[i] = new WebWorker();
-      }
-    }
-
-    active[mapId] = true;
-    return workers.slice();
-  }
-
-  function release(mapId) {
-    delete active[mapId];
-    if (Object.keys(active).length === 0) {
-      workers.forEach(w => w.terminate());
-      workers = undefined;
-    }
-  }
-
-  return {
-    acquire,
-    release
-  };
-}