mapbox-gl 1.13.2

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

@@ -0,0 +1,208 @@
+// @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

@@ -0,0 +1,175 @@
+// @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 = geometryNeeded(filter);
+        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 geometryNeeded(filter) {
+    if (!Array.isArray(filter)) return false;
+    if (filter[0] === 'within') return true;
+    for (let index = 1; index < filter.length; index++) {
+        if (geometryNeeded(filter[index])) return true;
+    }
+    return false;
+}
+
+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])) :
+        op === 'within' ? filter :
+        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

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