@mapwhit/tilerenderer 0.50.0 → 0.51.0

package/src/util/dom.js

@@ -1,7 +1,3 @@
-const Point = require('@mapbox/point-geometry');
-
-const assert = require('assert');
-
 const DOM = {};
 module.exports = DOM;
 
@@ -16,87 +12,3 @@ 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/find_pole_of_inaccessibility.js

@@ -1,4 +1,4 @@
-const Queue = require('tinyqueue');
+const { default: Queue } = require('tinyqueue');
 
 const Point = require('@mapbox/point-geometry');
 const { distToSegmentSquared } = require('./intersection_tests');
@@ -34,7 +34,7 @@ module.exports = function (polygonRings, precision = 1, debug = false) {
   let h = cellSize / 2;
 
   // a priority queue of cells in order of their "potential" (max distance to polygon)
-  const cellQueue = new Queue(null, compareMax);
+  const cellQueue = new Queue(undefined, compareMax);
 
   if (cellSize === 0) return new Point(minX, minY);
 

package/src/util/web_worker_transfer.js

@@ -1,13 +1,13 @@
 const Grid = require('grid-index');
-const Color = require('../style-spec/util/color');
+const { Color } = require('@mapwhit/style-expressions');
 const {
+  CompoundExpression,
+  definitions: expressions,
   StylePropertyFunction,
   StyleExpression,
   ZoomDependentExpression,
   ZoomConstantExpression
-} = require('../style-spec/expression');
-const CompoundExpression = require('../style-spec/expression/compound_expression');
-const expressions = require('../style-spec/expression/definitions');
+} = require('@mapwhit/style-expressions');
 
 const { register, serialize, deserialize } = require('./transfer_registry');
 module.exports = {

package/src/style/load_glyph_range.js

@@ -1,17 +0,0 @@
-const parseGlyphPBF = require('./parse_glyph_pbf');
-const { callback } = require('../util/callback');
-
-module.exports = loadGlyphRange;
-
-function loadGlyphRange(fontstack, range, load, fn) {
-  return callback(fn, perform());
-
-  async function perform() {
-    const data = await load(fontstack, range);
-    const glyphs = {};
-    for (const glyph of parseGlyphPBF(data)) {
-      glyphs[glyph.id] = glyph;
-    }
-    return glyphs;
-  }
-}

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

@@ -1,132 +0,0 @@
-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
-    );
-
-    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);
-
-      // First parse all the args, potentially coercing to the
-      // types expected by this overload.
-      const parsedArgs = [];
-      let argParseFailed = false;
-      for (let i = 1; i < args.length; i++) {
-        const arg = args[i];
-        const expectedType = Array.isArray(params) ? params[i - 1] : params.type;
-
-        const parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
-        if (!parsed) {
-          argParseFailed = true;
-          break;
-        }
-        parsedArgs.push(parsed);
-      }
-      if (argParseFailed) {
-        // Couldn't coerce args of this overload to expected type, move
-        // on to next one.
-        continue;
-      }
-
-      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 = [];
-      // For error message, re-parse arguments without trying to
-      // apply any coercions
-      for (let i = 1; i < args.length; i++) {
-        const parsed = context.parse(args[i], 1 + actualTypes.length);
-        if (!parsed) return null;
-        actualTypes.push(toString(parsed.type));
-      }
-      context.error(`Expected arguments of type ${signatures}, but found (${actualTypes.join(', ')}) 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/assertion.js

@@ -1,116 +0,0 @@
-const assert = require('assert');
-
-const {
-  ObjectType,
-  ValueType,
-  StringType,
-  NumberType,
-  BooleanType,
-  checkSubtype,
-  toString,
-  array
-} = 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.');
-
-    let i = 1;
-    let type;
-
-    const name = args[0];
-    if (name === 'array') {
-      let itemType;
-      if (args.length > 2) {
-        const type = args[1];
-        if (typeof type !== 'string' || !(type in types) || type === 'object')
-          return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
-        itemType = types[type];
-        i++;
-      } else {
-        itemType = ValueType;
-      }
-
-      let N;
-      if (args.length > 3) {
-        if (args[2] !== null && (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];
-        i++;
-      }
-
-      type = array(itemType, N);
-    } else {
-      assert(types[name], name);
-      type = types[name];
-    }
-
-    const parsed = [];
-    for (; 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() {
-    const type = this.type;
-    const serialized = [type.kind];
-    if (type.kind === 'array') {
-      const itemType = type.itemType;
-      if (itemType.kind === 'string' || itemType.kind === 'number' || itemType.kind === 'boolean') {
-        serialized.push(itemType.kind);
-        const N = type.N;
-        if (typeof N === 'number' || this.args.length > 1) {
-          serialized.push(N);
-        }
-      }
-    }
-    return serialized.concat(this.args.map(arg => arg.serialize()));
-  }
-}
-
-module.exports = Assertion;

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

@@ -1,57 +0,0 @@
-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;

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

@@ -1,73 +0,0 @@
-const assert = require('assert');
-
-const { BooleanType } = require('../types');
-
-class Case {
-  constructor(type, branches, otherwise) {
-    this.type = type;
-    this.branches = branches;
-    this.otherwise = otherwise;
-  }
-
-  static parse(args, context) {
-    if (args.length < 4) return context.error(`Expected at least 3 arguments, but found only ${args.length - 1}.`);
-    if (args.length % 2 !== 0) return context.error('Expected an odd number of arguments.');
-
-    let outputType;
-    if (context.expectedType && context.expectedType.kind !== 'value') {
-      outputType = context.expectedType;
-    }
-
-    const branches = [];
-    for (let i = 1; i < args.length - 1; i += 2) {
-      const test = context.parse(args[i], i, BooleanType);
-      if (!test) return null;
-
-      const result = context.parse(args[i + 1], i + 1, outputType);
-      if (!result) return null;
-
-      branches.push([test, result]);
-
-      outputType = outputType || result.type;
-    }
-
-    const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
-    if (!otherwise) return null;
-
-    assert(outputType);
-    return new Case(outputType, branches, otherwise);
-  }
-
-  evaluate(ctx) {
-    for (const [test, expression] of this.branches) {
-      if (test.evaluate(ctx)) {
-        return expression.evaluate(ctx);
-      }
-    }
-    return this.otherwise.evaluate(ctx);
-  }
-
-  eachChild(fn) {
-    for (const [test, expression] of this.branches) {
-      fn(test);
-      fn(expression);
-    }
-    fn(this.otherwise);
-  }
-
-  possibleOutputs() {
-    return []
-      .concat(...this.branches.map(branch => branch[1].possibleOutputs()))
-      .concat(this.otherwise.possibleOutputs());
-  }
-
-  serialize() {
-    const serialized = ['case'];
-    this.eachChild(child => {
-      serialized.push(child.serialize());
-    });
-    return serialized;
-  }
-}
-
-module.exports = Case;

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

@@ -1,66 +0,0 @@
-const assert = require('assert');
-
-const { checkSubtype, ValueType } = require('../types');
-
-class Coalesce {
-  constructor(type, args) {
-    this.type = type;
-    this.args = args;
-  }
-
-  static parse(args, context) {
-    if (args.length < 2) {
-      return context.error('Expectected at least one argument.');
-    }
-    let outputType = null;
-    const expectedType = context.expectedType;
-    if (expectedType && expectedType.kind !== 'value') {
-      outputType = expectedType;
-    }
-    const parsedArgs = [];
-
-    for (const arg of args.slice(1)) {
-      const parsed = context.parse(arg, 1 + parsedArgs.length, outputType, undefined, { typeAnnotation: 'omit' });
-      if (!parsed) return null;
-      outputType = outputType || parsed.type;
-      parsedArgs.push(parsed);
-    }
-    assert(outputType);
-
-    // Above, we parse arguments without inferred type annotation so that
-    // they don't produce a runtime error for `null` input, which would
-    // preempt the desired null-coalescing behavior.
-    // Thus, if any of our arguments would have needed an annotation, we
-    // need to wrap the enclosing coalesce expression with it instead.
-    const needsAnnotation = expectedType && parsedArgs.some(arg => checkSubtype(expectedType, arg.type));
-
-    return needsAnnotation ? new Coalesce(ValueType, parsedArgs) : new Coalesce(outputType, parsedArgs);
-  }
-
-  evaluate(ctx) {
-    let result = null;
-    for (const arg of this.args) {
-      result = arg.evaluate(ctx);
-      if (result !== null) break;
-    }
-    return result;
-  }
-
-  eachChild(fn) {
-    this.args.forEach(fn);
-  }
-
-  possibleOutputs() {
-    return [].concat(...this.args.map(arg => arg.possibleOutputs()));
-  }
-
-  serialize() {
-    const serialized = ['coalesce'];
-    this.eachChild(child => {
-      serialized.push(child.serialize());
-    });
-    return serialized;
-  }
-}
-
-module.exports = Coalesce;