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

package/dist/index.cjs

@@ -3923,7 +3923,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": {
@@ -12447,7 +12447,13 @@
       isEmpty() {
           if (this.sections.length === 0)
               return true;
-          return !this.sections.some(section => section.text.length !== 0 || section.image && section.image.namePrimary);
+          return !this.sections.some(section => {
+              if (section.text.length !== 0)
+                  return true;
+              if (!section.image)
+                  return false;
+              return section.image.hasPrimary();
+          });
       }
       static factory(text) {
           if (text instanceof Formatted) {
@@ -12465,9 +12471,10 @@
           const serialized = ['format'];
           for (const section of this.sections) {
               if (section.image) {
+                  const primaryId = section.image.getPrimary().id.toString();
                   serialized.push([
                       'image',
-                      section.image.namePrimary
+                      primaryId
                   ]);
                   continue;
               }
@@ -12491,11 +12498,57 @@
       }
   }
 
-  class ImageIdWithOptions {
-      constructor(id, options) {
-          this.id = id;
-          this.options = options || { params: {} };
-          if (!this.options.transform) {
+  class ImageId {
+      constructor(id) {
+          if (typeof id === 'string') {
+              this.name = id;
+          } else {
+              this.name = id.name;
+              this.iconsetId = id.iconsetId;
+          }
+      }
+      static from(id) {
+          return new ImageId(id);
+      }
+      static toString(id) {
+          return JSON.stringify({
+              name: id.name,
+              iconsetId: id.iconsetId
+          });
+      }
+      static parse(str) {
+          try {
+              const {name, iconsetId} = JSON.parse(str);
+              return new ImageId({
+                  name,
+                  iconsetId
+              });
+          } catch (e) {
+              return null;
+          }
+      }
+      static isEqual(a, b) {
+          return a.name === b.name && a.iconsetId === b.iconsetId;
+      }
+      toString() {
+          return JSON.stringify({
+              name: this.name,
+              iconsetId: this.iconsetId
+          });
+      }
+      serialize() {
+          return {
+              name: this.name,
+              iconsetId: this.iconsetId
+          };
+      }
+  }
+
+  class ImageVariant {
+      constructor(id, options = {}) {
+          this.id = ImageId.from(id);
+          this.options = Object.assign({}, options);
+          if (!options.transform) {
               this.options.transform = new DOMMatrix([
                   1,
                   0,
@@ -12505,7 +12558,7 @@
                   0
               ]);
           } else {
-              const {a, b, c, d, e, f} = this.options.transform;
+              const {a, b, c, d, e, f} = options.transform;
               this.options.transform = new DOMMatrix([
                   a,
                   b,
@@ -12516,90 +12569,93 @@
               ]);
           }
       }
-      static deserializeId(serialized) {
-          return JSON.parse(serialized).id;
+      toString() {
+          const {a, b, c, d, e, f} = this.options.transform;
+          const serialized = {
+              name: this.id.name,
+              iconsetId: this.id.iconsetId,
+              params: this.options.params,
+              transform: {
+                  a,
+                  b,
+                  c,
+                  d,
+                  e,
+                  f
+              }
+          };
+          return JSON.stringify(serialized);
       }
-      static deserializeFromString(serialized) {
-          const deserializedObject = JSON.parse(serialized);
-          ({ params: deserializedObject.options.params });
-          const {a, b, c, d, e, f} = deserializedObject.options.transform;
-          new DOMMatrix([
-              a,
-              b,
-              c,
-              d,
-              e,
-              f
-          ]);
-          return new ImageIdWithOptions(deserializedObject.id, deserializedObject.options);
+      static parse(str) {
+          let name, iconsetId, params, transform;
+          try {
+              ({name, iconsetId, params, transform} = JSON.parse(str) || {});
+          } catch (e2) {
+              return null;
+          }
+          if (!name)
+              return null;
+          const {a, b, c, d, e, f} = transform || {};
+          return new ImageVariant({
+              name,
+              iconsetId
+          }, {
+              params,
+              transform: new DOMMatrix([
+                  a,
+                  b,
+                  c,
+                  d,
+                  e,
+                  f
+              ])
+          });
       }
       scaleSelf(factor) {
-          this.options.transform = this.options.transform.scale(factor);
+          this.options.transform.scaleSelf(factor);
           return this;
       }
-      serialize() {
-          const serialisedObject = { 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);
-      }
   }
 
   class ResolvedImage {
-      constructor(options) {
-          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, primaryOptions, secondaryId, secondaryOptions, available = false) {
+          this.primaryId = ImageId.from(primaryId);
+          this.primaryOptions = primaryOptions;
+          if (secondaryId)
+              this.secondaryId = ImageId.from(secondaryId);
+          this.secondaryOptions = secondaryOptions;
+          this.available = available;
       }
       toString() {
-          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() {
+          return !!this.primaryId;
       }
       getPrimary() {
-          return new ImageIdWithOptions(this.namePrimary, { params: this.optionsPrimary ? this.optionsPrimary.params || {} : {} });
+          return new ImageVariant(this.primaryId, this.primaryOptions);
       }
-      getSerializedPrimary() {
-          return this.getPrimary().serialize();
+      hasSecondary() {
+          return !!this.secondaryId;
       }
       getSecondary() {
-          if (this.nameSecondary) {
-              return new ImageIdWithOptions(this.nameSecondary, { params: this.optionsSecondary ? this.optionsSecondary.params || {} : {} });
+          if (!this.secondaryId) {
+              return null;
           }
-          return null;
+          return new ImageVariant(this.secondaryId, this.secondaryOptions);
       }
       static from(image) {
-          return typeof image === 'string' ? ResolvedImage.build(image) : image;
+          return typeof image === 'string' ? ResolvedImage.build({ name: image }) : image;
       }
-      static build(namePrimary, nameSecondary, optionsPrimary, optionsSecondary) {
-          if (!namePrimary)
+      static build(primaryId, secondaryId, primaryOptions, secondaryOptions) {
+          if (!primaryId || typeof primaryId === 'object' && !('name' in primaryId))
               return null;
-          return new ResolvedImage({
-              namePrimary,
-              nameSecondary,
-              optionsPrimary,
-              optionsSecondary,
-              available: false
-          });
+          return new ResolvedImage(primaryId, primaryOptions, secondaryId, secondaryOptions);
       }
   }
 
@@ -12993,19 +13049,22 @@
   }
 
   function isImageOptions(value) {
-      if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-          return true;
-      }
-      return false;
+      return value !== null && typeof value === 'object' && !Array.isArray(value);
   }
   class ImageExpression {
-      constructor(inputPrimary, inputSecondary, inputPrimaryParams, inputSecondaryParams) {
+      constructor(inputPrimary, inputSecondary, inputPrimaryOptions, inputSecondaryOptions) {
           this._imageWarnHistory = {};
           this.type = ResolvedImageType;
-          this.inputPrimary = inputPrimary;
-          this.inputSecondary = inputSecondary;
-          this.inputPrimaryParams = inputPrimaryParams;
-          this.inputSecondaryParams = inputSecondaryParams;
+          this.namePrimary = inputPrimary;
+          this.nameSecondary = inputSecondary;
+          if (inputPrimaryOptions) {
+              this.paramsPrimary = inputPrimaryOptions.params;
+              this.iconsetIdPrimary = inputPrimaryOptions.iconset ? inputPrimaryOptions.iconset.id : void 0;
+          }
+          if (inputSecondaryOptions) {
+              this.paramsSecondary = inputSecondaryOptions.params;
+              this.iconsetIdSecondary = inputSecondaryOptions.iconset ? inputSecondaryOptions.iconset.id : void 0;
+          }
       }
       static parse(args, context) {
           if (args.length < 2) {
@@ -13022,7 +13081,7 @@
                   }
                   imageExpression.push({
                       image: imageName,
-                      options: void 0
+                      options: {}
                   });
                   return true;
               }
@@ -13030,33 +13089,48 @@
           }
           function tryParseOptions() {
               if (nextArgId < args.length) {
-                  if (!isImageOptions(args[nextArgId])) {
+                  const options = args[nextArgId];
+                  if (!isImageOptions(options)) {
                       return true;
                   }
-                  const params = args[nextArgId].params;
+                  const params = options.params;
+                  const iconset = options.iconset;
                   const optionsContext = context.concat(nextArgId);
-                  if (!params) {
+                  if (!params && !iconset) {
                       nextArgId++;
                       return true;
                   }
-                  if (typeof params !== 'object' || params.constructor !== Object) {
-                      optionsContext.error(`Image options "params" should be an object`);
-                      return false;
+                  if (params) {
+                      if (typeof params !== 'object' || params.constructor !== Object) {
+                          optionsContext.error(`Image options "params" should be an object`);
+                          return false;
+                      }
+                      const parsedParams = {};
+                      const childContext = optionsContext.concat(void 0, 'params');
+                      for (const key in params) {
+                          if (!key) {
+                              childContext.error(`Image parameter name should be non-empty`);
+                              return false;
+                          }
+                          const value = childContext.concat(void 0, key).parse(params[key], void 0, ColorType, void 0, { typeAnnotation: 'coerce' });
+                          if (!value) {
+                              return false;
+                          }
+                          parsedParams[key] = value;
+                      }
+                      imageExpression[imageExpression.length - 1].options.params = parsedParams;
                   }
-                  const parsed = {};
-                  const childContext = optionsContext.concat(void 0, 'params');
-                  for (const key in params) {
-                      if (!key) {
-                          childContext.error(`Image parameter name should be non-empty`);
+                  if (iconset) {
+                      if (typeof iconset !== 'object' || iconset.constructor !== Object) {
+                          optionsContext.error(`Image options "iconset" should be an object`);
                           return false;
                       }
-                      const value = childContext.concat(void 0, key).parse(params[key], void 0, ColorType, void 0, { typeAnnotation: 'coerce' });
-                      if (!value) {
+                      if (!iconset.id) {
+                          optionsContext.error(`Image options "iconset" should have an "id" property`);
                           return false;
                       }
-                      parsed[key] = value;
+                      imageExpression[imageExpression.length - 1].options.iconset = iconset;
                   }
-                  imageExpression[imageExpression.length - 1].options = parsed;
                   nextArgId++;
                   return true;
               }
@@ -13099,30 +13173,41 @@
           return { params: result };
       }
       evaluate(ctx) {
-          const value = ResolvedImage.build(this.inputPrimary.evaluate(ctx), this.inputSecondary ? this.inputSecondary.evaluate(ctx) : void 0, this.inputPrimaryParams ? this.evaluateParams(ctx, this.inputPrimaryParams) : void 0, this.inputSecondaryParams ? this.evaluateParams(ctx, this.inputSecondaryParams) : void 0);
+          const primaryId = {
+              name: this.namePrimary.evaluate(ctx),
+              iconsetId: this.iconsetIdPrimary
+          };
+          const secondaryId = this.nameSecondary ? {
+              name: this.nameSecondary.evaluate(ctx),
+              iconsetId: this.iconsetIdSecondary
+          } : void 0;
+          const value = ResolvedImage.build(primaryId, secondaryId, this.paramsPrimary ? this.evaluateParams(ctx, this.paramsPrimary) : void 0, this.paramsSecondary ? this.evaluateParams(ctx, this.paramsSecondary) : void 0);
           if (value && ctx.availableImages) {
-              value.available = ctx.availableImages.indexOf(value.namePrimary) > -1;
-              if (value.nameSecondary && value.available && ctx.availableImages) {
-                  value.available = ctx.availableImages.indexOf(value.nameSecondary) > -1;
+              const primaryId2 = value.getPrimary().id;
+              value.available = ctx.availableImages.some(id => ImageId.isEqual(id, primaryId2));
+              if (value.available) {
+                  const secondaryId2 = value.getSecondary() ? value.getSecondary().id : null;
+                  if (secondaryId2)
+                      value.available = ctx.availableImages.some(id => ImageId.isEqual(id, secondaryId2));
               }
           }
           return value;
       }
       eachChild(fn) {
-          fn(this.inputPrimary);
-          if (this.inputPrimaryParams) {
-              for (const key in this.inputPrimaryParams) {
-                  if (this.inputPrimaryParams[key]) {
-                      fn(this.inputPrimaryParams[key]);
+          fn(this.namePrimary);
+          if (this.paramsPrimary) {
+              for (const key in this.paramsPrimary) {
+                  if (this.paramsPrimary[key]) {
+                      fn(this.paramsPrimary[key]);
                   }
               }
           }
-          if (this.inputSecondary) {
-              fn(this.inputSecondary);
-              if (this.inputSecondaryParams) {
-                  for (const key in this.inputSecondaryParams) {
-                      if (this.inputSecondaryParams[key]) {
-                          fn(this.inputSecondaryParams[key]);
+          if (this.nameSecondary) {
+              fn(this.nameSecondary);
+              if (this.paramsSecondary) {
+                  for (const key in this.paramsSecondary) {
+                      if (this.paramsSecondary[key]) {
+                          fn(this.paramsSecondary[key]);
                       }
                   }
               }
@@ -13131,31 +13216,37 @@
       outputDefined() {
           return false;
       }
-      serializeParams(params) {
+      serializeOptions(params, iconsetId) {
           const result = {};
+          if (iconsetId) {
+              result.iconset = { id: iconsetId };
+          }
           if (params) {
+              result.params = {};
               for (const key in params) {
                   if (params[key]) {
-                      result[key] = params[key].serialize();
+                      result.params[key] = params[key].serialize();
                   }
               }
-          } else {
-              return void 0;
           }
-          return { params: result };
+          return Object.keys(result).length > 0 ? result : void 0;
       }
       serialize() {
           const serialized = [
               'image',
-              this.inputPrimary.serialize()
+              this.namePrimary.serialize()
           ];
-          if (this.inputPrimaryParams) {
-              serialized.push(this.serializeParams(this.inputPrimaryParams));
+          if (this.paramsPrimary || this.iconsetIdPrimary) {
+              const options = this.serializeOptions(this.paramsPrimary, this.iconsetIdPrimary);
+              if (options)
+                  serialized.push(options);
           }
-          if (this.inputSecondary) {
-              serialized.push(this.inputSecondary.serialize());
-              if (this.inputSecondaryParams) {
-                  serialized.push(this.serializeParams(this.inputSecondaryParams));
+          if (this.nameSecondary) {
+              serialized.push(this.nameSecondary.serialize());
+              if (this.paramsSecondary || this.iconsetIdSecondary) {
+                  const options = this.serializeOptions(this.paramsSecondary, this.iconsetIdSecondary);
+                  if (options)
+                      serialized.push(options);
               }
           }
           return serialized;