@ni/ok-components 0.1.23 → 0.1.24

package/dist/all-components-bundle.js

@@ -76889,7 +76889,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, {
@@ -76899,7 +76899,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);
@@ -76971,14 +76971,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
@@ -76988,15 +76988,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
           };
@@ -77004,7 +77004,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
           };
@@ -77029,8 +77029,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
@@ -77039,23 +77039,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();
@@ -77095,7 +77095,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);
@@ -77120,18 +77120,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
@@ -77143,7 +77143,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';
@@ -77154,20 +77154,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',
@@ -77326,7 +77326,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,
@@ -78922,8 +78922,6 @@ focus outline in that case.
   });
   DesignSystem.getOrCreate().withPrefix('nimble').register(nimbleTreeView());
 
-  const template$6 = html `<template slot="unit"></template>`;
-
   /**
    * Representations of a unit in a particular language
    */
@@ -78937,7 +78935,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')) {
@@ -78948,8 +78946,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);
@@ -79004,17 +79002,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'],
@@ -79025,16 +79023,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$6 = html `<template slot="unit"></template>`;
 
   const styles$6 = css `
     ${display$2('none')}
@@ -79051,12 +79051,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([
@@ -79096,15 +79096,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
@@ -79112,7 +79112,7 @@ focus outline in that case.
   class UnitVolt extends Unit {
       constructor() {
           super();
-          this.resolvedUnitScale = voltUnitScale;
+          this.resolvedUnitScale = unitScaleVolt;
       }
   }
   const nimbleUnitVolt = UnitVolt.compose({