@ni/nimble-components 34.10.3 → 35.0.0

package/dist/all-components-bundle.js

@@ -76888,7 +76888,7 @@ focus outline in that case.
   /**
    * A formatter for units that can be formatted/translated by Intl.NumberFormat
    */
-  class IntlNumberFormatScaledUnitFormat extends ScaledUnitFormat {
+  class ScaledUnitFormatIntlNumberFormat extends ScaledUnitFormat {
       constructor(scaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions) {
           super(scaledUnitFormatFactoryOptions);
           this.formatter = new Intl.NumberFormat(this.locale, {
@@ -76898,7 +76898,7 @@ focus outline in that case.
           });
       }
       static createFactory(unitSpecificIntlNumberFormatOptions) {
-          return (scaledUnitFormatFactoryOptions) => new IntlNumberFormatScaledUnitFormat(scaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions);
+          return (scaledUnitFormatFactoryOptions) => new ScaledUnitFormatIntlNumberFormat(scaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions);
       }
       format(value) {
           return this.formatter.format(value);
@@ -76970,14 +76970,14 @@ focus outline in that case.
   /**
    * Unit scale that is used to passthrough a number without applying scaling or units
    */
-  class PassthroughUnitScale extends UnitScale {
+  class UnitScalePassthrough extends UnitScale {
       constructor() {
           super([
-              new ScaledUnit(10 ** 0, IntlNumberFormatScaledUnitFormat.createFactory({}))
+              new ScaledUnit(10 ** 0, ScaledUnitFormatIntlNumberFormat.createFactory({}))
           ]);
       }
   }
-  const passthroughUnitScale = new PassthroughUnitScale();
+  const unitScalePassthrough = new UnitScalePassthrough();
 
   // Workaround to avoid ts errors about signDisplay not accepting the value 'negative'.
   // It has been supported by browsers since 8/23, but TypeScript still hasn't
@@ -76987,15 +76987,15 @@ focus outline in that case.
    * Format for numbers with units to show in a tabular form.
    * Large and tiny numbers are shown exponentially and the rest as decimal.
    */
-  class DefaultUnitFormat extends UnitFormat {
-      constructor(locale, { unitScale = passthroughUnitScale } = {
-          unitScale: passthroughUnitScale
+  class UnitFormatDefault extends UnitFormat {
+      constructor(locale, { unitScale = unitScalePassthrough } = {
+          unitScale: unitScalePassthrough
       }) {
           super();
           // Format options to use by default. It renders the number with a maximum of 6 signficant digits (including zero before decimal point).
           this.defaultIntlNumberFormatOptions = {
-              maximumSignificantDigits: DefaultUnitFormat.maximumDigits,
-              maximumFractionDigits: DefaultUnitFormat.maximumDigits - 1,
+              maximumSignificantDigits: UnitFormatDefault.maximumDigits,
+              maximumFractionDigits: UnitFormatDefault.maximumDigits - 1,
               roundingPriority: 'lessPrecision',
               signDisplay
           };
@@ -77003,7 +77003,7 @@ focus outline in that case.
           // Format options for numbers that should be displayed in exponential notation. This should be used
           // for numbers with magintudes over 'exponentialUpperBound' or under 'exponentialLowerBound'.
           this.exponentialIntlNumberFormatOptions = {
-              maximumSignificantDigits: DefaultUnitFormat.maximumDigits,
+              maximumSignificantDigits: UnitFormatDefault.maximumDigits,
               notation: 'scientific',
               signDisplay
           };
@@ -77028,8 +77028,8 @@ focus outline in that case.
           const { scaledValue, scaledUnit } = this.unitScale.scaleNumber(number);
           const absoluteValue = Math.abs(scaledValue);
           const useExponential = absoluteValue !== 0
-              && (absoluteValue >= DefaultUnitFormat.exponentialUpperBound
-                  || absoluteValue < DefaultUnitFormat.exponentialLowerBound);
+              && (absoluteValue >= UnitFormatDefault.exponentialUpperBound
+                  || absoluteValue < UnitFormatDefault.exponentialLowerBound);
           return useExponential
               ? this.exponentialScaledUnitFormatter.format(number)
               : this.defaultScaledUnitFormatters
@@ -77038,23 +77038,23 @@ focus outline in that case.
       }
   }
   // The maximum number of digits that should be rendered for any given value.
-  DefaultUnitFormat.maximumDigits = 6;
+  UnitFormatDefault.maximumDigits = 6;
   // Use exponential notation for numbers that will be rendered with 3 leading 0s or more.
   // Because a maximum of 6 digits are rendered, showing more than 3 leading 0s is not ideal
   // because then at least half of the displayed digits will be leading 0s.
-  DefaultUnitFormat.exponentialLowerBound = 0.000995;
+  UnitFormatDefault.exponentialLowerBound = 0.000995;
   // Use exponential formatting for numbers whose magnitude cannot otherwise be displayed
   // with 6 digits or less.
-  DefaultUnitFormat.exponentialUpperBound = 999999.5;
+  UnitFormatDefault.exponentialUpperBound = 999999.5;
 
   /**
    * Format for decimal numbers with units.
    */
-  class DecimalUnitFormat extends UnitFormat {
-      constructor(locale, { minimumFractionDigits = 0, maximumFractionDigits = Math.max(3, minimumFractionDigits), unitScale = passthroughUnitScale } = {
+  class UnitFormatDecimal extends UnitFormat {
+      constructor(locale, { minimumFractionDigits = 0, maximumFractionDigits = Math.max(3, minimumFractionDigits), unitScale = unitScalePassthrough } = {
           minimumFractionDigits: 0,
           maximumFractionDigits: 3,
-          unitScale: passthroughUnitScale
+          unitScale: unitScalePassthrough
       }) {
           super();
           this.scaledUnitFormatters = new Map();
@@ -77094,7 +77094,7 @@ focus outline in that case.
   /**
    * Format for numbers (with optional units) in a number-text table column.
    */
-  class NumberTextUnitFormat extends UnitFormat {
+  class UnitFormatNumberText extends UnitFormat {
       constructor(locale, options) {
           super();
           this._resolvedOptions = this.resolveOptions(options);
@@ -77119,18 +77119,18 @@ focus outline in that case.
       resolveUnitFormat(locale, options) {
           const { numberTextFormat, decimalMaximumDigits, decimalDigits, unitScale } = options;
           if (numberTextFormat === NumberTextFormat.default) {
-              return new DefaultUnitFormat(locale, {
+              return new UnitFormatDefault(locale, {
                   unitScale
               });
           }
           if (typeof decimalDigits === 'number') {
-              return new DecimalUnitFormat(locale, {
+              return new UnitFormatDecimal(locale, {
                   minimumFractionDigits: decimalDigits,
                   maximumFractionDigits: decimalDigits,
                   unitScale
               });
           }
-          return new DecimalUnitFormat(locale, {
+          return new UnitFormatDecimal(locale, {
               minimumFractionDigits: 0,
               maximumFractionDigits: decimalMaximumDigits,
               unitScale
@@ -77142,7 +77142,7 @@ focus outline in that case.
                   numberTextFormat: NumberTextFormat.default,
                   decimalDigits: undefined,
                   decimalMaximumDigits: undefined,
-                  unitScale: options?.unitScale ?? passthroughUnitScale
+                  unitScale: options?.unitScale ?? unitScalePassthrough
               };
           }
           const hasDecimalDigits = typeof options.decimalDigits === 'number';
@@ -77153,20 +77153,20 @@ focus outline in that case.
           if (!hasDecimalDigits && !hasDecimalMaximumDigits) {
               return {
                   numberTextFormat: NumberTextFormat.decimal,
-                  decimalDigits: NumberTextUnitFormat.defaultDecimalDigits,
+                  decimalDigits: UnitFormatNumberText.defaultDecimalDigits,
                   decimalMaximumDigits: undefined,
-                  unitScale: options.unitScale ?? passthroughUnitScale
+                  unitScale: options.unitScale ?? unitScalePassthrough
               };
           }
           return {
               numberTextFormat: NumberTextFormat.decimal,
               decimalDigits: options.decimalDigits,
               decimalMaximumDigits: options.decimalMaximumDigits,
-              unitScale: options.unitScale ?? passthroughUnitScale
+              unitScale: options.unitScale ?? unitScalePassthrough
           };
       }
   }
-  NumberTextUnitFormat.defaultDecimalDigits = 2;
+  UnitFormatNumberText.defaultDecimalDigits = 2;
 
   const numberTextValidityFlagNames = [
       'invalidDecimalDigits',
@@ -77325,7 +77325,7 @@ focus outline in that case.
       }
       createFormatter() {
           const unitScale = this.unit?.resolvedUnitScale;
-          return new NumberTextUnitFormat(lang.getValueFor(this), {
+          return new UnitFormatNumberText(lang.getValueFor(this), {
               // Attribute values sometimes resolve to either null or undefined
               // See https://github.com/microsoft/fast/issues/6630
               numberTextFormat: this.format ?? undefined,
@@ -78921,8 +78921,6 @@ focus outline in that case.
   });
   DesignSystem.getOrCreate().withPrefix('nimble').register(nimbleTreeView());
 
-  const template$1 = html `<template slot="unit"></template>`;
-
   /**
    * Representations of a unit in a particular language
    */
@@ -78936,7 +78934,7 @@ focus outline in that case.
   /**
    * A formatter for units that are not supported by Intl.NumberFormat
    */
-  class ManuallyTranslatedScaledUnitFormat extends ScaledUnitFormat {
+  class ScaledUnitFormatManuallyTranslated extends ScaledUnitFormat {
       constructor(scaledUnitFormatFactoryOptions, { unitTranslations, scaledPrefixText }) {
           super(scaledUnitFormatFactoryOptions);
           if (!unitTranslations.get('en')) {
@@ -78947,8 +78945,8 @@ focus outline in that case.
           this.unitTranslation = this.getTranslationToUse(unitTranslations, this.locale);
           this.scaledPrefixText = scaledPrefixText;
       }
-      static createFactory(manuallyTranslatedScaledUnitFormatOptions) {
-          return (scaledUnitFormatFactoryOptions) => new ManuallyTranslatedScaledUnitFormat(scaledUnitFormatFactoryOptions, manuallyTranslatedScaledUnitFormatOptions);
+      static createFactory(scaledUnitFormatManuallyTranslatedOptions) {
+          return (scaledUnitFormatFactoryOptions) => new ScaledUnitFormatManuallyTranslated(scaledUnitFormatFactoryOptions, scaledUnitFormatManuallyTranslatedOptions);
       }
       format(value) {
           const formatted = this.formatter.format(value);
@@ -79003,17 +79001,17 @@ focus outline in that case.
   /**
    * Byte units (1024-based)
    */
-  class Byte1024UnitScale extends UnitScale {
+  class UnitScaleByte1024 extends UnitScale {
       constructor() {
-          super(byte1024Prefixes.map(([scaleFactor, scaledPrefixText]) => new ScaledUnit(scaleFactor, ManuallyTranslatedScaledUnitFormat.createFactory({
+          super(byte1024Prefixes.map(([scaleFactor, scaledPrefixText]) => new ScaledUnit(scaleFactor, ScaledUnitFormatManuallyTranslated.createFactory({
               unitTranslations: unitTranslations$1,
               scaledPrefixText
           }))));
       }
   }
-  const byte1024UnitScale = new Byte1024UnitScale();
+  const unitScaleByte1024 = new UnitScaleByte1024();
 
-  const byteUnitScaleOptions = [
+  const unitScaleByteConfig = [
       [1000 ** 0, 'byte', 'long'],
       [1000 ** 1, 'kilobyte', 'short'],
       [1000 ** 2, 'megabyte', 'short'],
@@ -79024,16 +79022,18 @@ focus outline in that case.
   /**
    * Byte units (1000-based)
    */
-  class ByteUnitScale extends UnitScale {
+  class UnitScaleByte extends UnitScale {
       constructor() {
-          super(byteUnitScaleOptions.map(([scaleFactor, unit, unitDisplay]) => new ScaledUnit(scaleFactor, IntlNumberFormatScaledUnitFormat.createFactory({
+          super(unitScaleByteConfig.map(([scaleFactor, unit, unitDisplay]) => new ScaledUnit(scaleFactor, ScaledUnitFormatIntlNumberFormat.createFactory({
               style: 'unit',
               unit,
               unitDisplay
           }))));
       }
   }
-  const byteUnitScale = new ByteUnitScale();
+  const unitScaleByte = new UnitScaleByte();
+
+  const template$1 = html `<template slot="unit"></template>`;
 
   const styles$1 = css `
     ${display('none')}
@@ -79050,12 +79050,12 @@ focus outline in that case.
            * the default of decimal (base 1000 scale with metric prefixes)
            */
           this.binary = false;
-          this.resolvedUnitScale = byteUnitScale;
+          this.resolvedUnitScale = unitScaleByte;
       }
       binaryChanged() {
           this.resolvedUnitScale = this.binary
-              ? byte1024UnitScale
-              : byteUnitScale;
+              ? unitScaleByte1024
+              : unitScaleByte;
       }
   }
   __decorate([
@@ -79095,15 +79095,15 @@ focus outline in that case.
   /**
    * Voltage unit scale
    */
-  class VoltUnitScale extends UnitScale {
+  class UnitScaleVolt extends UnitScale {
       constructor() {
-          super(metricPrefixes.map(([scaleFactor, scaledPrefixText]) => new ScaledUnit(scaleFactor, ManuallyTranslatedScaledUnitFormat.createFactory({
+          super(metricPrefixes.map(([scaleFactor, scaledPrefixText]) => new ScaledUnit(scaleFactor, ScaledUnitFormatManuallyTranslated.createFactory({
               unitTranslations,
               scaledPrefixText
           }))));
       }
   }
-  const voltUnitScale = new VoltUnitScale();
+  const unitScaleVolt = new UnitScaleVolt();
 
   /**
    * Element representing units for volts
@@ -79111,7 +79111,7 @@ focus outline in that case.
   class UnitVolt extends Unit {
       constructor() {
           super();
-          this.resolvedUnitScale = voltUnitScale;
+          this.resolvedUnitScale = unitScaleVolt;
       }
   }
   const nimbleUnitVolt = UnitVolt.compose({