@ni/nimble-components 21.6.6 → 21.6.8

package/dist/all-components-bundle.js

@@ -16301,7 +16301,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Fri, 23 Feb 2024 22:02:36 GMT
+   * Generated on Mon, 26 Feb 2024 22:10:53 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -58741,16 +58741,22 @@ img.ProseMirror-separator {
   DesignSystem.getOrCreate().withPrefix('nimble').register(nimbleSelect());
 
   const styles$n = css `
-    ${display('inline-flex')}
+    ${display('inline-grid')}
 
     :host {
         height: ${spinnerSmallHeight};
         aspect-ratio: 1 / 1;
     }
 
+    div.overlay {
+        z-index: ${ZIndexLevels.zIndex1};
+        margin: max(2px, 6.25%);
+        grid-area: 1/1;
+    }
+
     div.container {
         margin: max(2px, 6.25%);
-        flex: 1;
+        grid-area: 1/1;
         ${
 /**
  * At some spinner sizes / browser zoom levels, the spinner bits/squares appear to slightly overlap visually.
@@ -58902,8 +58908,19 @@ img.ProseMirror-separator {
             }
         `));
 
+  /* eslint-disable @typescript-eslint/indent */
+  // prettier-ignore
   const template$k = html `
     <template role="progressbar">
+        ${''
+/**
+ * In Firefox, the 'title' set on the spinner is very finicky when
+ * the spinner is animating. Therefore, put a transparent overlay on
+ * top of the spinning bits so that the title displays as expected.
+ */
+}
+        <div class="overlay"></div>
+
         <div class="container">
             <div class="bit1"></div>
             <div class="bit2"></div>
@@ -68451,6 +68468,10 @@ img.ProseMirror-separator {
   }
   const passthroughUnitScale = new PassthroughUnitScale();
 
+  // 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
+  // added it to the type definitions. See https://github.com/microsoft/TypeScript/issues/56269
+  const signDisplay = 'negative';
   /**
    * Format for numbers with units to show in a tabular form.
    * Large and tiny numbers are shown exponentially and the rest as decimal.
@@ -68460,35 +68481,26 @@ img.ProseMirror-separator {
           unitScale: passthroughUnitScale
       }) {
           super();
-          // Format options to use by default. It renders the number with a maximum of 6 signficant digits.
+          // 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,
-              useGrouping: true
-          };
-          this.defaultScaledUnitFormatters = new Map();
-          // Format options to use for numbers that have leading zeros. It limits the number of rendered
-          // digits using 'maximumFractionDigits', which will result in less than 6 significant digits
-          // in order to render no more than 6 total digits.
-          this.leadingZeroIntlNumberFormatOptions = {
               maximumFractionDigits: DefaultUnitFormat.maximumDigits - 1,
-              useGrouping: true
+              roundingPriority: 'lessPrecision',
+              signDisplay
           };
-          this.leadingZeroScaledUnitFormatters = new Map();
+          this.defaultScaledUnitFormatters = new Map();
           // 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,
-              notation: 'scientific'
+              notation: 'scientific',
+              signDisplay
           };
           for (const unit of unitScale.supportedScaledUnits) {
               this.defaultScaledUnitFormatters.set(unit.scaleFactor, unit.scaledUnitFormatFactory({
                   locale,
                   intlNumberFormatOptions: this.defaultIntlNumberFormatOptions
               }));
-              this.leadingZeroScaledUnitFormatters.set(unit.scaleFactor, unit.scaledUnitFormatFactory({
-                  locale,
-                  intlNumberFormatOptions: this.leadingZeroIntlNumberFormatOptions
-              }));
           }
           this.exponentialScaledUnitFormatter = unitScale.baseScaledUnit.scaledUnitFormatFactory({
               locale,
@@ -68502,43 +68514,16 @@ img.ProseMirror-separator {
           };
       }
       tryFormat(number) {
-          // Normalize +0 / -0 --> +0
-          const numberNormalized = number === 0 ? 0 : number;
-          const { scaledValue, scaledUnit } = this.unitScale.scaleNumber(numberNormalized);
-          const numberStyle = this.resolveNumberStyle(scaledValue);
-          switch (numberStyle) {
-              case 'default': {
-                  const scaledUnitFormatter = this.defaultScaledUnitFormatters.get(scaledUnit.scaleFactor);
-                  return scaledUnitFormatter.format(scaledValue);
-              }
-              case 'leadingZero': {
-                  const scaledUnitFormatter = this.leadingZeroScaledUnitFormatters.get(scaledUnit.scaleFactor);
-                  return scaledUnitFormatter.format(scaledValue);
-              }
-              case 'exponential': {
-                  const scaledUnitFormatter = this.exponentialScaledUnitFormatter;
-                  return scaledUnitFormatter.format(numberNormalized);
-              }
-              default:
-                  throw new Error('Unexpected number format style');
-          }
-      }
-      resolveNumberStyle(number) {
-          if (number === 0) {
-              return 'default';
-          }
-          const absoluteValue = Math.abs(number);
-          if (absoluteValue >= DefaultUnitFormat.exponentialUpperBound
-              || absoluteValue < DefaultUnitFormat.exponentialLowerBound) {
-              return 'exponential';
-          }
-          // Ideally, we could set 'roundingPriority: "lessPrecision"' with a formatter that has both 'maximumSignificantDigits' and
-          // 'maximumFractionDigits' configured instead of having two different formatters that we conditionally choose between. However,
-          // 'roundingPrioirty' is not supported yet in all browsers.
-          if (absoluteValue < 1) {
-              return 'leadingZero';
-          }
-          return 'default';
+          const { scaledValue, scaledUnit } = this.unitScale.scaleNumber(number);
+          const absoluteValue = Math.abs(scaledValue);
+          const useExponential = absoluteValue !== 0
+              && (absoluteValue >= DefaultUnitFormat.exponentialUpperBound
+                  || absoluteValue < DefaultUnitFormat.exponentialLowerBound);
+          return useExponential
+              ? this.exponentialScaledUnitFormatter.format(number)
+              : this.defaultScaledUnitFormatters
+                  .get(scaledUnit.scaleFactor)
+                  .format(scaledValue);
       }
   }
   // The maximum number of digits that should be rendered for any given value.
@@ -68562,10 +68547,14 @@ img.ProseMirror-separator {
       }) {
           super();
           this.scaledUnitFormatters = new Map();
+          // Workaround to avoid a ts error about signDisplay not accepting the value 'negative'.
+          // It has been supported by browsers since 8/23, but TypeScript still hasn't
+          // added it to the type definitions. See https://github.com/microsoft/TypeScript/issues/56269
+          const signDisplay = 'negative';
           const intlNumberFormatOptions = {
               maximumFractionDigits,
               minimumFractionDigits,
-              useGrouping: true
+              signDisplay
           };
           for (const scaledUnit of unitScale.supportedScaledUnits) {
               this.scaledUnitFormatters.set(scaledUnit.scaleFactor, scaledUnit.scaledUnitFormatFactory({
@@ -68573,7 +68562,6 @@ img.ProseMirror-separator {
                   intlNumberFormatOptions
               }));
           }
-          this.tenPowDecimalDigits = 10 ** maximumFractionDigits;
           this.unitScale = unitScale;
           this.minimumFractionDigits = minimumFractionDigits;
           this.maximumFractionDigits = maximumFractionDigits;
@@ -68587,16 +68575,8 @@ img.ProseMirror-separator {
       }
       tryFormat(number) {
           const { scaledValue, scaledUnit } = this.unitScale.scaleNumber(number);
-          const numberNormalized = this.willRoundToZero(scaledValue)
-              ? 0
-              : scaledValue;
           const scaledUnitFormatter = this.scaledUnitFormatters.get(scaledUnit.scaleFactor);
-          return scaledUnitFormatter.format(numberNormalized);
-      }
-      willRoundToZero(number) {
-          // Multiply the value by 10 raised to maximumFractionDigits so that Math.round can be used to emulate rounding to
-          // maximumFractionDigits decimal places. If that rounded value is 0, then the value will be rendered with only 0s.
-          return Math.round(number * this.tenPowDecimalDigits) === 0;
+          return scaledUnitFormatter.format(scaledValue);
       }
   }