@ni/nimble-components 20.14.2 → 20.14.4

package/dist/all-components-bundle.js

@@ -16298,7 +16298,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Sat, 11 Nov 2023 10:48:28 GMT
+   * Generated on Wed, 15 Nov 2023 16:37:32 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -16647,7 +16647,15 @@
       elevation1BoxShadow: 'elevation-1-box-shadow',
       elevation2BoxShadow: 'elevation-2-box-shadow',
       elevation3BoxShadow: 'elevation-3-box-shadow',
-      graphGridlineColor: 'graph-gridline-color'
+      graphGridlineColor: 'graph-gridline-color',
+      mentionFont: 'mention-font',
+      mentionFontColor: 'mention-font-color',
+      mentionDisabledFontColor: 'mention-disabled-font-color',
+      mentionFontFamily: 'mention-font-family',
+      mentionFontSize: 'mention-font-size',
+      mentionFontWeight: 'mention-font-weight',
+      mentionFontLineHeight: 'mention-font-line-height',
+      mentionFallbackFontFamily: 'mention-fallback-font-family'
   };
   const prefix = 'ni-nimble';
   const styleNameFromTokenName = (tokenName) => `${prefix}-${tokenName}`;
@@ -16916,6 +16924,7 @@
   const [tooltipCaptionFont, tooltipCaptionFontColor, tooltipCaptionDisabledFontColor, tooltipCaptionFontFamily, tooltipCaptionFontWeight, tooltipCaptionFontSize, tooltipCaptionFontLineHeight, tooltipCaptionFallbackFontFamily] = createFontTokens(tokenNames.tooltipCaptionFont, (element) => getDefaultFontColorForTheme(element), (element) => hexToRgbaCssColor(getDefaultFontColorForTheme(element), 0.3), TooltipCaptionFamily, TooltipCaptionWeight, TooltipCaptionSize, TooltipCaptionLineHeight, TooltipCaptionFallbackFontFamily);
   const [errorTextFont, errorTextFontColor, errorTextDisabledFontColor, errorTextFontFamily, errorTextFontWeight, errorTextFontSize, errorTextFontLineHeight, errorTextFallbackFontFamily] = createFontTokens(tokenNames.errorTextFont, (element) => getFailColorForTheme(element), (element) => hexToRgbaCssColor(getFailColorForTheme(element), 0.3), ErrorLightUiFamily, ErrorLightUiWeight, ErrorLightUiSize, TooltipCaptionLineHeight, ErrorLightUiFallbackFontFamily);
   const [tableHeaderFont, tableHeaderFontColor, tableHeaderDisabledFontColor, tableHeaderFontFamily, tableHeaderFontWeight, tableHeaderFontSize, tableHeaderFontLineHeight, tableHeaderFallbackFontFamily] = createFontTokens(tokenNames.tableHeaderFont, (element) => hexToRgbaCssColor(getDefaultFontColorForTheme(element), 0.6), (element) => hexToRgbaCssColor(getDefaultFontColorForTheme(element), 0.3), GridHeaderFamily, GridHeaderWeight, GridHeaderSize, TooltipCaptionLineHeight, GridHeaderFallbackFontFamily);
+  createFontTokens(tokenNames.mentionFont, (element) => getColorForTheme(element, DigitalGreenDark, PowerGreen, PowerGreen), (element) => hexToRgbaCssColor(getDefaultFontColorForTheme(element), 0.3), BodyFamily, BodyEmphasizedWeight, BodySize, BodyLineHeight, BodyFallbackFontFamily);
   // Font Transform Tokens
   const groupHeaderTextTransform = DesignToken.create(styleNameFromTokenName(tokenNames.groupHeaderTextTransform)).withDefault('uppercase');
   // Animation Tokens
@@ -24107,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>`;
 
@@ -24120,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
@@ -24178,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);
@@ -24195,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
@@ -68658,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.
@@ -68688,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;
@@ -68701,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);
       }
   }
 
@@ -69171,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 `