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

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/package.json

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

package/reference/v8.json

@@ -4101,7 +4101,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/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/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);
-    }
-}