@mapbox/mapbox-gl-style-spec 14.4.0 → 14.5.0

package/function/{convert.js → convert.ts}

@@ -1,26 +1,18 @@
-// @flow
-
 import assert from 'assert';
 
-import type {StylePropertySpecification} from '../style-spec.js';
-import type {ExpressionSpecification} from '../types.js';
-
-type Stop = [{zoom: number, value: string | number | boolean}, mixed];
-
-type FunctionParameters = {
-    stops: Array<Stop>;
-    base: number;
-    property: string;
-    type: 'identity' | 'exponential' | 'interval' | 'categorical';
-    colorSpace: 'rgb' | 'lab' | 'hcl';
-    default: mixed;
-};
+import type {StylePropertySpecification} from '../style-spec';
+import type {
+    FunctionSpecification,
+    PropertyFunctionStop,
+    ZoomAndPropertyFunctionStop,
+    ExpressionSpecification,
+} from '../types';
 
-function convertLiteral(value: mixed) {
+function convertLiteral(value: unknown) {
     return typeof value === 'object' ? ['literal', value] : value;
 }
 
-export default function convertFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification): ExpressionSpecification {
+export default function convertFunction<T>(parameters: FunctionSpecification<T>, propertySpec: StylePropertySpecification): ExpressionSpecification {
     let stops = parameters.stops;
     if (!stops) {
         // identity function
@@ -36,19 +28,19 @@ export default function convertFunction(parameters: FunctionParameters, property
             return [stop[0], convertTokenString(stop[1])];
         }
         return [stop[0], convertLiteral(stop[1])];
-    });
+    }) as FunctionSpecification<T>['stops'];
 
     if (zoomAndFeatureDependent) {
-        return convertZoomAndPropertyFunction(parameters, propertySpec, stops);
+        return convertZoomAndPropertyFunction(parameters, propertySpec, stops as Array<ZoomAndPropertyFunctionStop<T>>);
     } else if (zoomDependent) {
-        return convertZoomFunction(parameters, propertySpec, stops);
+        return convertZoomFunction(parameters, propertySpec, stops as PropertyFunctionStop<T>[]);
     } else {
-        return convertPropertyFunction(parameters, propertySpec, stops);
+        return convertPropertyFunction(parameters, propertySpec, stops as PropertyFunctionStop<T>[]);
     }
 }
 
-function convertIdentityFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification): Array<mixed> {
-    const get = ['get', parameters.property];
+function convertIdentityFunction<T>(parameters: FunctionSpecification<T>, propertySpec: StylePropertySpecification): ExpressionSpecification {
+    const get: ExpressionSpecification = ['get', parameters.property];
 
     if (parameters.default === undefined) {
         // By default, expressions for string-valued properties get coerced. To preserve
@@ -63,7 +55,7 @@ function convertIdentityFunction(parameters: FunctionParameters, propertySpec: S
             parameters.default
         ];
     } else {
-        const expression = [propertySpec.type === 'color' ? 'to-color' : propertySpec.type, get, convertLiteral(parameters.default)];
+        const expression: ExpressionSpecification = [propertySpec.type === 'color' ? 'to-color' : propertySpec.type, get, convertLiteral(parameters.default)];
         if (propertySpec.type === 'array') {
             expression.splice(1, 0, propertySpec.value, propertySpec.length || null);
         }
@@ -71,7 +63,7 @@ function convertIdentityFunction(parameters: FunctionParameters, propertySpec: S
     }
 }
 
-function getInterpolateOperator(parameters: FunctionParameters) {
+function getInterpolateOperator<T>(parameters: FunctionSpecification<T>) {
     switch (parameters.colorSpace) {
     case 'hcl': return 'interpolate-hcl';
     case 'lab': return 'interpolate-lab';
@@ -79,9 +71,13 @@ function getInterpolateOperator(parameters: FunctionParameters) {
     }
 }
 
-function convertZoomAndPropertyFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification, stops: Array<Stop>) {
-    const featureFunctionParameters = {};
-    const featureFunctionStops = {};
+function convertZoomAndPropertyFunction<T>(
+    parameters: FunctionSpecification<T>,
+    propertySpec: StylePropertySpecification,
+    stops: Array<ZoomAndPropertyFunctionStop<T>>,
+): ExpressionSpecification {
+    const featureFunctionParameters: Record<string, any> = {};
+    const featureFunctionStops: Record<string, any> = {};
     const zoomStops = [];
     for (let s = 0; s < stops.length; s++) {
         const stop = stops[s];
@@ -103,9 +99,9 @@ function convertZoomAndPropertyFunction(parameters: FunctionParameters, 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);
+    const functionType = getFunctionType({} as FunctionSpecification<unknown>, propertySpec);
     if (functionType === 'exponential') {
-        const expression = [getInterpolateOperator(parameters), ['linear'], ['zoom']];
+        const expression: ExpressionSpecification = [getInterpolateOperator(parameters), ['linear'], ['zoom']];
 
         for (const z of zoomStops) {
             const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
@@ -114,7 +110,7 @@ function convertZoomAndPropertyFunction(parameters: FunctionParameters, property
 
         return expression;
     } else {
-        const expression = ['step', ['zoom']];
+        const expression: ExpressionSpecification = ['step', ['zoom']];
 
         for (const z of zoomStops) {
             const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
@@ -127,12 +123,12 @@ function convertZoomAndPropertyFunction(parameters: FunctionParameters, property
     }
 }
 
-function coalesce(a: mixed, b: mixed) {
+function coalesce(a: unknown, b: unknown) {
     if (a !== undefined) return a;
     if (b !== undefined) return b;
 }
 
-function getFallback(parameters: FunctionParameters, propertySpec: StylePropertySpecification) {
+function getFallback<T>(parameters: FunctionSpecification<T>, propertySpec: StylePropertySpecification) {
     const defaultValue = convertLiteral(coalesce(parameters.default, propertySpec.default));
 
     /*
@@ -147,12 +143,16 @@ function getFallback(parameters: FunctionParameters, propertySpec: StyleProperty
     return defaultValue;
 }
 
-function convertPropertyFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification, stops: Array<Stop>) {
+function convertPropertyFunction<T>(
+    parameters: FunctionSpecification<T>,
+    propertySpec: StylePropertySpecification,
+    stops: Array<PropertyFunctionStop<T>>,
+): ExpressionSpecification {
     const type = getFunctionType(parameters, propertySpec);
-    const get = ['get', parameters.property];
+    const get: ExpressionSpecification = ['get', parameters.property];
     if (type === 'categorical' && typeof stops[0][0] === 'boolean') {
         assert(parameters.stops.length > 0 && parameters.stops.length <= 2);
-        const expression = ['case'];
+        const expression: ExpressionSpecification = ['case'];
         for (const stop of stops) {
             expression.push(['==', get, stop[0]], stop[1]);
         }
@@ -160,14 +160,14 @@ function convertPropertyFunction(parameters: FunctionParameters, propertySpec: S
         expression.push(getFallback(parameters, propertySpec));
         return expression;
     } else if (type === 'categorical') {
-        const expression = ['match', get];
+        const expression: ExpressionSpecification = ['match', get];
         for (const stop of stops) {
             appendStopPair(expression, stop[0], stop[1], false);
         }
         expression.push(getFallback(parameters, propertySpec));
         return expression;
     } else if (type === 'interval') {
-        const expression = ['step', ['number', get]];
+        const expression: ExpressionSpecification = ['step', ['number', get]];
         for (const stop of stops) {
             appendStopPair(expression, stop[0], stop[1], true);
         }
@@ -180,7 +180,7 @@ function convertPropertyFunction(parameters: FunctionParameters, propertySpec: S
         ];
     } else if (type === 'exponential') {
         const base = parameters.base !== undefined ? parameters.base : 1;
-        const expression = [
+        const expression: ExpressionSpecification = [
             getInterpolateOperator(parameters),
             base === 1 ? ["linear"] : ["exponential", base],
             ["number", get]
@@ -200,7 +200,7 @@ function convertPropertyFunction(parameters: FunctionParameters, propertySpec: S
     }
 }
 
-function convertZoomFunction(parameters: FunctionParameters, propertySpec: StylePropertySpecification, stops: Array<Stop>, input: Array<string> = ['zoom']) {
+function convertZoomFunction<T>(parameters: FunctionSpecification<T>, propertySpec: StylePropertySpecification, stops: Array<PropertyFunctionStop<T>>, input: Array<string> = ['zoom']) {
     const type = getFunctionType(parameters, propertySpec);
     let expression;
     let isStep = false;
@@ -232,7 +232,7 @@ function fixupDegenerateStepCurve(expression: ExpressionSpecification) {
     }
 }
 
-function appendStopPair(curve: ExpressionSpecification, input: mixed, output: mixed, isStep: boolean) {
+function appendStopPair(curve: ExpressionSpecification, input: unknown, output: unknown, isStep: boolean) {
     // 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]) {
@@ -245,18 +245,18 @@ function appendStopPair(curve: ExpressionSpecification, input: mixed, output: mi
     curve.push(output);
 }
 
-function getFunctionType(parameters: FunctionParameters, propertySpec: StylePropertySpecification): string {
+function getFunctionType<T>(parameters: FunctionSpecification<T>, propertySpec: StylePropertySpecification): string {
     if (parameters.type) {
         return parameters.type;
     } else {
         assert(propertySpec.expression);
-        return (propertySpec.expression: any).interpolated ? 'exponential' : 'interval';
+        return (propertySpec.expression as any).interpolated ? 'exponential' : 'interval';
     }
 }
 
 // "String with {name} token" => ["concat", "String with ", ["get", "name"], " token"]
 export function convertTokenString(s: string): string | ExpressionSpecification {
-    const result = ['concat'];
+    const result: ExpressionSpecification = ['concat'];
     const re = /{([^{}]+)}/g;
     let pos = 0;
     for (let match = re.exec(s); match !== null; match = re.exec(s)) {

package/function/{index.js → index.ts}

@@ -1,15 +1,15 @@
-// @noflow
+// @ts-nocheck
 
-import * as colorSpaces from '../util/color_spaces.js';
-import Color from '../util/color.js';
-import extend from '../util/extend.js';
-import getType from '../util/get_type.js';
-import * as interpolate from '../util/interpolate.js';
-import Interpolate from '../expression/definitions/interpolate.js';
-import Formatted from '../expression/types/formatted.js';
-import ResolvedImage from '../expression/types/resolved_image.js';
-import {supportsInterpolation} from '../util/properties.js';
-import {findStopLessThanOrEqualTo} from '../expression/stops.js';
+import * as colorSpaces from '../util/color_spaces';
+import Color from '../util/color';
+import extend from '../util/extend';
+import getType from '../util/get_type';
+import * as interpolate from '../util/interpolate';
+import Interpolate from '../expression/definitions/interpolate';
+import Formatted from '../expression/types/formatted';
+import ResolvedImage from '../expression/types/resolved_image';
+import {supportsInterpolation} from '../util/properties';
+import {findStopLessThanOrEqualTo} from '../expression/stops';
 
 export function isFunction(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -72,7 +72,7 @@ export function createFunction(parameters, propertySpec) {
     }
 
     if (zoomAndFeatureDependent) {
-        const featureFunctions = {};
+        const featureFunctions: Record<string, any> = {};
         const zoomStops = [];
         for (let s = 0; s < parameters.stops.length; s++) {
             const stop = parameters.stops[s];

package/{group_by_layout.js → group_by_layout.ts}

@@ -1,8 +1,6 @@
-// @flow
+import type {LayerSpecification} from './types';
 
-import type {LayerSpecification} from './types.js';
-
-import refProperties from './util/ref_properties.js';
+import refProperties from './util/ref_properties';
 
 function stringify(obj: any) {
     if (typeof obj === 'number' || typeof obj === 'boolean' || typeof obj === 'string' || obj === undefined || obj === null)
@@ -18,7 +16,7 @@ function stringify(obj: any) {
 
     let str = '{';
     for (const key of Object.keys(obj).sort()) {
-        str += `${key}:${stringify((obj: any)[key])},`;
+        str += `${key}:${stringify((obj)[key])},`;
     }
     return `${str}}`;
 }
@@ -26,7 +24,7 @@ function stringify(obj: any) {
 function getKey(layer: LayerSpecification) {
     let key = '';
     for (const k of refProperties) {
-        key += `/${stringify((layer: any)[k])}`;
+        key += `/${stringify((layer as any)[k])}`;
     }
     return key;
 }
@@ -46,8 +44,13 @@ function getKey(layer: LayerSpecification) {
  * @param {Object} [cachedKeys] - an object to keep already calculated keys.
  * @returns {Array<Array<Layer>>}
  */
-export default function groupByLayout(layers: Array<LayerSpecification>, cachedKeys: {[id: string]: string}): Array<Array<LayerSpecification>> {
-    const groups = {};
+export default function groupByLayout(
+    layers: Array<LayerSpecification>,
+    cachedKeys: {
+        [id: string]: string;
+    },
+): Array<Array<LayerSpecification>> {
+    const groups: Record<string, any> = {};
 
     for (let i = 0; i < layers.length; i++) {
 

package/migrate/{expressions.js → expressions.ts}

@@ -1,14 +1,9 @@
-// @flow
+import {eachLayer, eachProperty} from '../visit';
+import {isExpression} from '../expression/index';
+import convertFunction, {convertTokenString} from '../function/convert';
+import convertFilter from '../feature_filter/convert';
 
-import {
-    eachLayer,
-    eachProperty
-} from '../visit.js';
-import {isExpression} from '../expression/index.js';
-import convertFunction, {convertTokenString} from '../function/convert.js';
-import convertFilter from '../feature_filter/convert.js';
-
-import type {StyleSpecification} from '../types.js';
+import type {StyleSpecification, FunctionSpecification} from '../types';
 
 /**
  * Migrate the given style object in place to use expressions. Specifically,
@@ -20,17 +15,14 @@ export default function(style: StyleSpecification): StyleSpecification {
 
     eachLayer(style, (layer) => {
         if (layer.filter) {
-            layer.filter = (convertFilter(layer.filter): any);
+            layer.filter = (convertFilter(layer.filter) as any);
         }
     });
 
     eachProperty(style, {paint: true, layout: true}, ({path, value, reference, set}) => {
         if (isExpression(value)) return;
         if (typeof value === 'object' && !Array.isArray(value)) {
-            // $FlowFixMe[prop-missing]
-            // $FlowFixMe[incompatible-call]
-            // $FlowFixMe[incompatible-variance]
-            set(convertFunction(value, reference));
+            set(convertFunction(value as FunctionSpecification<unknown>, reference));
             converted.push(path.join('.'));
         } else if (reference.tokens && typeof value === 'string') {
             set(convertTokenString(value));
@@ -39,4 +31,3 @@ export default function(style: StyleSpecification): StyleSpecification {
 
     return style;
 }
-

package/migrate/{v8.js → v8.ts}

@@ -1,5 +1,5 @@
-// @noflow
-import {eachSource, eachLayer, eachProperty} from '../visit.js';
+// @ts-nocheck
+import {eachSource, eachLayer, eachProperty} from '../visit';
 
 function eachLayout(layer, callback) {
     for (const k in layer) {

package/migrate/{v9.js → v9.ts}

@@ -1,5 +1,5 @@
-// @noflow
-import deref from '../deref.js';
+// @ts-nocheck
+import deref from '../deref';
 
 function eachLayer(style, callback) {
     for (const k in style.layers) {

package/{migrate.js → migrate.ts}

@@ -1,7 +1,7 @@
-// @noflow
+// @ts-nocheck
 
-import migrateToV8 from './migrate/v8.js';
-import migrateToExpressions from './migrate/expressions.js';
+import migrateToV8 from './migrate/v8';
+import migrateToExpressions from './migrate/expressions';
 
 /**
  * Migrate a Mapbox GL Style to the latest version.

package/package.json

@@ -1,17 +1,23 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
+  "version": "14.5.0",
   "description": "a specification for mapbox gl styles",
-  "version": "14.4.0",
   "author": "Mapbox",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:mapbox/mapbox-gl-js.git"
+  },
   "keywords": [
     "mapbox",
     "mapbox-gl",
     "mapbox-gl-js"
   ],
-  "license": "SEE LICENSE IN LICENSE.txt",
   "main": "./dist/index.cjs",
   "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "require": "./dist/index.cjs",
@@ -24,14 +30,11 @@
   "scripts": {
     "pretest": "npm run build",
     "test": "node ./test.js",
-    "copy-flow-typed": "cp -R ../../flow-typed .",
-    "build": "../../node_modules/.bin/rollup -c && ../../node_modules/.bin/rollup -c --environment esm",
-    "prepublishOnly": "npm run copy-flow-typed && npm run build",
-    "postpublish": "rm -r flow-typed dist/index.cjs"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:mapbox/mapbox-gl-js.git"
+    "build": "npm run build-spec && npm run build-dts",
+    "build-dts": "dts-bundle-generator --no-banner --export-referenced-types=false -o ./dist/index.d.ts ./style-spec.ts",
+    "build-spec": "rollup -c && rollup -c --environment esm",
+    "prepublishOnly": "npm run build",
+    "postpublish": "rm dist/index.cjs dist/index.d.ts"
   },
   "bin": {
     "gl-style-migrate": "./bin/gl-style-migrate.js",
@@ -42,15 +45,13 @@
   "dependencies": {
     "@mapbox/jsonlint-lines-primitives": "~2.0.2",
     "@mapbox/point-geometry": "^0.1.0",
-    "@mapbox/unitbezier": "^0.0.0",
+    "@mapbox/unitbezier": "^0.0.1",
+    "cheap-ruler": "^4.0.0",
     "csscolorparser": "~1.0.2",
-    "json-stringify-pretty-compact": "^2.0.0",
+    "json-stringify-pretty-compact": "^4.0.0",
     "minimist": "^1.2.6",
-    "rw": "^1.3.3",
-    "sort-object": "^0.3.2",
     "quickselect": "^2.0.0",
-    "tinyqueue": "^2.0.3",
-    "cheap-ruler": "^3.0.1"
-  },
-  "sideEffects": false
+    "rw": "^1.3.3",
+    "tinyqueue": "^2.0.3"
+  }
 }

package/{read_style.js → read_style.ts}

@@ -1,13 +1,14 @@
-// @noflow
+// @ts-nocheck
 
-import ParsingError from './error/parsing_error.js';
+import ParsingError from './error/parsing_error';
 import jsonlint from '@mapbox/jsonlint-lines-primitives';
 
 export default function readStyle(style) {
-    if (style instanceof String || typeof style === 'string' || style instanceof Buffer) {
+    if (style instanceof String || typeof style === 'string' || ArrayBuffer.isView(style)) {
         try {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
             return jsonlint.parse(style.toString());
-        } catch (e) {
+        } catch (e: any) {
             throw new ParsingError(e);
         }
     }

package/reference/latest.ts

@@ -0,0 +1,5 @@
+import spec from './v8.json';
+
+export type StyleReference = Record<any, any>;
+
+export default spec as StyleReference;