@mapwhit/tilerenderer 0.47.1

package/src/style/style_layer.js

@@ -0,0 +1,183 @@
+const { filterObject } = require('../util/object');
+
+const { Evented } = require('../util/evented');
+const { Layout, Transitionable, PossiblyEvaluatedPropertyValue } = require('./properties');
+const { supportsPropertyExpression } = require('../style-spec/util/properties');
+
+const TRANSITION_SUFFIX = '-transition';
+
+class StyleLayer extends Evented {
+  constructor(layer, properties) {
+    super();
+
+    this.id = layer.id;
+    this.metadata = layer.metadata;
+    this.type = layer.type;
+    this.minzoom = layer.minzoom;
+    this.maxzoom = layer.maxzoom;
+    this.visibility = 'visible';
+    this.paint = {};
+    this.layout = {};
+
+    if (layer.type !== 'background') {
+      this.source = layer.source;
+      this.sourceLayer = layer['source-layer'];
+      this.filter = layer.filter;
+    }
+
+    this._featureFilter = () => true;
+
+    if (properties.layout) {
+      this._unevaluatedLayout = new Layout(properties.layout);
+    }
+
+    this._transitionablePaint = new Transitionable(properties.paint);
+
+    for (const property in layer.paint) {
+      this.setPaintProperty(property, layer.paint[property]);
+    }
+    for (const property in layer.layout) {
+      this.setLayoutProperty(property, layer.layout[property]);
+    }
+
+    this._transitioningPaint = this._transitionablePaint.untransitioned();
+  }
+
+  getCrossfadeParameters() {
+    return this._crossfadeParameters;
+  }
+
+  getLayoutProperty(name) {
+    if (name === 'visibility') {
+      return this.visibility;
+    }
+
+    return this._unevaluatedLayout.getValue(name);
+  }
+
+  setLayoutProperty(name, value) {
+    if (name === 'visibility') {
+      this.visibility = value === 'none' ? value : 'visible';
+      return;
+    }
+
+    this._unevaluatedLayout.setValue(name, value);
+  }
+
+  getPaintProperty(name) {
+    if (name.endsWith(TRANSITION_SUFFIX)) {
+      return this._transitionablePaint.getTransition(name.slice(0, -TRANSITION_SUFFIX.length));
+    }
+    return this._transitionablePaint.getValue(name);
+  }
+
+  setPaintProperty(name, value) {
+    if (name.endsWith(TRANSITION_SUFFIX)) {
+      this._transitionablePaint.setTransition(name.slice(0, -TRANSITION_SUFFIX.length), value || undefined);
+      return false;
+    }
+    // if a cross-faded value is changed, we need to make sure the new icons get added to each tile's iconAtlas
+    // so a call to _updateLayer is necessary, and we return true from this function so it gets called in
+    // Style#setPaintProperty
+    const prop = this._transitionablePaint._values[name];
+    const newCrossFadedValue =
+      prop.property.specification['property-type'] === 'cross-faded-data-driven' && !prop.value.value && value;
+    const wasDataDriven = this._transitionablePaint._values[name].value.isDataDriven();
+    this._transitionablePaint.setValue(name, value);
+    const isDataDriven = this._transitionablePaint._values[name].value.isDataDriven();
+    this._handleSpecialPaintPropertyUpdate(name);
+    return isDataDriven || wasDataDriven || newCrossFadedValue;
+  }
+
+  _handleSpecialPaintPropertyUpdate() {
+    // No-op; can be overridden by derived classes.
+  }
+
+  isHidden(zoom) {
+    if (this.minzoom && zoom < this.minzoom) return true;
+    if (this.maxzoom && zoom >= this.maxzoom) return true;
+    return this.visibility === 'none';
+  }
+
+  updateTransitions(parameters) {
+    this._transitioningPaint = this._transitionablePaint.transitioned(parameters, this._transitioningPaint);
+  }
+
+  hasTransition() {
+    return this._transitioningPaint.hasTransition();
+  }
+
+  recalculate(parameters) {
+    if (parameters.getCrossfadeParameters) {
+      this._crossfadeParameters = parameters.getCrossfadeParameters();
+    }
+    if (this._unevaluatedLayout) {
+      this.layout = this._unevaluatedLayout.possiblyEvaluate(parameters);
+    }
+
+    this.paint = this._transitioningPaint.possiblyEvaluate(parameters);
+  }
+
+  serialize() {
+    const output = {
+      id: this.id,
+      type: this.type,
+      source: this.source,
+      'source-layer': this.sourceLayer,
+      metadata: this.metadata,
+      minzoom: this.minzoom,
+      maxzoom: this.maxzoom,
+      filter: this.filter,
+      layout: this._unevaluatedLayout?.serialize(),
+      paint: this._transitionablePaint?.serialize()
+    };
+
+    if (this.visibility === 'none') {
+      output.layout = output.layout || {};
+      output.layout.visibility = 'none';
+    }
+
+    return filterObject(output, (value, key) => {
+      return (
+        value !== undefined &&
+        !(key === 'layout' && !Object.keys(value).length) &&
+        !(key === 'paint' && !Object.keys(value).length)
+      );
+    });
+  }
+
+  is3D() {
+    return false;
+  }
+
+  isTileClipped() {
+    return false;
+  }
+
+  hasOffscreenPass() {
+    return false;
+  }
+
+  resize() {
+    // noop
+  }
+
+  isStateDependent() {
+    for (const property in this.paint._values) {
+      const value = this.paint.get(property);
+      if (
+        !(value instanceof PossiblyEvaluatedPropertyValue) ||
+        !supportsPropertyExpression(value.property.specification)
+      ) {
+        continue;
+      }
+
+      if ((value.value.kind === 'source' || value.value.kind === 'composite') && value.value.isStateDependent) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+module.exports = StyleLayer;

package/src/style/style_layer_index.js

@@ -0,0 +1,61 @@
+const createStyleLayer = require('./create_style_layer');
+
+const { values } = require('../util/object');
+const featureFilter = require('../style-spec/feature_filter');
+const groupByLayout = require('../style-spec/group_by_layout');
+
+class StyleLayerIndex {
+  constructor(layerConfigs) {
+    if (layerConfigs) {
+      this.replace(layerConfigs);
+    }
+  }
+
+  replace(layerConfigs) {
+    this._layerConfigs = {};
+    this._layers = {};
+    this.update(layerConfigs, []);
+  }
+
+  update(layerConfigs, removedIds) {
+    for (const layerConfig of layerConfigs) {
+      this._layerConfigs[layerConfig.id] = layerConfig;
+
+      const layer = (this._layers[layerConfig.id] = createStyleLayer(layerConfig));
+      layer._featureFilter = featureFilter(layer.filter);
+    }
+    for (const id of removedIds) {
+      delete this._layerConfigs[id];
+      delete this._layers[id];
+    }
+
+    this.familiesBySource = {};
+
+    const groups = groupByLayout(values(this._layerConfigs));
+
+    for (const layerConfigs of groups) {
+      const layers = layerConfigs.map(layerConfig => this._layers[layerConfig.id]);
+
+      const layer = layers[0];
+      if (layer.visibility === 'none') {
+        continue;
+      }
+
+      const sourceId = layer.source || '';
+      let sourceGroup = this.familiesBySource[sourceId];
+      if (!sourceGroup) {
+        sourceGroup = this.familiesBySource[sourceId] = {};
+      }
+
+      const sourceLayerId = layer.sourceLayer || '_geojsonTileLayer';
+      let sourceLayerFamilies = sourceGroup[sourceLayerId];
+      if (!sourceLayerFamilies) {
+        sourceLayerFamilies = sourceGroup[sourceLayerId] = [];
+      }
+
+      sourceLayerFamilies.push(layers);
+    }
+  }
+}
+
+module.exports = StyleLayerIndex;

package/src/style/zoom_history.js

@@ -0,0 +1,36 @@
+class ZoomHistory {
+  constructor() {
+    this.first = true;
+  }
+
+  update(z, now) {
+    const floorZ = Math.floor(z);
+
+    if (this.first) {
+      this.first = false;
+      this.lastIntegerZoom = floorZ;
+      this.lastIntegerZoomTime = 0;
+      this.lastZoom = z;
+      this.lastFloorZoom = floorZ;
+      return true;
+    }
+
+    if (this.lastFloorZoom > floorZ) {
+      this.lastIntegerZoom = floorZ + 1;
+      this.lastIntegerZoomTime = now;
+    } else if (this.lastFloorZoom < floorZ) {
+      this.lastIntegerZoom = floorZ;
+      this.lastIntegerZoomTime = now;
+    }
+
+    if (z !== this.lastZoom) {
+      this.lastZoom = z;
+      this.lastFloorZoom = floorZ;
+      return true;
+    }
+
+    return false;
+  }
+}
+
+module.exports = ZoomHistory;

package/src/style-spec/deref.js

@@ -0,0 +1,51 @@
+const refProperties = require('./util/ref_properties');
+
+function deref(layer, parent) {
+  const result = {};
+
+  for (const k in layer) {
+    if (k !== 'ref') {
+      result[k] = layer[k];
+    }
+  }
+
+  refProperties.forEach(k => {
+    if (k in parent) {
+      result[k] = parent[k];
+    }
+  });
+
+  return result;
+}
+
+module.exports = derefLayers;
+
+/**
+ * Given an array of layers, some of which may contain `ref` properties
+ * whose value is the `id` of another property, return a new array where
+ * such layers have been augmented with the 'type', 'source', etc. properties
+ * from the parent layer, and the `ref` property has been removed.
+ *
+ * The input is not modified. The output may contain references to portions
+ * of the input.
+ *
+ * @private
+ * @param {Array<Layer>} layers
+ * @returns {Array<Layer>}
+ */
+function derefLayers(layers) {
+  layers = layers.slice();
+
+  const map = Object.create(null);
+  for (let i = 0; i < layers.length; i++) {
+    map[layers[i].id] = layers[i];
+  }
+
+  for (let i = 0; i < layers.length; i++) {
+    if ('ref' in layers[i]) {
+      layers[i] = deref(layers[i], map[layers[i].ref]);
+    }
+  }
+
+  return layers;
+}

package/src/style-spec/error/parsing_error.js

@@ -0,0 +1,8 @@
+function ParsingError(error) {
+  this.error = error;
+  this.message = error.message;
+  const match = error.message.match(/line (\d+)/);
+  this.line = match ? Number.parseInt(match[1], 10) : 0;
+}
+
+module.exports = ParsingError;

package/src/style-spec/error/validation_error.js

@@ -0,0 +1,10 @@
+module.exports = class ValidationError {
+  constructor(key, value, message, identifier) {
+    this.message = (key ? `${key}: ` : '') + message;
+    if (identifier) this.identifier = identifier;
+
+    if (value?.__line__) {
+      this.line = value.__line__;
+    }
+  }
+};

package/src/style-spec/expression/compound_expression.js

@@ -0,0 +1,118 @@
+const { toString } = require('./types');
+
+const assert = require('assert');
+
+class CompoundExpression {
+  constructor(name, type, evaluate, args) {
+    this.name = name;
+    this.type = type;
+    this._evaluate = evaluate;
+    this.args = args;
+  }
+
+  evaluate(ctx) {
+    return this._evaluate(ctx, this.args);
+  }
+
+  eachChild(fn) {
+    this.args.forEach(fn);
+  }
+
+  possibleOutputs() {
+    return [undefined];
+  }
+
+  serialize() {
+    return [this.name].concat(this.args.map(arg => arg.serialize()));
+  }
+
+  static parse(args, context) {
+    const ParsingContext = require('./parsing_context');
+
+    const op = args[0];
+    const definition = CompoundExpression.definitions[op];
+    if (!definition) {
+      return context.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
+    }
+
+    // Now check argument types against each signature
+    const type = Array.isArray(definition) ? definition[0] : definition.type;
+
+    const availableOverloads = Array.isArray(definition) ? [[definition[1], definition[2]]] : definition.overloads;
+
+    const overloads = availableOverloads.filter(
+      ([signature]) =>
+        !Array.isArray(signature) || // varags
+        signature.length === args.length - 1 // correct param count
+    );
+
+    // First parse all the args
+    const parsedArgs = [];
+    for (let i = 1; i < args.length; i++) {
+      const arg = args[i];
+      let expected;
+      if (overloads.length === 1) {
+        const params = overloads[0][0];
+        expected = Array.isArray(params) ? params[i - 1] : params.type;
+      }
+      const parsed = context.parse(arg, 1 + parsedArgs.length, expected);
+      if (!parsed) return null;
+      parsedArgs.push(parsed);
+    }
+
+    let signatureContext = null;
+
+    for (const [params, evaluate] of overloads) {
+      // Use a fresh context for each attempted signature so that, if
+      // we eventually succeed, we haven't polluted `context.errors`.
+      signatureContext = new ParsingContext(context.registry, context.path, null, context.scope);
+
+      if (Array.isArray(params)) {
+        if (params.length !== parsedArgs.length) {
+          signatureContext.error(`Expected ${params.length} arguments, but found ${parsedArgs.length} instead.`);
+          continue;
+        }
+      }
+
+      for (let i = 0; i < parsedArgs.length; i++) {
+        const expected = Array.isArray(params) ? params[i] : params.type;
+        const arg = parsedArgs[i];
+        signatureContext.concat(i + 1).checkSubtype(expected, arg.type);
+      }
+
+      if (signatureContext.errors.length === 0) {
+        return new CompoundExpression(op, type, evaluate, parsedArgs);
+      }
+    }
+
+    assert(!signatureContext || signatureContext.errors.length > 0);
+
+    if (overloads.length === 1) {
+      context.errors.push.apply(context.errors, signatureContext.errors);
+    } else {
+      const expected = overloads.length ? overloads : availableOverloads;
+      const signatures = expected.map(([params]) => stringifySignature(params)).join(' | ');
+      const actualTypes = parsedArgs.map(arg => toString(arg.type)).join(', ');
+      context.error(`Expected arguments of type ${signatures}, but found (${actualTypes}) instead.`);
+    }
+
+    return null;
+  }
+
+  static register(registry, definitions) {
+    assert(!CompoundExpression.definitions);
+    CompoundExpression.definitions = definitions;
+    for (const name in definitions) {
+      registry[name] = CompoundExpression;
+    }
+  }
+}
+
+function stringifySignature(signature) {
+  if (Array.isArray(signature)) {
+    return `(${signature.map(toString).join(', ')})`;
+  }
+  return `(${toString(signature.type)}...)`;
+}
+
+module.exports = CompoundExpression;

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

@@ -0,0 +1,82 @@
+const { toString, array, ValueType, StringType, NumberType, BooleanType, checkSubtype } = require('../types');
+
+const { typeOf } = require('../values');
+const RuntimeError = require('../runtime_error');
+
+const types = {
+  string: StringType,
+  number: NumberType,
+  boolean: BooleanType
+};
+
+class ArrayAssertion {
+  constructor(type, input) {
+    this.type = type;
+    this.input = input;
+  }
+
+  static parse(args, context) {
+    if (args.length < 2 || args.length > 4)
+      return context.error(`Expected 1, 2, or 3 arguments, but found ${args.length - 1} instead.`);
+
+    let itemType;
+    let N;
+    if (args.length > 2) {
+      const type = args[1];
+      if (typeof type !== 'string' || !(type in types))
+        return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
+      itemType = types[type];
+    } else {
+      itemType = ValueType;
+    }
+
+    if (args.length > 3) {
+      if (typeof args[2] !== 'number' || args[2] < 0 || args[2] !== Math.floor(args[2])) {
+        return context.error('The length argument to "array" must be a positive integer literal', 2);
+      }
+      N = args[2];
+    }
+
+    const type = array(itemType, N);
+
+    const input = context.parse(args[args.length - 1], args.length - 1, ValueType);
+    if (!input) return null;
+
+    return new ArrayAssertion(type, input);
+  }
+
+  evaluate(ctx) {
+    const value = this.input.evaluate(ctx);
+    const error = checkSubtype(this.type, typeOf(value));
+    if (error) {
+      throw new RuntimeError(
+        `Expected value to be of type ${toString(this.type)}, but found ${toString(typeOf(value))} instead.`
+      );
+    }
+    return value;
+  }
+
+  eachChild(fn) {
+    fn(this.input);
+  }
+
+  possibleOutputs() {
+    return this.input.possibleOutputs();
+  }
+
+  serialize() {
+    const serialized = ['array'];
+    const itemType = this.type.itemType;
+    if (itemType.kind === 'string' || itemType.kind === 'number' || itemType.kind === 'boolean') {
+      serialized.push(itemType.kind);
+      const N = this.type.N;
+      if (typeof N === 'number') {
+        serialized.push(N);
+      }
+    }
+    serialized.push(this.input.serialize());
+    return serialized;
+  }
+}
+
+module.exports = ArrayAssertion;

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

@@ -0,0 +1,69 @@
+const assert = require('assert');
+
+const { ObjectType, ValueType, StringType, NumberType, BooleanType, checkSubtype, toString } = require('../types');
+const RuntimeError = require('../runtime_error');
+const { typeOf } = require('../values');
+
+const types = {
+  string: StringType,
+  number: NumberType,
+  boolean: BooleanType,
+  object: ObjectType
+};
+
+class Assertion {
+  constructor(type, args) {
+    this.type = type;
+    this.args = args;
+  }
+
+  static parse(args, context) {
+    if (args.length < 2) return context.error('Expected at least one argument.');
+
+    const name = args[0];
+    assert(types[name], name);
+
+    const type = types[name];
+
+    const parsed = [];
+    for (let i = 1; i < args.length; i++) {
+      const input = context.parse(args[i], i, ValueType);
+      if (!input) return null;
+      parsed.push(input);
+    }
+
+    return new Assertion(type, parsed);
+  }
+
+  evaluate(ctx) {
+    for (let i = 0; i < this.args.length; i++) {
+      const value = this.args[i].evaluate(ctx);
+      const error = checkSubtype(this.type, typeOf(value));
+      if (!error) {
+        return value;
+      }
+      if (i === this.args.length - 1) {
+        throw new RuntimeError(
+          `Expected value to be of type ${toString(this.type)}, but found ${toString(typeOf(value))} instead.`
+        );
+      }
+    }
+
+    assert(false);
+    return null;
+  }
+
+  eachChild(fn) {
+    this.args.forEach(fn);
+  }
+
+  possibleOutputs() {
+    return [].concat(...this.args.map(arg => arg.possibleOutputs()));
+  }
+
+  serialize() {
+    return [this.type.kind].concat(this.args.map(arg => arg.serialize()));
+  }
+}
+
+module.exports = Assertion;

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

@@ -0,0 +1,57 @@
+const { array, ValueType, NumberType } = require('../types');
+
+const RuntimeError = require('../runtime_error');
+
+class At {
+  constructor(type, index, input) {
+    this.type = type;
+    this.index = index;
+    this.input = input;
+  }
+
+  static parse(args, context) {
+    if (args.length !== 3) return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
+
+    const index = context.parse(args[1], 1, NumberType);
+    const input = context.parse(args[2], 2, array(context.expectedType || ValueType));
+
+    if (!index || !input) return null;
+
+    const t = input.type;
+    return new At(t.itemType, index, input);
+  }
+
+  evaluate(ctx) {
+    const index = this.index.evaluate(ctx);
+    const array = this.input.evaluate(ctx);
+
+    if (index < 0) {
+      throw new RuntimeError(`Array index out of bounds: ${index} < 0.`);
+    }
+
+    if (index >= array.length) {
+      throw new RuntimeError(`Array index out of bounds: ${index} > ${array.length - 1}.`);
+    }
+
+    if (index !== Math.floor(index)) {
+      throw new RuntimeError(`Array index must be an integer, but found ${index} instead.`);
+    }
+
+    return array[index];
+  }
+
+  eachChild(fn) {
+    fn(this.index);
+    fn(this.input);
+  }
+
+  possibleOutputs() {
+    return [undefined];
+  }
+
+  serialize() {
+    return ['at', this.index.serialize(), this.input.serialize()];
+  }
+}
+
+module.exports = At;