@mapwhit/tilerenderer 0.50.0 → 0.51.0

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

@@ -1,37 +0,0 @@
-const RuntimeError = require('./runtime_error');
-
-/**
- * Returns the index of the last stop <= input, or 0 if it doesn't exist.
- * @private
- */
-function findStopLessThanOrEqualTo(stops, input) {
-  const n = stops.length;
-  let lowerIndex = 0;
-  let upperIndex = n - 1;
-  let currentIndex = 0;
-  let currentValue;
-  let upperValue;
-
-  while (lowerIndex <= upperIndex) {
-    currentIndex = Math.floor((lowerIndex + upperIndex) / 2);
-    currentValue = stops[currentIndex];
-    upperValue = stops[currentIndex + 1];
-    if (input === currentValue || (input > currentValue && input < upperValue)) {
-      // Search complete
-      return currentIndex;
-    }
-    if (currentValue < input) {
-      lowerIndex = currentIndex + 1;
-    } else if (currentValue > input) {
-      upperIndex = currentIndex - 1;
-    } else {
-      throw new RuntimeError('Input is not a number.');
-    }
-  }
-
-  return Math.max(currentIndex - 1, 0);
-}
-
-module.exports = {
-  findStopLessThanOrEqualTo
-};

package/src/style-spec/expression/types/collator.js

@@ -1,24 +0,0 @@
-class Collator {
-  constructor(caseSensitive, diacriticSensitive, locale) {
-    if (caseSensitive) this.sensitivity = diacriticSensitive ? 'variant' : 'case';
-    else this.sensitivity = diacriticSensitive ? 'accent' : 'base';
-
-    this.locale = locale;
-    this.collator = new Intl.Collator(this.locale ? this.locale : [], {
-      sensitivity: this.sensitivity,
-      usage: 'search'
-    });
-  }
-
-  compare(lhs, rhs) {
-    return this.collator.compare(lhs, rhs);
-  }
-
-  resolvedLocale() {
-    // We create a Collator without "usage: search" because we don't want
-    // the search options encoded in our result (e.g. "en-u-co-search")
-    return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
-  }
-}
-
-module.exports = { Collator };

package/src/style-spec/expression/types/formatted.js

@@ -1,39 +0,0 @@
-class FormattedSection {
-  constructor(text, scale, fontStack = null) {
-    this.text = text;
-    this.scale = scale;
-    this.fontStack = fontStack;
-  }
-}
-
-class Formatted {
-  constructor(sections) {
-    this.sections = sections;
-  }
-
-  static fromString(unformatted) {
-    return new Formatted([new FormattedSection(unformatted, null, null)]);
-  }
-
-  toString() {
-    return this.sections.map(section => section.text).join('');
-  }
-
-  serialize() {
-    const serialized = ['format'];
-    for (const section of this.sections) {
-      serialized.push(section.text);
-      const options = {};
-      if (section.fontStack) {
-        options['text-font'] = ['literal', section.fontStack.split(',')];
-      }
-      if (section.scale) {
-        options['font-scale'] = section.scale;
-      }
-      serialized.push(options);
-    }
-    return serialized;
-  }
-}
-
-module.exports = { Formatted, FormattedSection };

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

@@ -1,88 +0,0 @@
-const NullType = { kind: 'null' };
-const NumberType = { kind: 'number' };
-const StringType = { kind: 'string' };
-const BooleanType = { kind: 'boolean' };
-const ColorType = { kind: 'color' };
-const ObjectType = { kind: 'object' };
-const ValueType = { kind: 'value' };
-const ErrorType = { kind: 'error' };
-const CollatorType = { kind: 'collator' };
-const FormattedType = { kind: 'formatted' };
-
-function array(itemType, N) {
-  return {
-    kind: 'array',
-    itemType,
-    N
-  };
-}
-
-function toString(type) {
-  if (type.kind === 'array') {
-    const itemType = toString(type.itemType);
-    return typeof type.N === 'number'
-      ? `array<${itemType}, ${type.N}>`
-      : type.itemType.kind === 'value'
-        ? 'array'
-        : `array<${itemType}>`;
-  }
-  return type.kind;
-}
-
-const valueMemberTypes = [
-  NullType,
-  NumberType,
-  StringType,
-  BooleanType,
-  ColorType,
-  FormattedType,
-  ObjectType,
-  array(ValueType)
-];
-
-/**
- * Returns null if `t` is a subtype of `expected`; otherwise returns an
- * error message.
- * @private
- */
-function checkSubtype(expected, t) {
-  if (t.kind === 'error') {
-    // Error is a subtype of every type
-    return null;
-  }
-  if (expected.kind === 'array') {
-    if (
-      t.kind === 'array' &&
-      ((t.N === 0 && t.itemType.kind === 'value') || !checkSubtype(expected.itemType, t.itemType)) &&
-      (typeof expected.N !== 'number' || expected.N === t.N)
-    ) {
-      return null;
-    }
-  } else if (expected.kind === t.kind) {
-    return null;
-  } else if (expected.kind === 'value') {
-    for (const memberType of valueMemberTypes) {
-      if (!checkSubtype(memberType, t)) {
-        return null;
-      }
-    }
-  }
-
-  return `Expected ${toString(expected)} but found ${toString(t)} instead.`;
-}
-
-module.exports = {
-  NullType,
-  NumberType,
-  StringType,
-  BooleanType,
-  ColorType,
-  FormattedType,
-  ObjectType,
-  ValueType,
-  ErrorType,
-  CollatorType,
-  array,
-  toString,
-  checkSubtype
-};

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

@@ -1,149 +0,0 @@
-const assert = require('assert');
-
-const Color = require('../util/color');
-const { Collator } = require('./types/collator');
-const { Formatted } = require('./types/formatted');
-const {
-  NullType,
-  NumberType,
-  StringType,
-  BooleanType,
-  ColorType,
-  ObjectType,
-  ValueType,
-  CollatorType,
-  FormattedType,
-  array
-} = require('./types');
-
-function validateRGBA(r, g, b, a) {
-  if (
-    !(
-      typeof r === 'number' &&
-      r >= 0 &&
-      r <= 255 &&
-      typeof g === 'number' &&
-      g >= 0 &&
-      g <= 255 &&
-      typeof b === 'number' &&
-      b >= 0 &&
-      b <= 255
-    )
-  ) {
-    const value = typeof a === 'number' ? [r, g, b, a] : [r, g, b];
-    return `Invalid rgba value [${value.join(', ')}]: 'r', 'g', and 'b' must be between 0 and 255.`;
-  }
-
-  if (!(typeof a === 'undefined' || (typeof a === 'number' && a >= 0 && a <= 1))) {
-    return `Invalid rgba value [${[r, g, b, a].join(', ')}]: 'a' must be between 0 and 1.`;
-  }
-
-  return null;
-}
-
-function isValue(mixed) {
-  if (mixed === null) {
-    return true;
-  }
-  if (typeof mixed === 'string') {
-    return true;
-  }
-  if (typeof mixed === 'boolean') {
-    return true;
-  }
-  if (typeof mixed === 'number') {
-    return true;
-  }
-  if (mixed instanceof Color) {
-    return true;
-  }
-  if (mixed instanceof Collator) {
-    return true;
-  }
-  if (mixed instanceof Formatted) {
-    return true;
-  }
-  if (Array.isArray(mixed)) {
-    for (const item of mixed) {
-      if (!isValue(item)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (typeof mixed === 'object') {
-    for (const key in mixed) {
-      if (!isValue(mixed[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-
-function typeOf(value) {
-  if (value === null) {
-    return NullType;
-  }
-  if (typeof value === 'string') {
-    return StringType;
-  }
-  if (typeof value === 'boolean') {
-    return BooleanType;
-  }
-  if (typeof value === 'number') {
-    return NumberType;
-  }
-  if (value instanceof Color) {
-    return ColorType;
-  }
-  if (value instanceof Collator) {
-    return CollatorType;
-  }
-  if (value instanceof Formatted) {
-    return FormattedType;
-  }
-  if (Array.isArray(value)) {
-    const length = value.length;
-    let itemType;
-
-    for (const item of value) {
-      const t = typeOf(item);
-      if (!itemType) {
-        itemType = t;
-      } else if (itemType === t) {
-      } else {
-        itemType = ValueType;
-        break;
-      }
-    }
-
-    return array(itemType || ValueType, length);
-  }
-  assert(typeof value === 'object');
-  return ObjectType;
-}
-
-function toString(value) {
-  const type = typeof value;
-  if (value === null) {
-    return '';
-  }
-  if (type === 'string' || type === 'number' || type === 'boolean') {
-    return String(value);
-  }
-  if (value instanceof Color || value instanceof Formatted) {
-    return value.toString();
-  }
-  return JSON.stringify(value);
-}
-
-module.exports = {
-  toString,
-  Color,
-  Collator,
-  validateRGBA,
-  isValue,
-  typeOf
-};

package/src/style-spec/function/convert.js

@@ -1,240 +0,0 @@
-const assert = require('assert');
-
-module.exports = convertFunction;
-
-function convertLiteral(value) {
-  return typeof value === 'object' ? ['literal', value] : value;
-}
-
-function convertFunction(parameters, propertySpec) {
-  let stops = parameters.stops;
-  if (!stops) {
-    // identity function
-    return convertIdentityFunction(parameters, propertySpec);
-  }
-
-  const zoomAndFeatureDependent = stops && typeof stops[0][0] === 'object';
-  const featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
-  const zoomDependent = zoomAndFeatureDependent || !featureDependent;
-
-  stops = stops.map(stop => {
-    if (!featureDependent && propertySpec.tokens && typeof stop[1] === 'string') {
-      return [stop[0], convertTokenString(stop[1])];
-    }
-    return [stop[0], convertLiteral(stop[1])];
-  });
-
-  if (zoomAndFeatureDependent) {
-    return convertZoomAndPropertyFunction(parameters, propertySpec, stops);
-  }
-  if (zoomDependent) {
-    return convertZoomFunction(parameters, propertySpec, stops);
-  }
-  return convertPropertyFunction(parameters, propertySpec, stops);
-}
-
-function convertIdentityFunction(parameters, propertySpec) {
-  const get = ['get', parameters.property];
-
-  if (parameters.default === undefined) {
-    // By default, expressions for string-valued properties get coerced. To preserve
-    // legacy function semantics, insert an explicit assertion instead.
-    return propertySpec.type === 'string' ? ['string', get] : get;
-  }
-  if (propertySpec.type === 'enum') {
-    return ['match', get, Object.keys(propertySpec.values), get, parameters.default];
-  }
-  const expression = [
-    propertySpec.type === 'color' ? 'to-color' : propertySpec.type,
-    get,
-    convertLiteral(parameters.default)
-  ];
-  if (propertySpec.type === 'array') {
-    expression.splice(1, 0, propertySpec.value, propertySpec.length || null);
-  }
-  return expression;
-}
-
-function getInterpolateOperator(parameters) {
-  switch (parameters.colorSpace) {
-    case 'hcl':
-      return 'interpolate-hcl';
-    case 'lab':
-      return 'interpolate-lab';
-    default:
-      return 'interpolate';
-  }
-}
-
-function convertZoomAndPropertyFunction(parameters, propertySpec, stops) {
-  const featureFunctionParameters = {};
-  const featureFunctionStops = {};
-  const zoomStops = [];
-  for (let s = 0; s < stops.length; s++) {
-    const stop = stops[s];
-    const zoom = stop[0].zoom;
-    if (featureFunctionParameters[zoom] === undefined) {
-      featureFunctionParameters[zoom] = {
-        zoom: zoom,
-        type: parameters.type,
-        property: parameters.property,
-        default: parameters.default
-      };
-      featureFunctionStops[zoom] = [];
-      zoomStops.push(zoom);
-    }
-    featureFunctionStops[zoom].push([stop[0].value, stop[1]]);
-  }
-
-  // the interpolation type for the zoom dimension of a zoom-and-property
-  // function is determined directly from the style property specification
-  // for which it's being used: linear for interpolatable properties, step
-  // otherwise.
-  const functionType = getFunctionType({}, propertySpec);
-  if (functionType === 'exponential') {
-    const expression = [getInterpolateOperator(parameters), ['linear'], ['zoom']];
-
-    for (const z of zoomStops) {
-      const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
-      appendStopPair(expression, z, output, false);
-    }
-
-    return expression;
-  }
-  const expression = ['step', ['zoom']];
-
-  for (const z of zoomStops) {
-    const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
-    appendStopPair(expression, z, output, true);
-  }
-
-  fixupDegenerateStepCurve(expression);
-
-  return expression;
-}
-
-function coalesce(a, b) {
-  if (a !== undefined) return a;
-  if (b !== undefined) return b;
-}
-
-function convertPropertyFunction(parameters, propertySpec, stops) {
-  const type = getFunctionType(parameters, propertySpec);
-  const get = ['get', parameters.property];
-  if (type === 'categorical' && typeof stops[0][0] === 'boolean') {
-    assert(parameters.stops.length > 0 && parameters.stops.length <= 2);
-    const expression = ['case'];
-    for (const stop of stops) {
-      expression.push(['==', get, stop[0]], stop[1]);
-    }
-    expression.push(convertLiteral(coalesce(parameters.default, propertySpec.default)));
-    return expression;
-  }
-  if (type === 'categorical') {
-    const expression = ['match', get];
-    for (const stop of stops) {
-      appendStopPair(expression, stop[0], stop[1], false);
-    }
-    expression.push(convertLiteral(coalesce(parameters.default, propertySpec.default)));
-    return expression;
-  }
-  if (type === 'interval') {
-    const expression = ['step', ['number', get]];
-    for (const stop of stops) {
-      appendStopPair(expression, stop[0], stop[1], true);
-    }
-    fixupDegenerateStepCurve(expression);
-    return parameters.default === undefined
-      ? expression
-      : ['case', ['==', ['typeof', get], 'number'], expression, convertLiteral(parameters.default)];
-  }
-  if (type === 'exponential') {
-    const base = parameters.base !== undefined ? parameters.base : 1;
-    const expression = [getInterpolateOperator(parameters), ['exponential', base], ['number', get]];
-    for (const stop of stops) {
-      appendStopPair(expression, stop[0], stop[1], false);
-    }
-    return parameters.default === undefined
-      ? expression
-      : ['case', ['==', ['typeof', get], 'number'], expression, convertLiteral(parameters.default)];
-  }
-  throw new Error(`Unknown property function type ${type}`);
-}
-
-function convertZoomFunction(parameters, propertySpec, stops, input = ['zoom']) {
-  const type = getFunctionType(parameters, propertySpec);
-  let expression;
-  let isStep = false;
-  if (type === 'interval') {
-    expression = ['step', input];
-    isStep = true;
-  } else if (type === 'exponential') {
-    const base = parameters.base !== undefined ? parameters.base : 1;
-    expression = [getInterpolateOperator(parameters), ['exponential', base], input];
-  } else {
-    throw new Error(`Unknown zoom function type "${type}"`);
-  }
-
-  for (const stop of stops) {
-    appendStopPair(expression, stop[0], stop[1], isStep);
-  }
-
-  fixupDegenerateStepCurve(expression);
-
-  return expression;
-}
-
-function fixupDegenerateStepCurve(expression) {
-  // degenerate step curve (i.e. a constant function): add a noop stop
-  if (expression[0] === 'step' && expression.length === 3) {
-    expression.push(0);
-    expression.push(expression[3]);
-  }
-}
-
-function appendStopPair(curve, input, output, isStep) {
-  // Skip duplicate stop values. They were not validated for functions, but they are for expressions.
-  // https://github.com/mapbox/mapbox-gl-js/issues/4107
-  if (curve.length > 3 && input === curve[curve.length - 2]) {
-    return;
-  }
-  // step curves don't get the first input value, as it is redundant.
-  if (!(isStep && curve.length === 2)) {
-    curve.push(input);
-  }
-  curve.push(output);
-}
-
-function getFunctionType(parameters, propertySpec) {
-  if (parameters.type) {
-    return parameters.type;
-  }
-  assert(propertySpec.expression);
-  return propertySpec.expression.interpolated ? 'exponential' : 'interval';
-}
-
-// "String with {name} token" => ["concat", "String with ", ["get", "name"], " token"]
-function convertTokenString(s) {
-  const result = ['concat'];
-  const re = /{([^{}]+)}/g;
-  let pos = 0;
-  let match;
-  while ((match = re.exec(s)) !== null) {
-    const literal = s.slice(pos, re.lastIndex - match[0].length);
-    pos = re.lastIndex;
-    if (literal.length > 0) result.push(literal);
-    result.push(['get', match[1]]);
-  }
-
-  if (result.length === 1) {
-    return s;
-  }
-
-  if (pos < s.length) {
-    result.push(s.slice(pos));
-  } else if (result.length === 2) {
-    return ['to-string', result[1]];
-  }
-
-  return result;
-}