@mapgis/mapbox-gl 16.0.1 → 16.2.0

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

@@ -1,123 +0,0 @@
-// @flow
-
-import assert from 'assert';
-
-import Color from '../util/color';
-import Collator from './types/collator';
-import Formatted from './types/formatted';
-import ResolvedImage from './types/resolved_image';
-import {NullType, NumberType, StringType, BooleanType, ColorType, ObjectType, ValueType, CollatorType, FormattedType, ResolvedImageType, array} from './types';
-
-import type {Type} from './types';
-
-export function validateRGBA(r: mixed, g: mixed, b: mixed, a?: mixed): string | null {
-    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;
-}
-
-export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | $ReadOnlyArray<Value> | { +[string]: Value }
-
-export function isValue(mixed: mixed): boolean {
-    if (mixed === null) {
-        return true;
-    } else if (typeof mixed === 'string') {
-        return true;
-    } else if (typeof mixed === 'boolean') {
-        return true;
-    } else if (typeof mixed === 'number') {
-        return true;
-    } else if (mixed instanceof Color) {
-        return true;
-    } else if (mixed instanceof Collator) {
-        return true;
-    } else if (mixed instanceof Formatted) {
-        return true;
-    } else if (mixed instanceof ResolvedImage) {
-        return true;
-    } else if (Array.isArray(mixed)) {
-        for (const item of mixed) {
-            if (!isValue(item)) {
-                return false;
-            }
-        }
-        return true;
-    } else if (typeof mixed === 'object') {
-        for (const key in mixed) {
-            if (!isValue(mixed[key])) {
-                return false;
-            }
-        }
-        return true;
-    } else {
-        return false;
-    }
-}
-
-export function typeOf(value: Value): Type {
-    if (value === null) {
-        return NullType;
-    } else if (typeof value === 'string') {
-        return StringType;
-    } else if (typeof value === 'boolean') {
-        return BooleanType;
-    } else if (typeof value === 'number') {
-        return NumberType;
-    } else if (value instanceof Color) {
-        return ColorType;
-    } else if (value instanceof Collator) {
-        return CollatorType;
-    } else if (value instanceof Formatted) {
-        return FormattedType;
-    } else if (value instanceof ResolvedImage) {
-        return ResolvedImageType;
-    } else if (Array.isArray(value)) {
-        const length = value.length;
-        let itemType: Type | typeof undefined;
-
-        for (const item of value) {
-            const t = typeOf(item);
-            if (!itemType) {
-                itemType = t;
-            } else if (itemType === t) {
-                continue;
-            } else {
-                itemType = ValueType;
-                break;
-            }
-        }
-
-        return array(itemType || ValueType, length);
-    } else {
-        assert(typeof value === 'object');
-        return ObjectType;
-    }
-}
-
-export function toString(value: Value) {
-    const type = typeof value;
-    if (value === null) {
-        return '';
-    } else if (type === 'string' || type === 'number' || type === 'boolean') {
-        return String(value);
-    } else if (value instanceof Color || value instanceof Formatted || value instanceof ResolvedImage) {
-        return value.toString();
-    } else {
-        return JSON.stringify(value);
-    }
-}
-
-export {Color, Collator};

package/src/style-spec/feature_filter/README.md

@@ -1,55 +0,0 @@
-## Filter
-
-Filter expressions are used to target specific data in a layer. This library implements the semantics specified by the [Mapbox GL JS spec](https://www.mapbox.com/mapbox-gl-style-spec/#filter).
-
-### API
-
-`featureFilter(filter)`
-
-Given a filter expressed as nested arrays, return a new function
-that evaluates whether a given feature (with a .properties or .tags property)
-passes its test.
-
-#### Parameters
-
-| parameter | type  | description      |
-| --------- | ----- | ---------------- |
-| `filter`  | Array | mapbox gl filter |
-
-**Returns** `Function`, filter-evaluating function
-
-### Usage
-
-``` javascript
-var ff = require('@mapbox/mapbox-gl-style-spec').featureFilter;
-
-// will match a feature with class of street_limited,
-// AND an admin_level less than or equal to 3,
-// that's NOT a polygon.
-var filter = [
-    "all",
-    ["==", "class", "street_limited"],
-    ["<=", "admin_level", 3],
-    ["!=", "$type", "Polygon"]
-]
-
-// will match a feature that has a class of
-// wetland OR wetland_noveg.
-// ["in", "class", "wetland", "wetland_noveg"]
-
-// testFilter will be a function that returns a boolean
-var testFilter = ff(filter);
-
-// Layer feature that you're testing. Must have type
-// and properties keys.
-var feature = {
-    type: 2,
-    properties: {
-       class: "street_limited",
-       admin_level: 1
-    }
-};
-
-// will return a boolean based on whether the feature matched the filter
-return testFilter({zoom: 0}, feature);
-```

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

@@ -1,208 +0,0 @@
-// @flow
-
-import {isExpressionFilter} from './index';
-
-import type {FilterSpecification} from '../types';
-
-type ExpectedTypes = {[_: string]: 'string' | 'number' | 'boolean'};
-
-/**
- * Convert the given legacy filter to (the JSON representation of) an
- * equivalent expression
- * @private
- */
-export default function convertFilter(filter: FilterSpecification): mixed {
-    return _convertFilter(filter, {});
-}
-
-/*
- * Convert the given filter to an expression, storing the expected types for
- * any feature properties referenced in expectedTypes.
- *
- * These expected types are needed in order to construct preflight type checks
- * needed for handling 'any' filters. A preflight type check is necessary in
- * order to mimic legacy filters' semantics around expected type mismatches.
- * For example, consider the legacy filter:
- *
- *     ["any", ["all", [">", "y", 0], [">", "y", 0]], [">", "x", 0]]
- *
- * Naively, we might convert this to the expression:
- *
- *     ["any", ["all", [">", ["get", "y"], 0], [">", ["get", "z"], 0]], [">", ["get", "x"], 0]]
- *
- * But if we tried to evaluate this against, say `{x: 1, y: null, z: 0}`, the
- * [">", ["get", "y"], 0] would cause an evaluation error, leading to the
- * entire filter returning false. Legacy filter semantics, though, ask for
- * [">", "y", 0] to simply return `false` when `y` is of the wrong type,
- * allowing the subsequent terms of the outer "any" expression to be evaluated
- * (resulting, in this case, in a `true` value, because x > 0).
- *
- * We account for this by inserting a preflight type-checking expression before
- * each "any" term, allowing us to avoid evaluating the actual converted filter
- * if any type mismatches would cause it to produce an evalaution error:
- *
- *     ["any",
- *       ["case",
- *         ["all", ["==", ["typeof", ["get", "y"]], "number"], ["==", ["typeof", ["get", "z"], "number]],
- *         ["all", [">", ["get", "y"], 0], [">", ["get", "z"], 0]],
- *         false
- *       ],
- *       ["case",
- *         ["==", ["typeof", ["get", "x"], "number"]],
- *         [">", ["get", "x"], 0],
- *         false
- *       ]
- *     ]
- *
- * An alternative, possibly more direct approach would be to use type checks
- * in the conversion of each comparison operator, so that the converted version
- * of each individual ==, >=, etc. would mimic the legacy filter semantics. The
- * downside of this approach is that it can lead to many more type checks than
- * would otherwise be necessary: outside the context of an "any" expression,
- * bailing out due to a runtime type error (expression semantics) and returning
- * false (legacy filter semantics) are equivalent: they cause the filter to
- * produce a `false` result.
- */
-function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedTypes): mixed {
-    if (isExpressionFilter(filter)) { return filter; }
-
-    if (!filter) return true;
-    const op = filter[0];
-    if (filter.length <= 1) return (op !== 'any');
-
-    let converted;
-
-    if (
-        op === '==' ||
-        op === '!=' ||
-        op === '<' ||
-        op === '>' ||
-        op === '<=' ||
-        op === '>='
-    ) {
-        const [, property, value] = (filter: any);
-        converted = convertComparisonOp(property, value, op, expectedTypes);
-    } else if (op === 'any') {
-        const children = (filter: any).slice(1).map(f => {
-            const types = {};
-            const child = _convertFilter(f, types);
-            const typechecks = runtimeTypeChecks(types);
-            return typechecks === true ? child : ['case', typechecks, child, false];
-        });
-        return ['any'].concat(children);
-    } else if (op === 'all') {
-        const children = (filter: any).slice(1).map(f => _convertFilter(f, expectedTypes));
-        return children.length > 1 ? ['all'].concat(children) : [].concat(...children);
-    } else if (op === 'none') {
-        return ['!', _convertFilter(['any'].concat(filter.slice(1)), {})];
-    } else if (op === 'in') {
-        converted = convertInOp((filter[1]: any), filter.slice(2));
-    } else if (op === '!in') {
-        converted = convertInOp((filter[1]: any), filter.slice(2), true);
-    } else if (op === 'has') {
-        converted = convertHasOp((filter[1]: any));
-    } else if (op === '!has') {
-        converted = ['!', convertHasOp((filter[1]: any))];
-    } else {
-        converted = true;
-    }
-
-    return converted;
-}
-
-// Given a set of feature properties and an expected type for each one,
-// construct an boolean expression that tests whether each property has the
-// right type.
-// E.g.: for {name: 'string', population: 'number'}, return
-// [ 'all',
-//   ['==', ['typeof', ['get', 'name'], 'string']],
-//   ['==', ['typeof', ['get', 'population'], 'number]]
-// ]
-function runtimeTypeChecks(expectedTypes: ExpectedTypes) {
-    const conditions = [];
-    for (const property in expectedTypes) {
-        const get = property === '$id' ? ['id'] : ['get', property];
-        conditions.push(['==', ['typeof', get], expectedTypes[property]]);
-    }
-    if (conditions.length === 0) return true;
-    if (conditions.length === 1) return conditions[0];
-    return ['all'].concat(conditions);
-}
-
-function convertComparisonOp(property: string, value: any, op: string, expectedTypes: ?ExpectedTypes) {
-    let get;
-    if (property === '$type') {
-        return [op, ['geometry-type'], value];
-    } else if (property === '$id') {
-        get = ['id'];
-    } else {
-        get = ['get', property];
-    }
-
-    if (expectedTypes && value !== null) {
-        const type = ((typeof value): any);
-        expectedTypes[property] = type;
-    }
-
-    if (op === '==' && property !== '$id' && value === null) {
-        return [
-            'all',
-            ['has', property], // missing property != null for legacy filters
-            ['==', get, null]
-        ];
-    } else if (op === '!=' && property !== '$id' && value === null) {
-        return [
-            'any',
-            ['!', ['has', property]], // missing property != null for legacy filters
-            ['!=', get, null]
-        ];
-    }
-
-    return [op, get, value];
-}
-
-function convertInOp(property: string, values: Array<any>, negate = false) {
-    if (values.length === 0) return negate;
-
-    let get;
-    if (property === '$type') {
-        get = ['geometry-type'];
-    } else if (property === '$id') {
-        get = ['id'];
-    } else {
-        get = ['get', property];
-    }
-
-    // Determine if the list of values to be searched is homogenously typed.
-    // If so (and if the type is string or number), then we can use a
-    // [match, input, [...values], true, false] construction rather than a
-    // bunch of `==` tests.
-    let uniformTypes = true;
-    const type = typeof values[0];
-    for (const value of values) {
-        if (typeof value !== type) {
-            uniformTypes = false;
-            break;
-        }
-    }
-
-    if (uniformTypes && (type === 'string' || type === 'number')) {
-        // Match expressions must have unique values.
-        const uniqueValues = values.sort().filter((v, i) => i === 0 || values[i - 1] !== v);
-        return ['match', get, uniqueValues, !negate, negate];
-    }
-
-    return [ negate ? 'all' : 'any' ].concat(
-        values.map(v => [negate ? '!=' : '==', get, v])
-    );
-}
-
-function convertHasOp(property: string) {
-    if (property === '$type') {
-        return true;
-    } else if (property === '$id') {
-        return ['!=', ['id'], null];
-    } else {
-        return ['has', property];
-    }
-}

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

@@ -1,165 +0,0 @@
-// @flow
-
-import {createExpression} from '../expression';
-import type {GlobalProperties, Feature} from '../expression';
-import type {CanonicalTileID} from '../../source/tile_id';
-
-type FilterExpression = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => boolean;
-export type FeatureFilter ={filter: FilterExpression, needGeometry: boolean};
-
-export default createFilter;
-export {isExpressionFilter};
-
-function isExpressionFilter(filter: any) {
-    if (filter === true || filter === false) {
-        return true;
-    }
-
-    if (!Array.isArray(filter) || filter.length === 0) {
-        return false;
-    }
-    switch (filter[0]) {
-    case 'has':
-        return filter.length >= 2 && filter[1] !== '$id' && filter[1] !== '$type';
-
-    case 'in':
-        return filter.length >= 3 && (typeof filter[1] !== 'string' || Array.isArray(filter[2]));
-
-    case '!in':
-    case '!has':
-    case 'none':
-        return false;
-
-    case '==':
-    case '!=':
-    case '>':
-    case '>=':
-    case '<':
-    case '<=':
-        return filter.length !== 3 || (Array.isArray(filter[1]) || Array.isArray(filter[2]));
-
-    case 'any':
-    case 'all':
-        for (const f of filter.slice(1)) {
-            if (!isExpressionFilter(f) && typeof f !== 'boolean') {
-                return false;
-            }
-        }
-        return true;
-
-    default:
-        return true;
-    }
-}
-
-const filterSpec = {
-    'type': 'boolean',
-    'default': false,
-    'transition': false,
-    'property-type': 'data-driven',
-    'expression': {
-        'interpolated': false,
-        'parameters': ['zoom', 'feature']
-    }
-};
-
-/**
- * Given a filter expressed as nested arrays, return a new function
- * that evaluates whether a given feature (with a .properties or .tags property)
- * passes its test.
- *
- * @private
- * @param {Array} filter mapbox gl filter
- * @returns {Function} filter-evaluating function
- */
-function createFilter(filter: any): FeatureFilter {
-    if (filter === null || filter === undefined) {
-        return {filter: () => true, needGeometry: false};
-    }
-
-    if (!isExpressionFilter(filter)) {
-        filter = convertFilter(filter);
-    }
-
-    const compiled = createExpression(filter, filterSpec);
-    if (compiled.result === 'error') {
-        throw new Error(compiled.value.map(err => `${err.key}: ${err.message}`).join(', '));
-    } else {
-        const needGeometry = Array.isArray(filter) && filter.length !== 0 && filter[0] === 'within';
-        return {filter: (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID) => compiled.value.evaluate(globalProperties, feature, {}, canonical),
-            needGeometry};
-    }
-}
-
-// Comparison function to sort numbers and strings
-function compare(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-
-function convertFilter(filter: ?Array<any>): mixed {
-    if (!filter) return true;
-    const op = filter[0];
-    if (filter.length <= 1) return (op !== 'any');
-    const converted =
-        op === '==' ? convertComparisonOp(filter[1], filter[2], '==') :
-        op === '!=' ? convertNegation(convertComparisonOp(filter[1], filter[2], '==')) :
-        op === '<' ||
-        op === '>' ||
-        op === '<=' ||
-        op === '>=' ? convertComparisonOp(filter[1], filter[2], op) :
-        op === 'any' ? convertDisjunctionOp(filter.slice(1)) :
-        op === 'all' ? ['all'].concat(filter.slice(1).map(convertFilter)) :
-        op === 'none' ? ['all'].concat(filter.slice(1).map(convertFilter).map(convertNegation)) :
-        op === 'in' ? convertInOp(filter[1], filter.slice(2)) :
-        op === '!in' ? convertNegation(convertInOp(filter[1], filter.slice(2))) :
-        op === 'has' ? convertHasOp(filter[1]) :
-        op === '!has' ? convertNegation(convertHasOp(filter[1])) :
-        true;
-    return converted;
-}
-
-function convertComparisonOp(property: string, value: any, op: string) {
-    switch (property) {
-    case '$type':
-        return [`filter-type-${op}`, value];
-    case '$id':
-        return [`filter-id-${op}`, value];
-    default:
-        return [`filter-${op}`, property, value];
-    }
-}
-
-function convertDisjunctionOp(filters: Array<Array<any>>) {
-    return ['any'].concat(filters.map(convertFilter));
-}
-
-function convertInOp(property: string, values: Array<any>) {
-    if (values.length === 0) { return false; }
-    switch (property) {
-    case '$type':
-        return [`filter-type-in`, ['literal', values]];
-    case '$id':
-        return [`filter-id-in`, ['literal', values]];
-    default:
-        if (values.length > 200 && !values.some(v => typeof v !== typeof values[0])) {
-            return ['filter-in-large', property, ['literal', values.sort(compare)]];
-        } else {
-            return ['filter-in-small', property, ['literal', values]];
-        }
-    }
-}
-
-function convertHasOp(property: string) {
-    switch (property) {
-    case '$type':
-        return true;
-    case '$id':
-        return [`filter-has-id`];
-    default:
-        return [`filter-has`, property];
-    }
-}
-
-function convertNegation(filter: mixed) {
-    return ['!', filter];
-}

package/src/style-spec/format.js

@@ -1,51 +0,0 @@
-
-import reference from './reference/latest.js';
-import stringifyPretty from 'json-stringify-pretty-compact';
-
-function sortKeysBy(obj, reference) {
-    const result = {};
-    for (const key in reference) {
-        if (obj[key] !== undefined) {
-            result[key] = obj[key];
-        }
-    }
-    for (const key in obj) {
-        if (result[key] === undefined) {
-            result[key] = obj[key];
-        }
-    }
-    return result;
-}
-
-/**
- * Format a Mapbox GL Style.  Returns a stringified style with its keys
- * sorted in the same order as the reference style.
- *
- * The optional `space` argument is passed to
- * [`JSON.stringify`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify)
- * to generate formatted output.
- *
- * If `space` is unspecified, a default of `2` spaces will be used.
- *
- * @private
- * @param {Object} style a Mapbox GL Style
- * @param {number} [space] space argument to pass to `JSON.stringify`
- * @returns {string} stringified formatted JSON
- * @example
- * var fs = require('fs');
- * var format = require('mapbox-gl-style-spec').format;
- * var style = fs.readFileSync('./source.json', 'utf8');
- * fs.writeFileSync('./dest.json', format(style));
- * fs.writeFileSync('./dest.min.json', format(style, 0));
- */
-function format(style, space = 2) {
-    style = sortKeysBy(style, reference.$root);
-
-    if (style.layers) {
-        style.layers = style.layers.map((layer) => sortKeysBy(layer, reference.layer));
-    }
-
-    return stringifyPretty(style, {indent: space});
-}
-
-export default format;