@ni/nimble-components 34.10.2 → 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({
@@ -83206,28 +83206,33 @@ focus outline in that case.
           return this.bytes_.length;
       }
       readInt8(offset) {
-          return this.readUint8(offset) << 24 >> 24;
+          return (this.readUint8(offset) << 24) >> 24;
       }
       readUint8(offset) {
           return this.bytes_[offset];
       }
       readInt16(offset) {
-          return this.readUint16(offset) << 16 >> 16;
+          return (this.readUint16(offset) << 16) >> 16;
       }
       readUint16(offset) {
-          return this.bytes_[offset] | this.bytes_[offset + 1] << 8;
+          return this.bytes_[offset] | (this.bytes_[offset + 1] << 8);
       }
       readInt32(offset) {
-          return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;
+          return (this.bytes_[offset] |
+              (this.bytes_[offset + 1] << 8) |
+              (this.bytes_[offset + 2] << 16) |
+              (this.bytes_[offset + 3] << 24));
       }
       readUint32(offset) {
           return this.readInt32(offset) >>> 0;
       }
       readInt64(offset) {
-          return BigInt.asIntN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+          return BigInt.asIntN(64, BigInt(this.readUint32(offset)) +
+              (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
       }
       readUint64(offset) {
-          return BigInt.asUintN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
+          return BigInt.asUintN(64, BigInt(this.readUint32(offset)) +
+              (BigInt(this.readUint32(offset + 4)) << BigInt(32)));
       }
       readFloat32(offset) {
           int32[0] = this.readInt32(offset);
@@ -83287,11 +83292,11 @@ focus outline in that case.
        * start of a the root vtable).
        */
       getBufferIdentifier() {
-          if (this.bytes_.length < this.position_ + SIZEOF_INT +
-              FILE_IDENTIFIER_LENGTH) {
+          if (this.bytes_.length <
+              this.position_ + SIZEOF_INT + FILE_IDENTIFIER_LENGTH) {
               throw new Error('FlatBuffers: ByteBuffer is too short to contain an identifier.');
           }
-          let result = "";
+          let result = '';
           for (let i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {
               result += String.fromCharCode(this.readInt8(this.position_ + SIZEOF_INT + i));
           }
@@ -83303,7 +83308,9 @@ focus outline in that case.
        */
       __offset(bb_pos, vtable_offset) {
           const vtable = bb_pos - this.readInt32(bb_pos);
-          return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
+          return vtable_offset < this.readInt16(vtable)
+              ? this.readInt16(vtable + vtable_offset)
+              : 0;
       }
       /**
        * Initialize any Table-derived type to point to the union at the given offset.
@@ -83367,8 +83374,7 @@ focus outline in that case.
       }
       __has_identifier(ident) {
           if (ident.length != FILE_IDENTIFIER_LENGTH) {
-              throw new Error('FlatBuffers: file identifier must be length ' +
-                  FILE_IDENTIFIER_LENGTH);
+              throw new Error('FlatBuffers: file identifier must be length ' + FILE_IDENTIFIER_LENGTH);
           }
           for (let i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {
               if (ident.charCodeAt(i) != this.readInt8(this.position() + SIZEOF_INT + i)) {
@@ -83481,7 +83487,9 @@ focus outline in that case.
        * called finish().
        */
       asUint8Array() {
-          return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
+          return this.bb
+              .bytes()
+              .subarray(this.bb.position(), this.bb.position() + this.offset());
       }
       /**
        * Prepare to write an element of `size` after `additional_bytes` have been
@@ -83499,7 +83507,7 @@ focus outline in that case.
           }
           // Find the amount of alignment needed such that `size` is properly
           // aligned after `additional_bytes`
-          const align_size = ((~(this.bb.capacity() - this.space + additional_bytes)) + 1) & (size - 1);
+          const align_size = (~(this.bb.capacity() - this.space + additional_bytes) + 1) & (size - 1);
           // Reallocate the buffer if needed.
           while (this.space < align_size + size + additional_bytes) {
               const old_buf_size = this.bb.capacity();
@@ -83514,22 +83522,22 @@ focus outline in that case.
           }
       }
       writeInt8(value) {
-          this.bb.writeInt8(this.space -= 1, value);
+          this.bb.writeInt8((this.space -= 1), value);
       }
       writeInt16(value) {
-          this.bb.writeInt16(this.space -= 2, value);
+          this.bb.writeInt16((this.space -= 2), value);
       }
       writeInt32(value) {
-          this.bb.writeInt32(this.space -= 4, value);
+          this.bb.writeInt32((this.space -= 4), value);
       }
       writeInt64(value) {
-          this.bb.writeInt64(this.space -= 8, value);
+          this.bb.writeInt64((this.space -= 8), value);
       }
       writeFloat32(value) {
-          this.bb.writeFloat32(this.space -= 4, value);
+          this.bb.writeFloat32((this.space -= 4), value);
       }
       writeFloat64(value) {
-          this.bb.writeFloat64(this.space -= 8, value);
+          this.bb.writeFloat64((this.space -= 8), value);
       }
       /**
        * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
@@ -83677,7 +83685,7 @@ focus outline in that case.
       static growByteBuffer(bb) {
           const old_buf_size = bb.capacity();
           // Ensure we don't grow beyond what fits in an int.
-          if (old_buf_size & 0xC0000000) {
+          if (old_buf_size & 0xc0000000) {
               throw new Error('FlatBuffers: cannot grow buffer beyond 2 gigabytes.');
           }
           const new_buf_size = old_buf_size << 1;
@@ -83776,8 +83784,7 @@ focus outline in that case.
           const size_prefix = opt_size_prefix ? SIZE_PREFIX_LENGTH : 0;
           if (opt_file_identifier) {
               const file_identifier = opt_file_identifier;
-              this.prep(this.minalign, SIZEOF_INT +
-                  FILE_IDENTIFIER_LENGTH + size_prefix);
+              this.prep(this.minalign, SIZEOF_INT + FILE_IDENTIFIER_LENGTH + size_prefix);
               if (file_identifier.length != FILE_IDENTIFIER_LENGTH) {
                   throw new TypeError('FlatBuffers: file identifier must be length ' +
                       FILE_IDENTIFIER_LENGTH);
@@ -83880,7 +83887,7 @@ focus outline in that case.
           }
           this.addInt8(0);
           this.startVector(1, utf8.length, 1);
-          this.bb.setPosition(this.space -= utf8.length);
+          this.bb.setPosition((this.space -= utf8.length));
           this.bb.bytes().set(utf8, this.space);
           return this.endVector();
       }
@@ -83895,7 +83902,7 @@ focus outline in that case.
               return 0;
           }
           this.startVector(1, v.length, 1);
-          this.bb.setPosition(this.space -= v.length);
+          this.bb.setPosition((this.space -= v.length));
           this.bb.bytes().set(v, this.space);
           return this.endVector();
       }