@mapwhit/tilerenderer 0.50.0 → 0.51.0

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

@@ -1,303 +0,0 @@
-const colorSpaces = require('../util/color_spaces');
-const Color = require('../util/color');
-const getType = require('../util/get_type');
-const interpolate = require('../util/interpolate');
-const Interpolate = require('../expression/definitions/interpolate');
-const { Formatted } = require('../expression/types/formatted');
-const { supportsInterpolation } = require('../util/properties');
-
-module.exports = {
-  isFunction,
-  createFunction
-};
-
-function isFunction(value) {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function identityFunction(x) {
-  return x;
-}
-
-function createFunction(parameters, propertySpec) {
-  const isColor = propertySpec.type === 'color';
-  const zoomAndFeatureDependent = parameters.stops && typeof parameters.stops[0][0] === 'object';
-  const featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
-  const zoomDependent = zoomAndFeatureDependent || !featureDependent;
-  const type = parameters.type || (supportsInterpolation(propertySpec) ? 'exponential' : 'interval');
-
-  if (isColor) {
-    parameters = { ...parameters };
-
-    if (parameters.stops) {
-      parameters.stops = parameters.stops.map(stop => {
-        return [stop[0], Color.parse(stop[1])];
-      });
-    }
-
-    if (parameters.default) {
-      parameters.default = Color.parse(parameters.default);
-    } else {
-      parameters.default = Color.parse(propertySpec.default);
-    }
-  }
-
-  if (parameters.colorSpace && parameters.colorSpace !== 'rgb' && !colorSpaces[parameters.colorSpace]) {
-    throw new Error(`Unknown color space: ${parameters.colorSpace}`);
-  }
-
-  let innerFun;
-  let hashedStops;
-  let categoricalKeyType;
-  if (type === 'exponential') {
-    innerFun = evaluateExponentialFunction;
-  } else if (type === 'interval') {
-    innerFun = evaluateIntervalFunction;
-  } else if (type === 'categorical') {
-    innerFun = evaluateCategoricalFunction;
-
-    // For categorical functions, generate an Object as a hashmap of the stops for fast searching
-    hashedStops = Object.create(null);
-    for (const stop of parameters.stops) {
-      hashedStops[stop[0]] = stop[1];
-    }
-
-    // Infer key type based on first stop key-- used to encforce strict type checking later
-    categoricalKeyType = typeof parameters.stops[0][0];
-  } else if (type === 'identity') {
-    innerFun = evaluateIdentityFunction;
-  } else {
-    throw new Error(`Unknown function type "${type}"`);
-  }
-
-  if (zoomAndFeatureDependent) {
-    const featureFunctions = {};
-    const zoomStops = [];
-    for (let s = 0; s < parameters.stops.length; s++) {
-      const stop = parameters.stops[s];
-      const zoom = stop[0].zoom;
-      if (featureFunctions[zoom] === undefined) {
-        featureFunctions[zoom] = {
-          zoom: zoom,
-          type: parameters.type,
-          property: parameters.property,
-          default: parameters.default,
-          stops: []
-        };
-        zoomStops.push(zoom);
-      }
-      featureFunctions[zoom].stops.push([stop[0].value, stop[1]]);
-    }
-
-    const featureFunctionStops = [];
-    for (const z of zoomStops) {
-      featureFunctionStops.push([featureFunctions[z].zoom, createFunction(featureFunctions[z], propertySpec)]);
-    }
-
-    return {
-      kind: 'composite',
-      interpolationFactor: Interpolate.interpolationFactor.bind(undefined, { name: 'linear' }),
-      zoomStops: featureFunctionStops.map(s => s[0]),
-      evaluate({ zoom }, properties) {
-        return evaluateExponentialFunction(
-          {
-            stops: featureFunctionStops,
-            base: parameters.base
-          },
-          propertySpec,
-          zoom
-        ).evaluate(zoom, properties);
-      }
-    };
-  }
-  if (zoomDependent) {
-    return {
-      kind: 'camera',
-      interpolationFactor:
-        type === 'exponential'
-          ? Interpolate.interpolationFactor.bind(undefined, {
-              name: 'exponential',
-              base: parameters.base !== undefined ? parameters.base : 1
-            })
-          : () => 0,
-      zoomStops: parameters.stops.map(s => s[0]),
-      evaluate: ({ zoom }) => innerFun(parameters, propertySpec, zoom, hashedStops, categoricalKeyType)
-    };
-  }
-  return {
-    kind: 'source',
-    evaluate(_, feature) {
-      const value = feature?.properties ? feature.properties[parameters.property] : undefined;
-      if (value === undefined) {
-        return coalesce(parameters.default, propertySpec.default);
-      }
-      return innerFun(parameters, propertySpec, value, hashedStops, categoricalKeyType);
-    }
-  };
-}
-
-function coalesce(a, b, c) {
-  if (a !== undefined) return a;
-  if (b !== undefined) return b;
-  if (c !== undefined) return c;
-}
-
-function evaluateCategoricalFunction(parameters, propertySpec, input, hashedStops, keyType) {
-  const evaluated = typeof input === keyType ? hashedStops[input] : undefined; // Enforce strict typing on input
-  return coalesce(evaluated, parameters.default, propertySpec.default);
-}
-
-function evaluateIntervalFunction(parameters, propertySpec, input) {
-  // Edge cases
-  if (getType(input) !== 'number') return coalesce(parameters.default, propertySpec.default);
-  const n = parameters.stops.length;
-  if (n === 1) return parameters.stops[0][1];
-  if (input <= parameters.stops[0][0]) return parameters.stops[0][1];
-  if (input >= parameters.stops[n - 1][0]) return parameters.stops[n - 1][1];
-
-  const index = findStopLessThanOrEqualTo(parameters.stops, input);
-
-  return parameters.stops[index][1];
-}
-
-function evaluateExponentialFunction(parameters, propertySpec, input) {
-  const base = parameters.base !== undefined ? parameters.base : 1;
-
-  // Edge cases
-  if (getType(input) !== 'number') return coalesce(parameters.default, propertySpec.default);
-  const n = parameters.stops.length;
-  if (n === 1) return parameters.stops[0][1];
-  if (input <= parameters.stops[0][0]) return parameters.stops[0][1];
-  if (input >= parameters.stops[n - 1][0]) return parameters.stops[n - 1][1];
-
-  const index = findStopLessThanOrEqualTo(parameters.stops, input);
-  const t = interpolationFactor(input, base, parameters.stops[index][0], parameters.stops[index + 1][0]);
-
-  const outputLower = parameters.stops[index][1];
-  const outputUpper = parameters.stops[index + 1][1];
-  let interp = interpolate[propertySpec.type] || identityFunction;
-
-  if (parameters.colorSpace && parameters.colorSpace !== 'rgb') {
-    const colorspace = colorSpaces[parameters.colorSpace];
-    interp = (a, b) => colorspace.reverse(colorspace.interpolate(colorspace.forward(a), colorspace.forward(b), t));
-  }
-
-  if (typeof outputLower.evaluate === 'function') {
-    return {
-      evaluate(...args) {
-        const evaluatedLower = outputLower.evaluate.apply(undefined, args);
-        const evaluatedUpper = outputUpper.evaluate.apply(undefined, args);
-        // Special case for fill-outline-color, which has no spec default.
-        if (evaluatedLower === undefined || evaluatedUpper === undefined) {
-          return undefined;
-        }
-        return interp(evaluatedLower, evaluatedUpper, t);
-      }
-    };
-  }
-
-  return interp(outputLower, outputUpper, t);
-}
-
-function evaluateIdentityFunction(parameters, propertySpec, input) {
-  switch (propertySpec.type) {
-    case 'color':
-      input = Color.parse(input);
-      break;
-    case 'formatted':
-      input = Formatted.fromString(input.toString());
-      break;
-    case 'enum':
-      if (!propertySpec.values.includes(input)) {
-        input = undefined;
-      }
-      break;
-    default:
-      if (getType(input) !== propertySpec.type) {
-        input = undefined;
-      }
-  }
-  return coalesce(input, parameters.default, propertySpec.default);
-}
-
-/**
- * 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][0];
-    upperValue = stops[currentIndex + 1][0];
-    if (input === currentValue || (input > currentValue && input < upperValue)) {
-      // Search complete
-      return currentIndex;
-    }
-    if (currentValue < input) {
-      lowerIndex = currentIndex + 1;
-    } else if (currentValue > input) {
-      upperIndex = currentIndex - 1;
-    }
-  }
-
-  return Math.max(currentIndex - 1, 0);
-}
-
-/**
- * Returns a ratio that can be used to interpolate between exponential function
- * stops.
- *
- * How it works:
- * Two consecutive stop values define a (scaled and shifted) exponential
- * function `f(x) = a * base^x + b`, where `base` is the user-specified base,
- * and `a` and `b` are constants affording sufficient degrees of freedom to fit
- * the function to the given stops.
- *
- * Here's a bit of algebra that lets us compute `f(x)` directly from the stop
- * values without explicitly solving for `a` and `b`:
- *
- * First stop value: `f(x0) = y0 = a * base^x0 + b`
- * Second stop value: `f(x1) = y1 = a * base^x1 + b`
- * => `y1 - y0 = a(base^x1 - base^x0)`
- * => `a = (y1 - y0)/(base^x1 - base^x0)`
- *
- * Desired value: `f(x) = y = a * base^x + b`
- * => `f(x) = y0 + a * (base^x - base^x0)`
- *
- * From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
- * little algebra:
- * ```
- * a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
- *                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
- * ```
- *
- * If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
- * `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
- * an interpolation factor between the two stops' output values.
- *
- * (Note: a slightly different form for `ratio`,
- * `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
- * expensive `Math.pow()` operations.)
- *
- * @private
- */
-function interpolationFactor(input, base, lowerValue, upperValue) {
-  const difference = upperValue - lowerValue;
-  const progress = input - lowerValue;
-
-  if (difference === 0) {
-    return 0;
-  }
-  if (base === 1) {
-    return progress / difference;
-  }
-  return (base ** progress - 1) / (base ** difference - 1);
-}

package/src/style-spec/util/color.js

@@ -1,73 +0,0 @@
-const { parseCSSColor } = require('csscolorparser');
-
-/**
- * An RGBA color value. Create instances from color strings using the static
- * method `Color.parse`. The constructor accepts RGB channel values in the range
- * `[0, 1]`, premultiplied by A.
- *
- * @param {number} r The red channel.
- * @param {number} g The green channel.
- * @param {number} b The blue channel.
- * @param {number} a The alpha channel.
- * @private
- */
-class Color {
-  constructor(r, g, b, a = 1) {
-    this.r = r;
-    this.g = g;
-    this.b = b;
-    this.a = a;
-  }
-
-  /**
-   * Parses valid CSS color strings and returns a `Color` instance.
-   * @returns A `Color` instance, or `undefined` if the input is not a valid color string.
-   */
-  static parse(input) {
-    if (!input) {
-      return undefined;
-    }
-
-    if (input instanceof Color) {
-      return input;
-    }
-
-    if (typeof input !== 'string') {
-      return undefined;
-    }
-
-    const rgba = parseCSSColor(input);
-    if (!rgba) {
-      return undefined;
-    }
-
-    return new Color((rgba[0] / 255) * rgba[3], (rgba[1] / 255) * rgba[3], (rgba[2] / 255) * rgba[3], rgba[3]);
-  }
-
-  /**
-   * Returns an RGBA string representing the color value.
-   *
-   * @returns An RGBA string.
-   * @example
-   * var purple = new Color.parse('purple');
-   * purple.toString; // = "rgba(128,0,128,1)"
-   * var translucentGreen = new Color.parse('rgba(26, 207, 26, .73)');
-   * translucentGreen.toString(); // = "rgba(26,207,26,0.73)"
-   */
-  toString() {
-    const [r, g, b, a] = this.toArray();
-    return `rgba(${Math.round(r)},${Math.round(g)},${Math.round(b)},${a})`;
-  }
-
-  toArray() {
-    const { r, g, b, a } = this;
-    return a === 0 ? [0, 0, 0, 0] : [(r * 255) / a, (g * 255) / a, (b * 255) / a, a];
-  }
-}
-
-Color.black = new Color(0, 0, 0, 1);
-Color.white = new Color(1, 1, 1, 1);
-Color.transparent = new Color(0, 0, 0, 0);
-Color.red = new Color(1, 0, 0, 1);
-
-module.exports = Color;

package/src/style-spec/util/color_spaces.js

@@ -1,128 +0,0 @@
-const Color = require('./color');
-
-const { number: interpolateNumber } = require('./interpolate');
-
-// Constants
-const Xn = 0.95047; // D65 standard referent
-const Yn = 1;
-const Zn = 1.08883;
-const t0 = 4 / 29;
-const t1 = 6 / 29;
-const t2 = 3 * t1 * t1;
-const t3 = t1 * t1 * t1;
-const deg2rad = Math.PI / 180;
-const rad2deg = 180 / Math.PI;
-
-// Utilities
-function xyz2lab(t) {
-  return t > t3 ? t ** (1 / 3) : t / t2 + t0;
-}
-
-function lab2xyz(t) {
-  return t > t1 ? t * t * t : t2 * (t - t0);
-}
-
-function xyz2rgb(x) {
-  return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * x ** (1 / 2.4) - 0.055);
-}
-
-function rgb2xyz(x) {
-  x /= 255;
-  return x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
-}
-
-// LAB
-function rgbToLab(rgbColor) {
-  const b = rgb2xyz(rgbColor.r);
-  const a = rgb2xyz(rgbColor.g);
-  const l = rgb2xyz(rgbColor.b);
-  const x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn);
-  const y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.072175 * l) / Yn);
-  const z = xyz2lab((0.0193339 * b + 0.119192 * a + 0.9503041 * l) / Zn);
-
-  return {
-    l: 116 * y - 16,
-    a: 500 * (x - y),
-    b: 200 * (y - z),
-    alpha: rgbColor.a
-  };
-}
-
-function labToRgb(labColor) {
-  let y = (labColor.l + 16) / 116;
-  let x = isNaN(labColor.a) ? y : y + labColor.a / 500;
-  let z = isNaN(labColor.b) ? y : y - labColor.b / 200;
-  y = Yn * lab2xyz(y);
-  x = Xn * lab2xyz(x);
-  z = Zn * lab2xyz(z);
-  return new Color(
-    xyz2rgb(3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB
-    xyz2rgb(-0.969266 * x + 1.8760108 * y + 0.041556 * z),
-    xyz2rgb(0.0556434 * x - 0.2040259 * y + 1.0572252 * z),
-    labColor.alpha
-  );
-}
-
-function interpolateLab(from, to, t) {
-  return {
-    l: interpolateNumber(from.l, to.l, t),
-    a: interpolateNumber(from.a, to.a, t),
-    b: interpolateNumber(from.b, to.b, t),
-    alpha: interpolateNumber(from.alpha, to.alpha, t)
-  };
-}
-
-// HCL
-function rgbToHcl(rgbColor) {
-  const { l, a, b } = rgbToLab(rgbColor);
-  const h = Math.atan2(b, a) * rad2deg;
-  return {
-    h: h < 0 ? h + 360 : h,
-    c: Math.sqrt(a * a + b * b),
-    l: l,
-    alpha: rgbColor.a
-  };
-}
-
-function hclToRgb(hclColor) {
-  const h = hclColor.h * deg2rad;
-  const c = hclColor.c;
-  const l = hclColor.l;
-  return labToRgb({
-    l: l,
-    a: Math.cos(h) * c,
-    b: Math.sin(h) * c,
-    alpha: hclColor.alpha
-  });
-}
-
-function interpolateHue(a, b, t) {
-  const d = b - a;
-  return a + t * (d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d);
-}
-
-function interpolateHcl(from, to, t) {
-  return {
-    h: interpolateHue(from.h, to.h, t),
-    c: interpolateNumber(from.c, to.c, t),
-    l: interpolateNumber(from.l, to.l, t),
-    alpha: interpolateNumber(from.alpha, to.alpha, t)
-  };
-}
-
-const lab = {
-  forward: rgbToLab,
-  reverse: labToRgb,
-  interpolate: interpolateLab
-};
-
-const hcl = {
-  forward: rgbToHcl,
-  reverse: hclToRgb,
-  interpolate: interpolateHcl
-};
-
-module.exports = {
-  lab,
-  hcl
-};

package/src/style-spec/util/get_type.js

@@ -1,18 +0,0 @@
-module.exports = function getType(val) {
-  if (val instanceof Number) {
-    return 'number';
-  }
-  if (val instanceof String) {
-    return 'string';
-  }
-  if (val instanceof Boolean) {
-    return 'boolean';
-  }
-  if (Array.isArray(val)) {
-    return 'array';
-  }
-  if (val === null) {
-    return 'null';
-  }
-  return typeof val;
-};

package/src/style-spec/util/interpolate.js

@@ -1,21 +0,0 @@
-const Color = require('./color');
-
-function number(a, b, t) {
-  return a * (1 - t) + b * t;
-}
-
-function color(from, to, t) {
-  return new Color(number(from.r, to.r, t), number(from.g, to.g, t), number(from.b, to.b, t), number(from.a, to.a, t));
-}
-
-function array(from, to, t) {
-  return from.map((d, i) => {
-    return number(d, to[i], t);
-  });
-}
-
-module.exports = {
-  number,
-  color,
-  array
-};

package/src/style-spec/util/properties.js

@@ -1,17 +0,0 @@
-function supportsPropertyExpression({ ['property-type']: propertyType }) {
-  return propertyType === 'data-driven' || propertyType === 'cross-faded-data-driven';
-}
-
-function supportsZoomExpression(spec) {
-  return !!spec.expression?.parameters.includes('zoom');
-}
-
-function supportsInterpolation(spec) {
-  return !!spec.expression?.interpolated;
-}
-
-module.exports = {
-  supportsPropertyExpression,
-  supportsZoomExpression,
-  supportsInterpolation
-};

package/src/style-spec/util/result.js

@@ -1,19 +0,0 @@
-/**
- * A type used for returning and propagating errors. The first element of the union
- * represents success and contains a value, and the second represents an error and
- * contains an error value.
- * @private
- */
-
-function success(value) {
-  return { result: 'success', value };
-}
-
-function error(value) {
-  return { result: 'error', value };
-}
-
-module.exports = {
-  success,
-  error
-};

package/src/ui/anchor.js

@@ -1,24 +0,0 @@
-const anchorTranslate = {
-  center: 'translate(-50%,-50%)',
-  top: 'translate(-50%,0)',
-  'top-left': 'translate(0,0)',
-  'top-right': 'translate(-100%,0)',
-  bottom: 'translate(-50%,-100%)',
-  'bottom-left': 'translate(0,-100%)',
-  'bottom-right': 'translate(-100%,-100%)',
-  left: 'translate(0,-50%)',
-  right: 'translate(-100%,-50%)'
-};
-
-function applyAnchorClass(element, anchor, prefix) {
-  const classList = element.classList;
-  for (const key in anchorTranslate) {
-    classList.remove(`mapboxgl-${prefix}-anchor-${key}`);
-  }
-  classList.add(`mapboxgl-${prefix}-anchor-${anchor}`);
-}
-
-module.exports = {
-  anchorTranslate,
-  applyAnchorClass
-};