@ni/nimble-components 20.18.0 → 20.18.1

package/dist/all-components-bundle.js

@@ -16301,7 +16301,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Wed, 17 Jan 2024 14:08:42 GMT
+   * Generated on Thu, 18 Jan 2024 17:06:46 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -66460,7 +66460,7 @@ img.ProseMirror-separator {
    * A formatter for units that can be formatted/translated by Intl.NumberFormat
    */
   class IntlNumberFormatScaledUnitFormat extends ScaledUnitFormat {
-      constructor(scaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions = {}) {
+      constructor(scaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions) {
           super(scaledUnitFormatFactoryOptions);
           this.formatter = new Intl.NumberFormat(this.locale, {
               ...unitSpecificIntlNumberFormatOptions,
@@ -66468,7 +66468,7 @@ img.ProseMirror-separator {
               ...this.intlNumberFormatOptions
           });
       }
-      static createFactory(unitSpecificIntlNumberFormatOptions = {}) {
+      static createFactory(unitSpecificIntlNumberFormatOptions) {
           return (scaledUnitFormatFactoryOptions) => new IntlNumberFormatScaledUnitFormat(scaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions);
       }
       format(value) {
@@ -66544,7 +66544,7 @@ img.ProseMirror-separator {
   class PassthroughUnitScale extends UnitScale {
       constructor() {
           super([
-              new ScaledUnit(10 ** 0, IntlNumberFormatScaledUnitFormat.createFactory())
+              new ScaledUnit(10 ** 0, IntlNumberFormatScaledUnitFormat.createFactory({}))
           ]);
       }
   }
@@ -68527,25 +68527,38 @@ img.ProseMirror-separator {
 
   const template$1 = html `<template slot="unit"></template>`;
 
+  /**
+   * Representations of a unit in a particular language
+   */
+  class UnitTranslation {
+      constructor(singular, plural, symbol) {
+          this.singular = singular;
+          this.plural = plural;
+          this.symbol = symbol;
+      }
+  }
   /**
    * A formatter for units that are not supported by Intl.NumberFormat
    */
   class ManuallyTranslatedScaledUnitFormat extends ScaledUnitFormat {
-      constructor(scaledUnitFormatFactoryOptions, unitTranslations, unitPrefix) {
+      constructor(scaledUnitFormatFactoryOptions, { unitTranslations, scaledPrefixText }) {
           super(scaledUnitFormatFactoryOptions);
-          this.unitTranslations = unitTranslations;
-          this.unitPrefix = unitPrefix;
+          if (!unitTranslations.get('en')) {
+              throw new Error('English translations must exist with locale string "en"');
+          }
           this.pluralRules = new Intl.PluralRules(this.locale);
           this.formatter = new Intl.NumberFormat(this.locale, this.intlNumberFormatOptions);
-          this.unitTranslation = this.getTranslationToUse(this.locale);
+          this.unitTranslation = this.getTranslationToUse(unitTranslations, this.locale);
+          this.scaledPrefixText = scaledPrefixText;
       }
-      static createFactory(unitTranslations, unitPrefix) {
-          return (scaledUnitFormatFactoryOptions) => new ManuallyTranslatedScaledUnitFormat(scaledUnitFormatFactoryOptions, unitTranslations, unitPrefix);
+      static createFactory(manuallyTranslatedScaledUnitFormatOptions) {
+          return (scaledUnitFormatFactoryOptions) => new ManuallyTranslatedScaledUnitFormat(scaledUnitFormatFactoryOptions, manuallyTranslatedScaledUnitFormatOptions);
       }
       format(value) {
           const formatted = this.formatter.format(value);
-          if (!this.unitPrefix.isBase()) {
-              return `${formatted} ${this.unitPrefix.text}${this.unitTranslation.symbol}`;
+          // For non-base units (which are a scaled prefix text of empty string)
+          if (this.scaledPrefixText !== '') {
+              return `${formatted} ${this.scaledPrefixText}${this.unitTranslation.symbol}`;
           }
           // Some languages have more than two forms (singular/plural) of cardinal
           // numbers, but we are treating anything other than the 'one' form as plural.
@@ -68562,123 +68575,65 @@ img.ProseMirror-separator {
               : this.unitTranslation.plural;
           return `${formatted} ${unitLabel}`;
       }
-      getTranslationToUse(locale) {
+      getTranslationToUse(unitTranslations, locale) {
           const localeObject = new Intl.Locale(locale ?? 'en');
           const language = localeObject.language;
           const region = localeObject.region;
           const regionSpecificMatchedTranslations = region
-              ? this.unitTranslations.get(`${language}-${region}`) // do not include any other subtags that might be in the given locale string
-              : null;
+              ? unitTranslations.get(`${language}-${region}`)
+              : undefined;
           return (regionSpecificMatchedTranslations
-              ?? this.unitTranslations.get(language)
-              ?? this.unitTranslations.get('en'));
-      }
-  }
-
-  /**
-   * A unit scale that is not supported by Intl.NumberFormat and has manually provided translation strings
-   */
-  class ManuallyTranslatedUnitScale extends UnitScale {
-      constructor(unitTranslations, supportedUnitPrefixes) {
-          super(ManuallyTranslatedUnitScale.createSupportedScaledUnits(unitTranslations, supportedUnitPrefixes));
-      }
-      static createSupportedScaledUnits(unitTranslations, supportedUnitPrefixes) {
-          if (!unitTranslations.get('en')) {
-              throw new Error('English translations must exist');
-          }
-          const supportedUnits = supportedUnitPrefixes.map(unitPrefix => new ScaledUnit(unitPrefix.scaleFactor, ManuallyTranslatedScaledUnitFormat.createFactory(unitTranslations, unitPrefix)));
-          return supportedUnits;
-      }
-  }
-
-  /**
-   * A prefix that represents a scaling factor when applied to a base unit.
-   * A base unit is represented as scale factor 1 and empty text.
-   */
-  class UnitPrefix {
-      constructor(scaleFactor, text) {
-          this.scaleFactor = scaleFactor;
-          this.text = text;
-          if (scaleFactor === 1 && text !== '') {
-              throw new Error('Base scale factor of 1 has unused text and should be empty string');
-          }
-      }
-      isBase() {
-          return this.scaleFactor === 1;
-      }
-  }
-
-  /**
-   * Representations of a base unit in a particular language
-   */
-  class UnitTranslation {
-      constructor(singular, plural, symbol) {
-          this.singular = singular;
-          this.plural = plural;
-          this.symbol = symbol;
+              ?? unitTranslations.get(language)
+              ?? unitTranslations.get('en'));
       }
   }
 
+  const unitTranslations$1 = new Map([
+      ['en', new UnitTranslation('byte', 'bytes', 'B')],
+      ['fr', new UnitTranslation('octet', 'octets', 'o')],
+      ['de', new UnitTranslation('Byte', 'Byte', 'B')],
+      ['ja', new UnitTranslation('バイト', 'バイト', 'B')],
+      ['zh', new UnitTranslation('字节', '字节', 'B')]
+  ]);
+  const byte1024Prefixes = [
+      [1024 ** 0, ''],
+      [1024 ** 1, 'Ki'],
+      [1024 ** 2, 'Mi'],
+      [1024 ** 3, 'Gi'],
+      [1024 ** 4, 'Ti'],
+      [1024 ** 5, 'Pi']
+  ];
   /**
    * Byte units (1024-based)
    */
-  class Byte1024UnitScale extends ManuallyTranslatedUnitScale {
+  class Byte1024UnitScale extends UnitScale {
       constructor() {
-          super(new Map([
-              ['en', new UnitTranslation('byte', 'bytes', 'B')],
-              ['fr', new UnitTranslation('octet', 'octets', 'o')],
-              ['de', new UnitTranslation('Byte', 'Byte', 'B')],
-              ['ja', new UnitTranslation('バイト', 'バイト', 'B')],
-              ['zh', new UnitTranslation('字节', '字节', 'B')]
-          ]), [
-              new UnitPrefix(1024 ** 0, ''),
-              new UnitPrefix(1024 ** 1, 'Ki'),
-              new UnitPrefix(1024 ** 2, 'Mi'),
-              new UnitPrefix(1024 ** 3, 'Gi'),
-              new UnitPrefix(1024 ** 4, 'Ti'),
-              new UnitPrefix(1024 ** 5, 'Pi')
-          ]);
+          super(byte1024Prefixes.map(([scaleFactor, scaledPrefixText]) => new ScaledUnit(scaleFactor, ManuallyTranslatedScaledUnitFormat.createFactory({
+              unitTranslations: unitTranslations$1,
+              scaledPrefixText
+          }))));
       }
   }
   const byte1024UnitScale = new Byte1024UnitScale();
 
+  const byteUnitScaleOptions = [
+      [1000 ** 0, 'byte', 'long'],
+      [1000 ** 1, 'kilobyte', 'short'],
+      [1000 ** 2, 'megabyte', 'short'],
+      [1000 ** 3, 'gigabyte', 'short'],
+      [1000 ** 4, 'terabyte', 'short'],
+      [1000 ** 5, 'petabyte', 'short']
+  ];
   /**
    * Byte units (1000-based)
    */
   class ByteUnitScale extends UnitScale {
       constructor() {
-          super([
-              new ScaledUnit(10 ** 0, IntlNumberFormatScaledUnitFormat.createFactory({
-                  style: 'unit',
-                  unit: 'byte',
-                  unitDisplay: 'long'
-              })),
-              new ScaledUnit(10 ** 3, IntlNumberFormatScaledUnitFormat.createFactory({
-                  style: 'unit',
-                  unit: 'kilobyte',
-                  unitDisplay: 'short'
-              })),
-              new ScaledUnit(10 ** 6, IntlNumberFormatScaledUnitFormat.createFactory({
-                  style: 'unit',
-                  unit: 'megabyte',
-                  unitDisplay: 'short'
-              })),
-              new ScaledUnit(10 ** 9, IntlNumberFormatScaledUnitFormat.createFactory({
-                  style: 'unit',
-                  unit: 'gigabyte',
-                  unitDisplay: 'short'
-              })),
-              new ScaledUnit(10 ** 12, IntlNumberFormatScaledUnitFormat.createFactory({
-                  style: 'unit',
-                  unit: 'terabyte',
-                  unitDisplay: 'short'
-              })),
-              new ScaledUnit(10 ** 15, IntlNumberFormatScaledUnitFormat.createFactory({
-                  style: 'unit',
-                  unit: 'petabyte',
-                  unitDisplay: 'short'
-              }))
-          ]);
+          super(byteUnitScaleOptions.map(([scaleFactor, unit, unitDisplay]) => new ScaledUnit(scaleFactor, IntlNumberFormatScaledUnitFormat.createFactory({
+              style: 'unit',
+              unit,
+              unitDisplay
+          }))));
       }
   }
   const byteUnitScale = new ByteUnitScale();
@@ -68711,38 +68666,39 @@ img.ProseMirror-separator {
   });
   DesignSystem.getOrCreate().withPrefix('nimble').register(nimbleUnitByte());
 
-  /**
-   * The metric unit prefixes for at least English, French, German, Japanese, and Chinese.
-   */
-  const unitPrefixesMetric = [
-      new UnitPrefix(10 ** -15, 'f'),
-      new UnitPrefix(10 ** -12, 'p'),
-      new UnitPrefix(10 ** -9, 'n'),
-      new UnitPrefix(10 ** -6, 'μ'),
-      new UnitPrefix(10 ** -3, 'm'),
-      new UnitPrefix(10 ** -2, 'c'),
-      new UnitPrefix(10 ** -1, 'd'),
-      new UnitPrefix(10 ** 0, ''),
-      new UnitPrefix(10 ** 3, 'k'),
-      new UnitPrefix(10 ** 6, 'M'),
-      new UnitPrefix(10 ** 9, 'G'),
-      new UnitPrefix(10 ** 12, 'T'),
-      new UnitPrefix(10 ** 15, 'P'),
-      new UnitPrefix(10 ** 18, 'E')
+  const metricPrefixes = [
+      [10 ** -15, 'f'],
+      [10 ** -12, 'p'],
+      [10 ** -9, 'n'],
+      [10 ** -6, 'μ'],
+      [10 ** -3, 'm'],
+      [10 ** -2, 'c'],
+      [10 ** -1, 'd'],
+      [10 ** 0, ''],
+      [10 ** 3, 'k'],
+      [10 ** 6, 'M'],
+      [10 ** 9, 'G'],
+      [10 ** 12, 'T'],
+      [10 ** 15, 'P'],
+      [10 ** 18, 'E']
   ];
 
+  const unitTranslations = new Map([
+      ['en', new UnitTranslation('volt', 'volts', 'V')],
+      ['fr', new UnitTranslation('volt', 'volts', 'V')],
+      ['de', new UnitTranslation('Volt', 'Volt', 'V')],
+      ['ja', new UnitTranslation('ボルト', 'ボルト', 'V')],
+      ['zh', new UnitTranslation('伏特', '伏特', 'V')]
+  ]);
   /**
    * Voltage unit scale
    */
-  class VoltUnitScale extends ManuallyTranslatedUnitScale {
+  class VoltUnitScale extends UnitScale {
       constructor() {
-          super(new Map([
-              ['en', new UnitTranslation('volt', 'volts', 'V')],
-              ['fr', new UnitTranslation('volt', 'volts', 'V')],
-              ['de', new UnitTranslation('Volt', 'Volt', 'V')],
-              ['ja', new UnitTranslation('ボルト', 'ボルト', 'V')],
-              ['zh', new UnitTranslation('伏特', '伏特', 'V')]
-          ]), unitPrefixesMetric);
+          super(metricPrefixes.map(([scaleFactor, scaledPrefixText]) => new ScaledUnit(scaleFactor, ManuallyTranslatedScaledUnitFormat.createFactory({
+              unitTranslations,
+              scaledPrefixText
+          }))));
       }
   }
   const voltUnitScale = new VoltUnitScale();