@mapwhit/tilerenderer 0.47.1 → 0.48.0

package/src/util/polyfill.js

@@ -0,0 +1,16 @@
+/**
+ * Adds a static method `withResolvers` to the Promise object if it does not already exist.
+ *
+ * @see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+ */
+if (typeof Promise.withResolvers !== 'function') {
+  Promise.withResolvers = function () {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  };
+}

package/src/util/task_queue.js

@@ -1,57 +1,53 @@
 const assert = require('assert');
 
-// can't mark opaque due to https://github.com/flowtype/flow-remove-types/pull/61
-
-class TaskQueue {
-  constructor() {
-    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 });
+module.exports = taskQueue;
+
+function taskQueue(thisArg) {
+  const queues = {
+    running: [],
+    later: []
+  };
+  let id = Number.MIN_SAFE_INTEGER;
+  let cleared = false;
+
+  return {
+    add,
+    remove,
+    run,
+    clear
+  };
+
+  function add(fn) {
+    if (id === Number.MAX_SAFE_INTEGER) id = Number.MIN_SAFE_INTEGER;
+    id += 1;
+    queues.later.push({ fn, 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;
-      }
+  function remove(id) {
+    const task = queues.running.find(t => t.id === id) ?? queues.later.find(t => t.id === id);
+    if (task) {
+      task.cancelled = true;
     }
   }
 
-  run() {
-    assert(!this._currentlyRunning);
-    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();
-      if (this._cleared) break;
+  function run() {
+    assert(queues.running.length === 0);
+    queues.running = queues.later;
+    queues.later = [];
+    for (const { fn, cancelled } of queues.running) {
+      if (cancelled) continue;
+      fn.call(thisArg);
+      if (cleared) break;
     }
-
-    this._cleared = false;
-    this._currentlyRunning = false;
+    queues.running.length = 0;
+    cleared = false;
   }
 
-  clear() {
-    if (this._currentlyRunning) {
-      this._cleared = true;
+  function clear() {
+    if (queues.running.length > 0) {
+      cleared = true;
     }
-    this._queue = [];
+    queues.later.length = 0;
   }
 }
-
-module.exports = TaskQueue;

package/src/util/transfer_registry.js

@@ -0,0 +1,167 @@
+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);
+
+/**
+ * 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,5 +1,3 @@
-const assert = require('assert');
-
 const Grid = require('grid-index');
 const Color = require('../style-spec/util/color');
 const {
@@ -11,31 +9,11 @@ const {
 const CompoundExpression = require('../style-spec/expression/compound_expression');
 const expressions = require('../style-spec/expression/definitions');
 
-const registry = {};
-
-/**
- * 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, options = {}) {
-  assert(!registry[name], `${name} is already registered.`);
-  Object.defineProperty(klass, '_classRegistryKey', {
-    value: name,
-    writeable: false
-  });
-  registry[name] = {
-    klass,
-    omit: options.omit || [],
-    shallow: options.shallow || []
-  };
-}
-
-register('Object', Object);
+const { register, serialize, deserialize } = require('./transfer_registry');
+module.exports = {
+  serialize,
+  deserialize
+};
 
 Grid.serialize = function serializeGrid(grid, transferables) {
   const buffer = grid.toArrayBuffer();
@@ -63,166 +41,3 @@ for (const name in expressions) {
   if (expressions[name]._classRegistryKey) continue;
   register(`Expression_${name}`, expressions[name]);
 }
-
-/**
- * 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 (
-    input === null ||
-    input === undefined ||
-    typeof input === 'boolean' ||
-    typeof input === 'number' ||
-    typeof input === 'string' ||
-    input instanceof Boolean ||
-    input instanceof Number ||
-    input instanceof String ||
-    input instanceof Date ||
-    input instanceof RegExp
-  ) {
-    return input;
-  }
-
-  if (input instanceof ArrayBuffer) {
-    if (transferables) {
-      transferables.push(input);
-    }
-    return input;
-  }
-
-  if (ArrayBuffer.isView(input)) {
-    const view = input;
-    if (transferables) {
-      transferables.push(view.buffer);
-    }
-    return view;
-  }
-
-  if (input instanceof ImageData) {
-    if (transferables) {
-      transferables.push(input.data.buffer);
-    }
-    return input;
-  }
-
-  if (Array.isArray(input)) {
-    const serialized = [];
-    for (const item of input) {
-      serialized.push(serialize(item, transferables));
-    }
-    return serialized;
-  }
-
-  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[name]);
-
-    const properties = klass.serialize
-      ? // (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.
-        klass.serialize(input, transferables)
-      : {};
-
-    if (!klass.serialize) {
-      for (const key in input) {
-        // any cast due to https://github.com/facebook/flow/issues/5393
-        if (!input.hasOwnProperty(key)) continue;
-        if (registry[name].omit.indexOf(key) >= 0) continue;
-        const property = input[key];
-        properties[key] = registry[name].shallow.indexOf(key) >= 0 ? property : serialize(property, 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 (
-    input === null ||
-    input === undefined ||
-    typeof input === 'boolean' ||
-    typeof input === 'number' ||
-    typeof input === 'string' ||
-    input instanceof Boolean ||
-    input instanceof Number ||
-    input instanceof String ||
-    input instanceof Date ||
-    input instanceof RegExp ||
-    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 } = registry[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] = registry[name].shallow.indexOf(key) >= 0 ? value : deserialize(value);
-    }
-
-    return result;
-  }
-
-  throw new Error(`can't deserialize object of type ${typeof input}`);
-}
-
-module.exports = {
-  register,
-  serialize,
-  deserialize
-};

package/src/source/raster_dem_tile_worker_source.js

@@ -1,26 +0,0 @@
-const DEMData = require('../data/dem_data');
-
-class RasterDEMTileWorkerSource {
-  constructor() {
-    this.loaded = {};
-  }
-
-  loadTile(params, callback) {
-    const { uid, encoding, rawImageData } = params;
-    const dem = new DEMData(uid, rawImageData, encoding);
-
-    this.loaded = this.loaded || {};
-    this.loaded[uid] = dem;
-    callback(null, dem);
-  }
-
-  removeTile(params) {
-    const loaded = this.loaded;
-    const uid = params.uid;
-    if (loaded?.[uid]) {
-      delete loaded[uid];
-    }
-  }
-}
-
-module.exports = RasterDEMTileWorkerSource;

package/src/style-spec/expression/definitions/equals.js

@@ -1,93 +0,0 @@
-const { toString, ValueType, BooleanType, CollatorType } = require('../types');
-
-function isComparableType(type) {
-  return type.kind === 'string' || type.kind === 'number' || type.kind === 'boolean' || type.kind === 'null';
-}
-
-/**
- * Special form for ==, !=, implementing the following signatures:
- * - (T1: Comparable, T2: Comparable) => boolean { T1 == T2 }
- * - (Comparable, value) => boolean
- * - (value, Comparable) => boolean
- *
- * Where Comparable = string | number | boolean | null.
- *
- * Evaluation semantics for the value cases are equivalent to Javascript's
- * strict equality (===/!==) -- i.e., when the value argument's type doesn't
- * match that of the Comparable argument, == evaluates to false, != to true.
- *
- * @private
- */
-function makeComparison(op, negate) {
-  return class Comparison {
-    constructor(lhs, rhs, collator) {
-      this.type = BooleanType;
-      this.lhs = lhs;
-      this.rhs = rhs;
-      this.collator = collator;
-    }
-
-    static parse(args, context) {
-      if (args.length !== 3 && args.length !== 4) return context.error('Expected two or three arguments.');
-
-      const lhs = context.parse(args[1], 1, ValueType);
-      if (!lhs) return null;
-      const rhs = context.parse(args[2], 2, ValueType);
-      if (!rhs) return null;
-
-      if (!isComparableType(lhs.type) && !isComparableType(rhs.type)) {
-        return context.error(
-          `Expected at least one argument to be a string, number, boolean, or null, but found (${toString(lhs.type)}, ${toString(rhs.type)}) instead.`
-        );
-      }
-
-      if (lhs.type.kind !== rhs.type.kind && lhs.type.kind !== 'value' && rhs.type.kind !== 'value') {
-        return context.error(`Cannot compare ${toString(lhs.type)} and ${toString(rhs.type)}.`);
-      }
-
-      let collator = null;
-      if (args.length === 4) {
-        if (lhs.type.kind !== 'string' && rhs.type.kind !== 'string') {
-          return context.error('Cannot use collator to compare non-string types.');
-        }
-        collator = context.parse(args[3], 3, CollatorType);
-        if (!collator) return null;
-      }
-
-      return new Comparison(lhs, rhs, collator);
-    }
-
-    evaluate(ctx) {
-      const equal = this.collator
-        ? this.collator.evaluate(ctx).compare(this.lhs.evaluate(ctx), this.rhs.evaluate(ctx)) === 0
-        : this.lhs.evaluate(ctx) === this.rhs.evaluate(ctx);
-
-      return negate ? !equal : equal;
-    }
-
-    eachChild(fn) {
-      fn(this.lhs);
-      fn(this.rhs);
-      if (this.collator) {
-        fn(this.collator);
-      }
-    }
-
-    possibleOutputs() {
-      return [true, false];
-    }
-
-    serialize() {
-      const serialized = [op];
-      this.eachChild(child => {
-        serialized.push(child.serialize());
-      });
-      return serialized;
-    }
-  };
-}
-
-module.exports = {
-  Equals: makeComparison('==', false),
-  NotEquals: makeComparison('!=', true)
-};