@mapbox/mapbox-gl-style-spec 14.11.0-beta.1 → 14.11.0

package/expression/types/resolved_image.ts

@@ -1,80 +1,71 @@
-import {ImageIdWithOptions} from "./image_id_with_options";
+import {ImageId} from './image_id';
+import {ImageVariant} from './image_variant';
 
-import type Color from "../../util/color";
-
-export type RasterizationOptions = {
-    params: Record<string, Color>;
-    transform?: DOMMatrix;
-}
-
-export type ResolvedImageOptions = {
-    namePrimary: string;
-    optionsPrimary: RasterizationOptions | null | undefined;
-    nameSecondary: string | null | undefined;
-    optionsSecondary: RasterizationOptions | null | undefined;
-    available: boolean;
-};
+import type {ImageIdSpec} from './image_id';
+import type {RasterizationOptions} from './image_variant';
 
 export default class ResolvedImage {
-    namePrimary: string;
-    optionsPrimary: RasterizationOptions | null | undefined;
-    nameSecondary: string | null | undefined;
-    optionsSecondary: RasterizationOptions | null | undefined;
+    primaryId: ImageId;
+    primaryOptions?: RasterizationOptions;
+    secondaryId?: ImageId;
+    secondaryOptions?: RasterizationOptions;
     available: boolean;
 
-    constructor(options: ResolvedImageOptions) {
-        this.namePrimary = options.namePrimary;
-        if (options.nameSecondary) {
-            this.nameSecondary = options.nameSecondary;
-        }
-        if (options.optionsPrimary) {
-            this.optionsPrimary = options.optionsPrimary;
-        }
-        if (options.optionsSecondary) {
-            this.optionsSecondary = options.optionsSecondary;
-        }
-        this.available = options.available;
+    constructor(
+        primaryId: string | ImageIdSpec,
+        primaryOptions?: RasterizationOptions,
+        secondaryId?: string | ImageIdSpec,
+        secondaryOptions?: RasterizationOptions,
+        available: boolean = false,
+    ) {
+        this.primaryId = ImageId.from(primaryId);
+        this.primaryOptions = primaryOptions;
+        if (secondaryId) this.secondaryId = ImageId.from(secondaryId);
+        this.secondaryOptions = secondaryOptions;
+        this.available = available;
     }
 
     toString(): string {
-        if (this.namePrimary && this.nameSecondary) {
-            return `[${this.namePrimary},${this.nameSecondary}]`;
+        if (this.primaryId && this.secondaryId) {
+            const primaryName = this.primaryId.name;
+            const secondaryName = this.secondaryId.name;
+            return `[${primaryName},${secondaryName}]`;
         }
 
-        return this.namePrimary;
+        return this.primaryId.name;
+    }
+
+    hasPrimary(): boolean {
+        return !!this.primaryId;
     }
 
-    getPrimary(): ImageIdWithOptions {
-        return new ImageIdWithOptions(this.namePrimary, {
-            params: this.optionsPrimary ? (this.optionsPrimary.params || {}) : {},
-        });
+    getPrimary(): ImageVariant {
+        return new ImageVariant(this.primaryId, this.primaryOptions);
     }
 
-    getSerializedPrimary(): string {
-        return this.getPrimary().serialize();
+    hasSecondary(): boolean {
+        return !!this.secondaryId;
     }
 
-    getSecondary(): ImageIdWithOptions | null {
-        if (this.nameSecondary) {
-            return new ImageIdWithOptions(this.nameSecondary, {
-                params: this.optionsSecondary ? (this.optionsSecondary.params || {}) : {},
-            });
+    getSecondary(): ImageVariant | null {
+        if (!this.secondaryId) {
+            return null;
         }
 
-        return null;
+        return new ImageVariant(this.secondaryId, this.secondaryOptions);
     }
 
     static from(image: string | ResolvedImage): ResolvedImage {
-        return typeof image === 'string' ? ResolvedImage.build(image) : image;
+        return typeof image === 'string' ? ResolvedImage.build({name: image}) : image;
     }
 
     static build(
-        namePrimary: string,
-        nameSecondary?: string | null,
-        optionsPrimary?: RasterizationOptions | null,
-        optionsSecondary?: RasterizationOptions | null
+        primaryId: string | ImageIdSpec,
+        secondaryId?: string | ImageIdSpec,
+        primaryOptions?: RasterizationOptions,
+        secondaryOptions?: RasterizationOptions
     ): ResolvedImage | null {
-        if (!namePrimary) return null; // treat empty values as no image
-        return new ResolvedImage({namePrimary, nameSecondary, optionsPrimary, optionsSecondary, available: false});
+        if (!primaryId || (typeof primaryId === 'object' && !('name' in primaryId))) return null; // treat empty values as no image
+        return new ResolvedImage(primaryId, primaryOptions, secondaryId, secondaryOptions);
     }
 }

package/expression/types.ts

@@ -34,7 +34,7 @@ export type ResolvedImageTypeT = {
 
 export type EvaluationKind = 'constant' | 'source' | 'camera' | 'composite';
 
-export type Type = NullTypeT | NumberTypeT | StringTypeT | BooleanTypeT | ColorTypeT | ObjectTypeT | ValueTypeT | // eslint-disable-line no-use-before-define
+export type Type = NullTypeT | NumberTypeT | StringTypeT | BooleanTypeT | ColorTypeT | ObjectTypeT | ValueTypeT |
 ArrayType | ErrorTypeT | CollatorTypeT | FormattedTypeT | ResolvedImageTypeT;
 
 export type ArrayType = {

package/function/index.ts

@@ -43,7 +43,7 @@ export function createFunction(parameters, propertySpec) {
         }
     }
 
-    if (parameters.colorSpace && parameters.colorSpace !== 'rgb' && !colorSpaces[parameters.colorSpace]) { // eslint-disable-line import/namespace
+    if (parameters.colorSpace && parameters.colorSpace !== 'rgb' && !colorSpaces[parameters.colorSpace]) {
         throw new Error(`Unknown color space: ${parameters.colorSpace}`);
     }
 
@@ -175,10 +175,10 @@ function evaluateExponentialFunction(parameters, propertySpec, input) {
 
     const outputLower = parameters.stops[index][1];
     const outputUpper = parameters.stops[index + 1][1];
-    let interp = interpolate[propertySpec.type] || identityFunction; // eslint-disable-line import/namespace
+    let interp = interpolate[propertySpec.type] || identityFunction;
 
     if (parameters.colorSpace && parameters.colorSpace !== 'rgb') {
-        const colorspace = colorSpaces[parameters.colorSpace]; // eslint-disable-line import/namespace
+        const colorspace = colorSpaces[parameters.colorSpace];
         interp = (a, b) => colorspace.reverse(colorspace.interpolate(colorspace.forward(a), colorspace.forward(b), t));
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapbox/mapbox-gl-style-spec",
-  "version": "14.11.0-beta.1",
+  "version": "14.11.0",
   "description": "a specification for mapbox gl styles",
   "author": "Mapbox",
   "license": "SEE LICENSE IN LICENSE.txt",

package/read_style.ts

@@ -1,15 +1,13 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-// @ts-nocheck
-
 import ParsingError from './error/parsing_error';
 import jsonlint from '@mapbox/jsonlint-lines-primitives';
 
-export default function readStyle(style) {
+import type {StyleSpecification} from './types';
+
+export default function readStyle(style: string | Buffer | StyleSpecification): StyleSpecification {
     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: any) {
+        } catch (e) {
             throw new ParsingError(e);
         }
     }

package/reference/v8.json

@@ -146,6 +146,7 @@
       "doc": "A collection of icon sets",
       "sdk-support": {
         "basic functionality": {
+          "js": "3.11.0",
           "android": "11.11.0",
           "ios": "11.11.0"
         }
@@ -4101,7 +4102,7 @@
         }
       },
       "config": {
-        "doc": "Retrieves the configuration value for the given option.",
+        "doc": "Retrieves the configuration value for the given option. Returns null if the requested option is missing.",
         "group": "Lookup",
         "sdk-support": {
           "basic functionality": {

package/test.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-/* eslint-disable no-process-exit */
 
 import fs from 'fs';
 import {execSync} from 'child_process';

package/types/brand.ts

@@ -0,0 +1,4 @@
+/**
+ * Defines nominal type of `U` based on type of `T`. Similar to Opaque types in Flow.
+ */
+export type Brand<T, U> = T & {__brand: U};

package/util/interpolate.ts

@@ -18,3 +18,7 @@ export function array(from: Array<number>, to: Array<number>, t: number): Array<
         return number(d, to[i], t);
     });
 }
+
+export function easeIn (x: number) {
+    return x * x * x * x * x;
+}

package/validate/validate_style.ts

@@ -3,6 +3,7 @@ import latestStyleSpec from '../reference/latest';
 import validateGlyphsURL from './validate_glyphs_url';
 
 import type ValidationError from '../error/validation_error';
+import type {StyleReference} from '../reference/latest';
 import type {ValidationOptions} from './validate';
 import type {StyleSpecification} from '../types';
 
@@ -12,7 +13,7 @@ type StyleValidationOptions = {
 
 export default function validateStyle(
     style: StyleSpecification,
-    styleSpec: any = latestStyleSpec,
+    styleSpec: StyleReference = latestStyleSpec,
     options: StyleValidationOptions = {},
 ): ValidationError[] {
     const errors = validate({

package/validate_style.min.ts

@@ -13,6 +13,7 @@ import _validatePaintProperty from './validate/validate_paint_property';
 import _validateLayoutProperty from './validate/validate_layout_property';
 import _validateModel from './validate/validate_model';
 
+import type {StyleReference} from './reference/latest';
 import type {StyleSpecification} from './types';
 
 export type ValidationError = {
@@ -20,8 +21,9 @@ export type ValidationError = {
     identifier?: string | null | undefined;
     line?: number | null | undefined;
 };
+
 export type ValidationErrors = ReadonlyArray<ValidationError>;
-export type Validator = (arg1: any) => ValidationErrors;
+export type Validator<T extends (...args: unknown[]) => unknown = (...args: unknown[]) => unknown> = (...args: Parameters<T>) => ValidationErrors;
 
 /**
  * Validate a Mapbox GL style against the style specification. This entrypoint,
@@ -38,24 +40,24 @@ export type Validator = (arg1: any) => ValidationErrors;
  *   var validate = require('mapbox-gl-style-spec/lib/validate_style.min');
  *   var errors = validate(style);
  */
-export function validateStyle(style: StyleSpecification, styleSpec: any = latestStyleSpec): ValidationErrors {
+export function validateStyle(style: StyleSpecification, styleSpec: StyleReference = latestStyleSpec): ValidationErrors {
     const errors = _validateStyle(style, styleSpec);
     return sortErrors(errors);
 }
 
-export const validateSource: Validator = opts => sortErrors(_validateSource(opts));
-export const validateLight: Validator = opts => sortErrors(_validateLight(opts));
-export const validateLights: Validator = opts => sortErrors(_validateLights(opts));
-export const validateTerrain: Validator = opts => sortErrors(_validateTerrain(opts));
-export const validateFog: Validator = opts => sortErrors(_validateFog(opts));
-export const validateSnow: Validator = opts => sortErrors(_validateSnow(opts));
-export const validateRain: Validator = opts => sortErrors(_validateRain(opts));
-export const validateLayer: Validator = opts => sortErrors(_validateLayer(opts));
-export const validateFilter: Validator = opts => sortErrors(_validateFilter(opts));
-export const validatePaintProperty: Validator = opts => sortErrors(_validatePaintProperty(opts));
-export const validateLayoutProperty: Validator = opts => sortErrors(_validateLayoutProperty(opts));
-export const validateModel: Validator = opts => sortErrors(_validateModel(opts));
+export const validateSource: Validator<typeof _validateSource> = opts => sortErrors(_validateSource(opts));
+export const validateLight: Validator<typeof _validateLight> = opts => sortErrors(_validateLight(opts));
+export const validateLights: Validator<typeof _validateLights> = opts => sortErrors(_validateLights(opts));
+export const validateTerrain: Validator<typeof _validateTerrain> = opts => sortErrors(_validateTerrain(opts));
+export const validateFog: Validator<typeof _validateFog> = opts => sortErrors(_validateFog(opts));
+export const validateSnow: Validator<typeof _validateSnow> = opts => sortErrors(_validateSnow(opts));
+export const validateRain: Validator<typeof _validateRain> = opts => sortErrors(_validateRain(opts));
+export const validateLayer: Validator<typeof _validateLayer> = opts => sortErrors(_validateLayer(opts));
+export const validateFilter: Validator<typeof _validateFilter> = opts => sortErrors(_validateFilter(opts));
+export const validatePaintProperty: Validator<typeof _validatePaintProperty> = opts => sortErrors(_validatePaintProperty(opts));
+export const validateLayoutProperty: Validator<typeof _validateLayoutProperty> = opts => sortErrors(_validateLayoutProperty(opts));
+export const validateModel: Validator<typeof _validateModel> = opts => sortErrors(_validateModel(opts));
 
-function sortErrors(errors: ValidationErrors) {
+function sortErrors(errors: ValidationErrors): ValidationErrors {
     return errors.slice().sort((a, b) => a.line && b.line ? a.line - b.line : 0);
 }

package/validate_style.ts

@@ -2,6 +2,7 @@ import {validateStyle as validateStyleMin} from './validate_style.min';
 import {v8} from './style-spec';
 import readStyle from './read_style';
 
+import type {StyleReference} from './reference/latest';
 import type {ValidationErrors} from './validate_style.min';
 import type {StyleSpecification} from './types';
 
@@ -21,16 +22,15 @@ import type {StyleSpecification} from './types';
  *   var errors = validate(style);
  */
 
-export default function validateStyle(style: StyleSpecification | string | Buffer, styleSpec: any = v8): ValidationErrors {
+export default function validateStyle(style: StyleSpecification | string | Buffer, styleSpec: StyleReference = v8): ValidationErrors {
     let s = style;
 
     try {
         s = readStyle(s);
-    } catch (e: any) {
+    } catch (e) {
         return [e];
     }
 
-    // @ts-expect-error - TS2345 - Argument of type 'string | StyleSpecification | Buffer' is not assignable to parameter of type 'StyleSpecification'.
     return validateStyleMin(s, styleSpec);
 }
 

package/expression/types/image_id_with_options.ts

@@ -1,58 +0,0 @@
-import type {RasterizationOptions} from "./resolved_image";
-
-export class ImageIdWithOptions {
-    id: string;
-    options: RasterizationOptions;
-
-    constructor(id: string, options?: RasterizationOptions) {
-        this.id = id;
-        this.options = options || {params: {}};
-
-        if (!this.options.transform) {
-            this.options.transform = new DOMMatrix([1, 0, 0, 1, 0, 0]);
-        } else {
-            const {a, b, c, d, e, f} = this.options.transform;
-            this.options.transform = new DOMMatrix([a, b, c, d, e, f]);
-        }
-    }
-
-    static deserializeId(serialized: string): string {
-        return JSON.parse(serialized).id;
-    }
-
-    static deserializeFromString(serialized: string): ImageIdWithOptions {
-        const deserializedObject = JSON.parse(serialized);
-        const options: RasterizationOptions = {params: deserializedObject.options.params};
-
-        const {a, b, c, d, e, f} = deserializedObject.options.transform;
-
-        options.transform = new DOMMatrix([a, b, c, d, e, f]);
-
-        return new ImageIdWithOptions(deserializedObject.id, deserializedObject.options);
-    }
-
-    scaleSelf(factor: number): this {
-        this.options.transform = this.options.transform.scale(factor);
-        return this;
-    }
-
-    serialize(): string {
-        const serialisedObject: Record<string, any> = {
-            id: this.id,
-        };
-
-        if (this.options) {
-            serialisedObject.options = this.options;
-        }
-
-        const {
-            a, b, c, d, e, f,
-        } = this.options.transform;
-
-        serialisedObject.options.transform = {
-            a, b, c, d, e, f,
-        };
-
-        return JSON.stringify(serialisedObject);
-    }
-}