@mapbox/mapbox-gl-style-spec 14.4.0-beta.1 → 14.5.0-beta.1

package/expression/{parsing_error.js → parsing_error.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 class ParsingError extends Error {
     key: string;
     message: string;

package/expression/{runtime_error.js → runtime_error.ts}

@@ -1,5 +1,3 @@
-// @flow
-
 class RuntimeError {
     name: string;
     message: string;

package/expression/{scope.js → scope.ts}

@@ -1,14 +1,14 @@
-// @flow
-
-import type {Expression} from './expression.js';
+import type {Expression} from './expression';
 
 /**
  * Tracks `let` bindings during expression parsing.
  * @private
  */
 class Scope {
-    parent: ?Scope;
-    bindings: {[_: string]: Expression};
+    parent: Scope | null | undefined;
+    bindings: {
+        [_: string]: Expression;
+    };
     constructor(parent?: Scope, bindings: Array<[string, Expression]> = []) {
         this.parent = parent;
         this.bindings = {};

package/expression/{stops.js → stops.ts}

@@ -1,8 +1,6 @@
-// @flow
+import RuntimeError from './runtime_error';
 
-import RuntimeError from './runtime_error.js';
-
-import type {Expression} from './expression.js';
+import type {Expression} from './expression';
 
 export type Stops = Array<[number, Expression]>;
 

package/expression/types/{collator.js → collator.ts}

@@ -1,9 +1,7 @@
-// @flow
-
 export default class Collator {
     locale: string | null;
     sensitivity: 'base' | 'accent' | 'case' | 'variant';
-    collator: Intl$Collator;
+    collator: Intl.Collator;
 
     constructor(caseSensitive: boolean, diacriticSensitive: boolean, locale: string | null) {
         if (caseSensitive)

package/expression/types/{formatted.js → formatted.ts}

@@ -1,6 +1,5 @@
-// @flow
-import type Color from '../../util/color.js';
-import type ResolvedImage from '../types/resolved_image.js';
+import type Color from '../../util/color';
+import type ResolvedImage from '../types/resolved_image';
 
 export class FormattedSection {
     text: string;
@@ -49,15 +48,17 @@ export default class Formatted {
         return this.sections.map(section => section.text).join('');
     }
 
-    serialize(): Array<mixed> {
-        const serialized: Array<mixed> = ["format"];
+    serialize(): Array<unknown> {
+        const serialized: Array<unknown> = ["format"];
         for (const section of this.sections) {
             if (section.image) {
                 serialized.push(["image", section.image.namePrimary]);
                 continue;
             }
             serialized.push(section.text);
-            const options: { [key: string]: mixed } = {};
+            const options: {
+                [key: string]: unknown;
+            } = {};
             if (section.fontStack) {
                 options["text-font"] = ["literal", section.fontStack.split(',')];
             }
@@ -65,7 +66,7 @@ export default class Formatted {
                 options["font-scale"] = section.scale;
             }
             if (section.textColor) {
-                options["text-color"] = (["rgba"]: Array<mixed>).concat(section.textColor.toArray());
+                options["text-color"] = (["rgba"] as Array<unknown>).concat(section.textColor.toRenderColor(null).toArray());
             }
             serialized.push(options);
         }

package/expression/types/{resolved_image.js → resolved_image.ts}

@@ -1,14 +1,12 @@
-// @flow
-
 export type ResolvedImageOptions = {
-    namePrimary: string,
-    nameSecondary: ?string,
-    available: boolean
+    namePrimary: string;
+    nameSecondary: string | null | undefined;
+    available: boolean;
 };
 
 export default class ResolvedImage {
     namePrimary: string;
-    nameSecondary: ?string;
+    nameSecondary: string | null | undefined;
     available: boolean;
 
     constructor(options: ResolvedImageOptions) {
@@ -26,7 +24,7 @@ export default class ResolvedImage {
         return this.namePrimary;
     }
 
-    static fromString(namePrimary: string, nameSecondary: ?string): ResolvedImage | null {
+    static fromString(namePrimary: string, nameSecondary?: string | null): ResolvedImage | null {
         if (!namePrimary) return null; // treat empty values as no image
         return new ResolvedImage({namePrimary, nameSecondary, available: false});
     }

package/expression/{types.js → types.ts}

@@ -1,55 +1,63 @@
-// @flow
-
-export type NullTypeT = { kind: 'null' };
-export type NumberTypeT = { kind: 'number' };
-export type StringTypeT = { kind: 'string' };
-export type BooleanTypeT = { kind: 'boolean' };
-export type ColorTypeT = { kind: 'color' };
-export type ObjectTypeT = { kind: 'object' };
-export type ValueTypeT = { kind: 'value' };
-export type ErrorTypeT = { kind: 'error' };
-export type CollatorTypeT = { kind: 'collator' };
-export type FormattedTypeT = { kind: 'formatted' };
-export type ResolvedImageTypeT = { kind: 'resolvedImage' };
+export type NullTypeT = {
+    kind: 'null';
+};
+export type NumberTypeT = {
+    kind: 'number';
+};
+export type StringTypeT = {
+    kind: 'string';
+};
+export type BooleanTypeT = {
+    kind: 'boolean';
+};
+export type ColorTypeT = {
+    kind: 'color';
+};
+export type ObjectTypeT = {
+    kind: 'object';
+};
+export type ValueTypeT = {
+    kind: 'value';
+};
+export type ErrorTypeT = {
+    kind: 'error';
+};
+export type CollatorTypeT = {
+    kind: 'collator';
+};
+export type FormattedTypeT = {
+    kind: 'formatted';
+};
+export type ResolvedImageTypeT = {
+    kind: 'resolvedImage';
+};
 
 export type EvaluationKind = 'constant' | 'source' | 'camera' | 'composite';
 
-export type Type =
-    NullTypeT |
-    NumberTypeT |
-    StringTypeT |
-    BooleanTypeT |
-    ColorTypeT |
-    ObjectTypeT |
-    ValueTypeT |
-    ArrayType | // eslint-disable-line no-use-before-define
-    ErrorTypeT |
-    CollatorTypeT |
-    FormattedTypeT |
-    ResolvedImageTypeT |
-    ArrayType;
+export type Type = NullTypeT | NumberTypeT | StringTypeT | BooleanTypeT | ColorTypeT | ObjectTypeT | ValueTypeT | // eslint-disable-line no-use-before-define
+ArrayType | ErrorTypeT | CollatorTypeT | FormattedTypeT | ResolvedImageTypeT;
 
 export type ArrayType = {
-    kind: 'array',
-    itemType: Type,
-    N: ?number
-}
+    kind: 'array';
+    itemType: Type;
+    N: number | null | undefined;
+};
 
-export type NativeType = 'number' | 'string' | 'boolean' | 'null' | 'array' | 'object'
+export type NativeType = 'number' | 'string' | 'boolean' | 'null' | 'array' | 'object';
 
-export const NullType = {kind: 'null'};
-export const NumberType = {kind: 'number'};
-export const StringType = {kind: 'string'};
-export const BooleanType = {kind: 'boolean'};
-export const ColorType = {kind: 'color'};
-export const ObjectType = {kind: 'object'};
-export const ValueType = {kind: 'value'};
-export const ErrorType = {kind: 'error'};
-export const CollatorType = {kind: 'collator'};
-export const FormattedType = {kind: 'formatted'};
-export const ResolvedImageType = {kind: 'resolvedImage'};
+export const NullType = {kind: 'null'} as const;
+export const NumberType = {kind: 'number'} as const;
+export const StringType = {kind: 'string'} as const;
+export const BooleanType = {kind: 'boolean'} as const;
+export const ColorType = {kind: 'color'} as const;
+export const ObjectType = {kind: 'object'} as const;
+export const ValueType = {kind: 'value'} as const;
+export const ErrorType = {kind: 'error'} as const;
+export const CollatorType = {kind: 'collator'} as const;
+export const FormattedType = {kind: 'formatted'} as const;
+export const ResolvedImageType = {kind: 'resolvedImage'} as const;
 
-export function array(itemType: Type, N: ?number): ArrayType {
+export function array(itemType: Type, N?: number | null): ArrayType {
     return {
         kind: 'array',
         itemType,
@@ -85,7 +93,7 @@ const valueMemberTypes = [
  * error message.
  * @private
  */
-export function checkSubtype(expected: Type, t: Type): ?string {
+export function checkSubtype(expected: Type, t: Type): string | null | undefined {
     if (t.kind === 'error') {
         // Error is a subtype of every type
         return null;

package/expression/{values.js → values.ts}

@@ -1,16 +1,14 @@
-// @flow
-
 import assert from 'assert';
 
-import Color from '../util/color.js';
-import Collator from './types/collator.js';
-import Formatted from './types/formatted.js';
-import ResolvedImage from './types/resolved_image.js';
-import {NullType, NumberType, StringType, BooleanType, ColorType, ObjectType, ValueType, CollatorType, FormattedType, ResolvedImageType, array} from './types.js';
+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.js';
+import type {Type} from './types';
 
-export function validateRGBA(r: mixed, g: mixed, b: mixed, a?: mixed): string | null {
+export function validateRGBA(r: unknown, g: unknown, b: unknown, a?: unknown): string | null {
     if (!(
         typeof r === 'number' && r >= 0 && r <= 255 &&
         typeof g === 'number' && g >= 0 && g <= 255 &&
@@ -29,7 +27,7 @@ export function validateRGBA(r: mixed, g: mixed, b: mixed, a?: mixed): string |
     return null;
 }
 
-export function validateHSLA(h: mixed, s: mixed, l: mixed, a?: mixed): string | null {
+export function validateHSLA(h: unknown, s: unknown, l: unknown, a?: unknown): string | null {
     if (!(
         typeof h === 'number' && h >= 0 && h <= 360
     )) {
@@ -54,9 +52,11 @@ export function validateHSLA(h: mixed, s: mixed, l: mixed, a?: mixed): string |
     return null;
 }
 
-export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | $ReadOnlyArray<Value> | { +[string]: Value }
+export type Value = null | string | boolean | number | Color | Collator | Formatted | ResolvedImage | ReadonlyArray<Value> | {
+    readonly [key: string]: Value;
+};
 
-export function isValue(mixed: mixed): boolean {
+export function isValue(mixed: unknown): boolean {
     if (mixed === null) {
         return true;
     } else if (typeof mixed === 'string') {

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

@@ -1,17 +1,17 @@
-// @flow
+import {isExpressionFilter} from './index';
 
-import {isExpressionFilter} from './index.js';
+import type {FilterSpecification} from '../types';
 
-import type {FilterSpecification} from '../types.js';
-
-type ExpectedTypes = {[_: string]: 'string' | 'number' | 'boolean'};
+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 {
+export default function convertFilter(filter: FilterSpecification): unknown {
     return _convertFilter(filter, {});
 }
 
@@ -63,7 +63,7 @@ export default function convertFilter(filter: FilterSpecification): mixed {
  * false (legacy filter semantics) are equivalent: they cause the filter to
  * produce a `false` result.
  */
-function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedTypes): mixed {
+function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedTypes): unknown {
     if (isExpressionFilter(filter)) { return filter; }
 
     if (!filter) return true;
@@ -80,29 +80,29 @@ function _convertFilter(filter: FilterSpecification, expectedTypes: ExpectedType
         op === '<=' ||
         op === '>='
     ) {
-        const [, property, value] = (filter: any);
+        const [, property, value] = (filter as any);
         converted = convertComparisonOp(property, value, op, expectedTypes);
     } else if (op === 'any') {
-        const children = (filter: any).slice(1).map(f => {
-            const types = {};
+        const children = (filter as any).slice(1).map(f => {
+            const types: Record<string, any> = {};
             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));
+        const children = (filter as 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: any).slice(1)), {})];
+        return ['!', _convertFilter(['any'].concat((filter as any).slice(1)), {})];
     } else if (op === 'in') {
-        converted = convertInOp((filter[1]: any), filter.slice(2));
+        converted = convertInOp((filter[1] as any), filter.slice(2));
     } else if (op === '!in') {
-        converted = convertInOp((filter[1]: any), filter.slice(2), true);
+        converted = convertInOp((filter[1] as any), filter.slice(2), true);
     } else if (op === 'has') {
-        converted = convertHasOp((filter[1]: any));
+        converted = convertHasOp((filter[1] as any));
     } else if (op === '!has') {
-        converted = ['!', convertHasOp((filter[1]: any))];
+        converted = ['!', convertHasOp((filter[1] as any))];
     } else {
         converted = true;
     }
@@ -129,7 +129,7 @@ function runtimeTypeChecks(expectedTypes: ExpectedTypes) {
     return ['all'].concat(conditions);
 }
 
-function convertComparisonOp(property: string, value: any, op: string, expectedTypes: ?ExpectedTypes) {
+function convertComparisonOp(property: string, value: any, op: string, expectedTypes?: ExpectedTypes | null) {
     let get;
     if (property === '$type') {
         return [op, ['geometry-type'], value];
@@ -140,7 +140,7 @@ function convertComparisonOp(property: string, value: any, op: string, expectedT
     }
 
     if (expectedTypes && value !== null) {
-        const type = ((typeof value): any);
+        const type = ((typeof value) as any);
         expectedTypes[property] = type;
     }
 
@@ -193,6 +193,7 @@ function convertInOp(property: string, values: Array<any>, negate: boolean = fal
     }
 
     return [ negate ? 'all' : 'any' ].concat(
+        // @ts-expect-error - TS2769 - No overload matches this call.
         values.map(v => [negate ? '!=' : '==', get, v])
     );
 }

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

@@ -1,16 +1,29 @@
-// @flow
-
-import {createExpression} from '../expression/index.js';
-import {isFeatureConstant} from '../expression/is_constant.js';
-import {deepUnbundle} from '../util/unbundle_jsonlint.js';
-import latest from '../reference/latest.js';
-import type {GlobalProperties, Feature} from '../expression/index.js';
-import type {CanonicalTileID} from '../../source/tile_id.js';
+import {createExpression} from '../expression/index';
+import {isFeatureConstant} from '../expression/is_constant';
+import {deepUnbundle} from '../util/unbundle_jsonlint';
+import latest from '../reference/latest';
+import type {GlobalProperties, Feature} from '../expression/index';
+import type {CanonicalTileID} from '../types/tile_id';
 import type Point from '@mapbox/point-geometry';
 
-export type FeatureDistanceData = {bearing: [number, number], center: [number, number], scale: number};
-export type FilterExpression = (globalProperties: GlobalProperties, feature: Feature, canonical?: CanonicalTileID, featureTileCoord?: Point, featureDistanceData?: FeatureDistanceData) => boolean;
-export type FeatureFilter = {filter: FilterExpression, dynamicFilter?: FilterExpression, needGeometry: boolean, needFeature: boolean};
+export type FeatureDistanceData = {
+    bearing: [number, number];
+    center: [number, number];
+    scale: number;
+};
+export type FilterExpression = (
+    globalProperties: GlobalProperties,
+    feature: Feature,
+    canonical?: CanonicalTileID,
+    featureTileCoord?: Point,
+    featureDistanceData?: FeatureDistanceData,
+) => boolean;
+export type FeatureFilter = {
+    filter: FilterExpression;
+    dynamicFilter?: FilterExpression;
+    needGeometry: boolean;
+    needFeature: boolean;
+};
 
 export default createFilter;
 export {isExpressionFilter, isDynamicFilter, extractStaticFilter};
@@ -67,21 +80,20 @@ function isExpressionFilter(filter: any): boolean {
  * @param {string} layerType the type of the layer this filter will be applied to.
  * @returns {Function} filter-evaluating function
  */
-function createFilter(filter: any, layerType?: string = 'fill'): FeatureFilter {
+function createFilter(filter: any, layerType: string = 'fill'): FeatureFilter {
     if (filter === null || filter === undefined) {
         return {filter: () => true, needGeometry: false, needFeature: false};
     }
 
     if (!isExpressionFilter(filter)) {
-        // $FlowFixMe[incompatible-call]
         filter = convertFilter(filter);
     }
-    const filterExp = ((filter: any): string[] | string | boolean);
+    const filterExp = (filter as string[] | string | boolean);
 
     let staticFilter = true;
     try {
         staticFilter = extractStaticFilter(filterExp);
-    } catch (e) {
+    } catch (e: any) {
         console.warn(
 `Failed to extract static filter. Filter will continue working, but at higher memory usage and slower framerate.
 This is most likely a bug, please report this via https://github.com/mapbox/mapbox-gl-js/issues/new?assignees=&labels=&template=Bug_report.md
@@ -118,7 +130,7 @@ ${JSON.stringify(filterExp, null, 2)}
         }
     }
 
-    filterFunc = ((filterFunc: any): FilterExpression);
+    filterFunc = (filterFunc as FilterExpression);
     const needGeometry = geometryNeeded(staticFilter);
 
     return {
@@ -267,7 +279,7 @@ function geometryNeeded(filter: Array<any> | boolean) {
     return false;
 }
 
-function convertFilter(filter: ?Array<any>): mixed {
+function convertFilter(filter?: Array<any> | null): unknown {
     if (!filter) return true;
     const op = filter[0];
     if (filter.length <= 1) return (op !== 'any');
@@ -279,7 +291,9 @@ function convertFilter(filter: ?Array<any>): mixed {
         op === '<=' ||
         op === '>=' ? convertComparisonOp(filter[1], filter[2], op) :
         op === 'any' ? convertDisjunctionOp(filter.slice(1)) :
+        // @ts-expect-error - TS2769 - No overload matches this call.
         op === 'all' ? ['all'].concat(filter.slice(1).map(convertFilter)) :
+        // @ts-expect-error - TS2769 - No overload matches this call.
         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))) :
@@ -301,6 +315,7 @@ function convertComparisonOp(property: string, value: any, op: string) {
 }
 
 function convertDisjunctionOp(filters: Array<Array<any>>) {
+// @ts-expect-error - TS2769 - No overload matches this call.
     return ['any'].concat(filters.map(convertFilter));
 }
 
@@ -331,6 +346,6 @@ function convertHasOp(property: string) {
     }
 }
 
-function convertNegation(filter: mixed) {
+function convertNegation(filter: unknown) {
     return ['!', filter];
 }

package/{format.js → format.ts}

@@ -1,10 +1,10 @@
-// @noflow
+// @ts-nocheck
 
-import reference from './reference/latest.js';
+import reference from './reference/latest';
 import stringifyPretty from 'json-stringify-pretty-compact';
 
 function sortKeysBy(obj, reference) {
-    const result = {};
+    const result: Record<string, any> = {};
     for (const key in reference) {
         if (obj[key] !== undefined) {
             result[key] = obj[key];