@ni/nimble-components 20.14.3 → 20.14.5

package/dist/all-components-bundle.js

@@ -16298,7 +16298,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Mon, 13 Nov 2023 16:48:30 GMT
+   * Generated on Fri, 17 Nov 2023 00:55:54 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -21512,7 +21512,7 @@
         flex: none;
         display: flex;
         justify-content: flex-end;
-        border-top: ${borderWidth} solid ${popupBorderColor};
+        border-top: 2px solid rgba(${actionRgbPartialColor}, 0.1);
     }
 `.withBehaviors(
   /*
@@ -24116,9 +24116,6 @@
   __decorate$1([
       attr()
   ], Mapping$1.prototype, "key", void 0);
-  __decorate$1([
-      attr()
-  ], Mapping$1.prototype, "text", void 0);
 
   const template$n = html `<template slot="mapping"></template>`;
 
@@ -24129,6 +24126,9 @@
    */
   class MappingText extends Mapping$1 {
   }
+  __decorate$1([
+      attr()
+  ], MappingText.prototype, "text", void 0);
   const textMapping = MappingText.compose({
       baseName: 'mapping-text',
       template: template$n
@@ -24187,6 +24187,9 @@
   __decorate$1([
       attr()
   ], MappingIcon.prototype, "severity", void 0);
+  __decorate$1([
+      attr()
+  ], MappingIcon.prototype, "text", void 0);
   __decorate$1([
       observable
   ], MappingIcon.prototype, "resolvedIcon", void 0);
@@ -24204,6 +24207,9 @@
    */
   class MappingSpinner extends Mapping$1 {
   }
+  __decorate$1([
+      attr()
+  ], MappingSpinner.prototype, "text", void 0);
   const spinnerMapping = MappingSpinner.compose({
       baseName: 'mapping-spinner',
       template: template$n
@@ -68667,27 +68673,22 @@ img.ProseMirror-separator {
 
   const enumBaseValidityFlagNames = [
       'invalidMappingKeyValueForType',
-      'unsupportedMappingType',
       'duplicateMappingKey',
-      'missingKeyValue',
-      'missingTextValue'
+      'missingKeyValue'
   ];
   /**
    * Validator for TableColumnEnumText. Implementations MUST include enumBaseValidityFlagNames in validity flag names set.
    */
   class TableColumnEnumBaseValidator extends ColumnValidator {
-      constructor(columnInternals, configValidityKeys, supportedMappingElements) {
+      constructor(columnInternals, configValidityKeys) {
           super(columnInternals, configValidityKeys);
-          this.supportedMappingElements = supportedMappingElements;
       }
       validate(mappings, keyType) {
           this.untrackAll();
           const keys = mappings.map(mapping => mapping.key);
           this.validateKeyValuesForType(keys, keyType);
-          this.validateMappingTypes(mappings);
           this.validateUniqueKeys(keys, keyType);
           this.validateNoMissingKeys(mappings);
-          this.validateNoMissingText(mappings);
       }
       validateKeyValuesForType(keys, keyType) {
           // Ignore undefined keys, because validateNoMissingKeys covers that case.
@@ -68697,10 +68698,6 @@ img.ProseMirror-separator {
               && resolveKeyWithType(key, keyType) === undefined);
           this.setConditionValue('invalidMappingKeyValueForType', invalid);
       }
-      validateMappingTypes(mappings) {
-          const valid = mappings.every(mapping => this.supportedMappingElements.some(mappingClass => mapping instanceof mappingClass));
-          this.setConditionValue('unsupportedMappingType', !valid);
-      }
       validateUniqueKeys(keys, keyType) {
           const typedKeys = keys.map(x => resolveKeyWithType(x, keyType));
           const invalid = new Set(typedKeys).size !== typedKeys.length;
@@ -68710,19 +68707,37 @@ img.ProseMirror-separator {
           const invalid = mappings.some(mapping => mapping.key === undefined);
           this.setConditionValue('missingKeyValue', invalid);
       }
-      validateNoMissingText(mappings) {
-          const invalid = mappings.some(mapping => mapping.text === undefined);
-          this.setConditionValue('missingTextValue', invalid);
-      }
   }
 
-  const enumTextValidityFlagNames = [...enumBaseValidityFlagNames];
+  const enumTextValidityFlagNames = [
+      ...enumBaseValidityFlagNames,
+      'unsupportedMappingType',
+      'missingTextValue'
+  ];
   /**
    * Validator for TableColumnEnumText
    */
   class TableColumnEnumTextValidator extends TableColumnEnumBaseValidator {
       constructor(columnInternals) {
-          super(columnInternals, enumTextValidityFlagNames, [MappingText]);
+          super(columnInternals, enumTextValidityFlagNames);
+      }
+      static isSupportedMappingElement(mapping) {
+          return mapping instanceof MappingText;
+      }
+      validate(mappings, keyType) {
+          super.validate(mappings, keyType);
+          this.validateMappingTypes(mappings);
+          this.validateNoMissingText(mappings);
+      }
+      validateNoMissingText(mappings) {
+          const invalid = mappings
+              .filter(TableColumnEnumTextValidator.isSupportedMappingElement)
+              .some(mapping => mapping.text === undefined);
+          this.setConditionValue('missingTextValue', invalid);
+      }
+      validateMappingTypes(mappings) {
+          const valid = mappings.every(TableColumnEnumTextValidator.isSupportedMappingElement);
+          this.setConditionValue('unsupportedMappingType', !valid);
       }
   }
 
@@ -69180,29 +69195,45 @@ img.ProseMirror-separator {
 
   const iconValidityFlagNames = [
       ...enumBaseValidityFlagNames,
-      'invalidIconName'
+      'unsupportedMappingType',
+      'invalidIconName',
+      'missingTextValue'
   ];
   /**
    * Validator for TableColumnIcon
    */
   class TableColumnIconValidator extends TableColumnEnumBaseValidator {
       constructor(columnInternals) {
-          super(columnInternals, iconValidityFlagNames, [
-              MappingIcon,
-              MappingSpinner
-          ]);
+          super(columnInternals, iconValidityFlagNames);
+      }
+      static isIconMappingElement(mapping) {
+          return mapping instanceof MappingIcon;
+      }
+      static isSupportedMappingElement(mapping) {
+          return (mapping instanceof MappingIcon || mapping instanceof MappingSpinner);
       }
       validate(mappings, keyType) {
           super.validate(mappings, keyType);
+          this.validateMappingTypes(mappings);
           this.validateIconNames(mappings);
+          this.validateNoMissingText(mappings);
       }
       validateIconNames(mappings) {
-          const isMappingIcon = (mapping) => mapping instanceof MappingIcon;
           const invalid = mappings
-              .filter(isMappingIcon)
+              .filter(TableColumnIconValidator.isIconMappingElement)
               .some(mappingIcon => mappingIcon.resolvedIcon === undefined);
           this.setConditionValue('invalidIconName', invalid);
       }
+      validateNoMissingText(mappings) {
+          const invalid = mappings
+              .filter(TableColumnIconValidator.isSupportedMappingElement)
+              .some(mapping => mapping.text === undefined);
+          this.setConditionValue('missingTextValue', invalid);
+      }
+      validateMappingTypes(mappings) {
+          const valid = mappings.every(TableColumnIconValidator.isSupportedMappingElement);
+          this.setConditionValue('unsupportedMappingType', !valid);
+      }
   }
 
   const styles$8 = css `