@dynatrace/strato-components 3.2.1 → 3.3.0

package/esm/filters/filter-field/utils/validation-utils/normalize-validator-map.js

@@ -0,0 +1,218 @@
+import {
+  isFilterFieldKeySuggestionConfig,
+  isFilterFieldKeySuggestionGroupConfig,
+  isFilterFieldRichValuePredicate,
+  isFilterFieldValidatorMapDurationSpecification,
+  isFilterFieldValidatorMapTypeSpecification,
+  isFilterFieldValueSuggestionGroupConfig
+} from "./type-guards.js";
+import { resolveGroupId } from "../suggestions-utils/suggestion-group-utils.js";
+const KEY_GROUP_ID = "strato-filter-field-key-suggestions";
+function toInternalValidatorMap(validatorMap) {
+  if (!validatorMap) {
+    return void 0;
+  }
+  const byKey = /* @__PURE__ */ new Map();
+  const valuesMap = /* @__PURE__ */ new Map();
+  const functionsMap = /* @__PURE__ */ new Map();
+  const fallbackKeysList = [];
+  let groups;
+  const { keyPredicates, exhaustive, comparisonOperators } = validatorMap;
+  if (keyPredicates !== void 0) {
+    if (Array.isArray(keyPredicates)) {
+      groups = processKeyPredicatesArray(
+        keyPredicates,
+        byKey,
+        valuesMap,
+        functionsMap,
+        fallbackKeysList
+      );
+    } else {
+      processKeyPredicatesObject(
+        keyPredicates,
+        byKey,
+        valuesMap,
+        functionsMap,
+        fallbackKeysList
+      );
+    }
+  }
+  const filterStatementKeysMap = valuesMap.size > 0 || functionsMap.size > 0 ? { values: valuesMap, functions: functionsMap } : void 0;
+  const resolvedGroups = groups && groups.length > 0 ? groups : void 0;
+  const keyToGroup = /* @__PURE__ */ new Map();
+  if (resolvedGroups) {
+    for (const group of resolvedGroups) {
+      for (const key of group.keys) {
+        keyToGroup.set(key, group);
+      }
+    }
+  } else {
+    const implicitGroup = {
+      id: `${KEY_GROUP_ID}-implicit-0`,
+      keys: [...byKey.keys()]
+    };
+    for (const key of byKey.keys()) {
+      keyToGroup.set(key, implicitGroup);
+    }
+  }
+  return {
+    normalizedKeys: {
+      byKey,
+      groups: resolvedGroups,
+      keyToGroup
+    },
+    exhaustive,
+    comparisonOperators,
+    sortSuggestions: validatorMap.sortSuggestions,
+    fallbackKeys: fallbackKeysList.length > 0 ? fallbackKeysList : void 0,
+    filterStatementKeysMap
+  };
+}
+function processKeyPredicatesArray(keyPredicates, byKey, valuesMap, functionsMap, fallbackKeysList) {
+  const groups = [];
+  let pendingKeys = [];
+  function processPendingKeys() {
+    if (pendingKeys.length === 0) {
+      return;
+    }
+    groups.push({
+      id: `${KEY_GROUP_ID}-implicit-${groups.length}`,
+      keys: pendingKeys
+    });
+    pendingKeys = [];
+  }
+  for (let index = 0; index < keyPredicates.length; index++) {
+    const item = keyPredicates[index];
+    if (typeof item === "string") {
+      byKey.set(item, {});
+      pendingKeys.push(item);
+      continue;
+    }
+    if (isFilterFieldKeySuggestionConfig(item)) {
+      byKey.set(item.key, item);
+      collectFallbackAndStatements(
+        item.key,
+        item,
+        fallbackKeysList,
+        valuesMap,
+        functionsMap
+      );
+      pendingKeys.push(item.key);
+      continue;
+    }
+    if (isFilterFieldKeySuggestionGroupConfig(item)) {
+      processPendingKeys();
+      const { label, "aria-label": ariaLabel } = item;
+      const groupId = resolveGroupId(item, `key-group-${index}`);
+      const groupKeys = [];
+      for (const suggestion of item.suggestions) {
+        if (typeof suggestion === "string") {
+          byKey.set(suggestion, {});
+          groupKeys.push(suggestion);
+        } else if (isFilterFieldKeySuggestionConfig(suggestion)) {
+          byKey.set(suggestion.key, suggestion);
+          groupKeys.push(suggestion.key);
+          collectFallbackAndStatements(
+            suggestion.key,
+            suggestion,
+            fallbackKeysList,
+            valuesMap,
+            functionsMap
+          );
+        }
+      }
+      if (groupKeys.length > 0) {
+        groups.push({
+          id: groupId,
+          label,
+          "aria-label": ariaLabel,
+          keys: groupKeys
+        });
+      }
+    }
+  }
+  processPendingKeys();
+  return groups;
+}
+function processKeyPredicatesObject(keyPredicates, byKey, valuesMap, functionsMap, fallbackKeysList) {
+  for (const [key, rawPredicate] of Object.entries(keyPredicates)) {
+    let config;
+    if (isFilterFieldValidatorMapTypeSpecification(rawPredicate)) {
+      config = { valuePredicate: rawPredicate };
+    } else {
+      config = {
+        comparisonOperators: rawPredicate.comparisonOperators,
+        valuePredicate: rawPredicate.valuePredicate,
+        fallbackKey: rawPredicate.fallbackKey,
+        suggestStatementOnValueMatch: rawPredicate.suggestStatementOnValueMatch,
+        displayValue: rawPredicate.displayValue,
+        details: rawPredicate.details
+      };
+    }
+    byKey.set(key, config);
+    collectFallbackAndStatements(
+      key,
+      config,
+      fallbackKeysList,
+      valuesMap,
+      functionsMap
+    );
+  }
+}
+function collectFallbackAndStatements(key, config, fallbackKeysList, valuesMap, functionsMap) {
+  if (config.fallbackKey) {
+    fallbackKeysList.push({
+      value: key,
+      comparisonOperators: Array.isArray(config.fallbackKey) ? config.fallbackKey : void 0
+    });
+  }
+  if (config.suggestStatementOnValueMatch) {
+    if (typeof config.suggestStatementOnValueMatch === "function") {
+      functionsMap.set(key, config.suggestStatementOnValueMatch);
+    } else if (config.valuePredicate !== void 0 && typeof config.valuePredicate !== "function") {
+      extractLiteralValuesToMap(config.valuePredicate, key, valuesMap);
+    }
+  }
+}
+function extractLiteralValuesToMap(valuePredicate, key, valuesMap) {
+  if (Array.isArray(valuePredicate)) {
+    for (const item of valuePredicate) {
+      if (isFilterFieldValueSuggestionGroupConfig(item)) {
+        for (const suggestion of item.suggestions) {
+          if (!isFilterFieldValidatorMapTypeSpecification(suggestion)) {
+            addToValuesMap(valuesMap, key, suggestion);
+          }
+        }
+      } else if (!isFilterFieldValidatorMapTypeSpecification(item)) {
+        addToValuesMap(valuesMap, key, item);
+      }
+    }
+  } else if (isFilterFieldValueSuggestionGroupConfig(valuePredicate)) {
+    for (const suggestion of valuePredicate.suggestions) {
+      if (!isFilterFieldValidatorMapTypeSpecification(suggestion)) {
+        addToValuesMap(valuesMap, key, suggestion);
+      }
+    }
+  } else if (!isFilterFieldValidatorMapTypeSpecification(valuePredicate)) {
+    addToValuesMap(valuesMap, key, valuePredicate);
+  }
+}
+function addToValuesMap(valuesMap, key, value) {
+  let stringValue;
+  if (isFilterFieldValidatorMapDurationSpecification(value)) {
+    stringValue = `${value.value}${value.unit}`;
+  } else if (isFilterFieldRichValuePredicate(value)) {
+    stringValue = `${value.value}`;
+  } else {
+    stringValue = `${value}`;
+  }
+  const existingKeys = valuesMap.get(stringValue) ?? [];
+  if (!existingKeys.includes(key)) {
+    valuesMap.set(stringValue, [...existingKeys, key]);
+  }
+}
+export {
+  KEY_GROUP_ID,
+  toInternalValidatorMap
+};
+//# sourceMappingURL=normalize-validator-map.js.map

package/esm/filters/filter-field/utils/validation-utils/normalize-validator-map.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/filters/filter-field/utils/validation-utils/normalize-validator-map.ts"],
+  "sourcesContent": ["import {\n  isFilterFieldKeySuggestionConfig,\n  isFilterFieldKeySuggestionGroupConfig,\n  isFilterFieldRichValuePredicate,\n  isFilterFieldValidatorMapDurationSpecification,\n  isFilterFieldValidatorMapTypeSpecification,\n  isFilterFieldValueSuggestionGroupConfig,\n} from './type-guards.js';\nimport type {\n  FallbackKeys,\n  FilterStatementFunctionMap,\n  FilterStatementKeysMap,\n  FilterStatementValuesMap,\n} from '../../FilterField.types.js';\nimport type {\n  FilterFieldComparisonOperators,\n  FilterFieldKeySuggestionConfig,\n  FilterFieldKeySuggestionGroupConfig,\n  FilterFieldValidatorMap,\n  FilterFieldValueMatchFn,\n  FilterFieldValuePredicate,\n  FilterFieldValuePredicateFn,\n  FilterFieldValuePredicateItem,\n} from '../../types/validation.js';\nimport { resolveGroupId } from '../suggestions-utils/suggestion-group-utils.js';\n\n/**\n * Normalized per-key configuration for use in the internal validation and suggestion pipeline.\n * @internal\n */\nexport type NormalizedKeyConfig = {\n  comparisonOperators?: Array<FilterFieldComparisonOperators>;\n  valuePredicate?: FilterFieldValuePredicate | FilterFieldValuePredicateFn;\n  /** Value type from the new array format's `valueType` prop. Stored separately from `valuePredicate`\n   * to avoid fabricating a synthetic type predicate object. */\n  valueType?: string | string[];\n  fallbackKey?:\n    | boolean\n    | Array<Exclude<FilterFieldComparisonOperators, 'exists' | 'not-exists'>>;\n  suggestStatementOnValueMatch?: boolean | FilterFieldValueMatchFn;\n  /** Display value shown for key suggestions (from deprecated object format). */\n  displayValue?: string;\n  /** Detail text shown for key suggestions (from deprecated object format). */\n  details?: string;\n};\n\n/**\n * A named key group for suggestion rendering.\n * @internal\n */\nexport type KeyGroup = {\n  id: string;\n  label?: string;\n  'aria-label'?: string;\n  keys: string[];\n};\n\n/**\n * Normalized key predicates for the internal validation and suggestion pipeline.\n * @internal\n */\nexport type NormalizedKeyPredicates = {\n  /** Flat per-key configuration map for validation and operator/value lookup. */\n  byKey: Map<string, NormalizedKeyConfig>;\n  /** Ordered named groups for suggestion rendering (undefined = no named groups). */\n  groups?: KeyGroup[];\n  /** Pre-computed key \u2192 group mapping for lookup during suggestion rendering. */\n  keyToGroup: Map<string, KeyGroup>;\n};\n\n/**\n * Internal representation of the FilterField validator map.\n * Replaces `FilterFieldValidatorMap` in the suggestion and validation pipeline.\n * The raw `keyPredicates` are not exposed \u2014 use `normalizedKeys` instead.\n * @internal\n */\nexport type InternalValidatorMap = {\n  /** Normalized per-key configs keyed by key string. */\n  normalizedKeys: NormalizedKeyPredicates;\n  /** Whether any key not in `normalizedKeys.byKey` is considered an error. */\n  exhaustive?: boolean;\n  /** Global comparison operator restrictions. */\n  comparisonOperators?: Array<FilterFieldComparisonOperators>;\n  /** Whether suggestions should be sorted alphabetically by default. Defaults to true. */\n  sortSuggestions?: boolean;\n  /** Pre-computed fallback keys for suggestion generation. */\n  fallbackKeys?: FallbackKeys;\n  /** Pre-computed filter statement keys map for statement suggestions. */\n  filterStatementKeysMap?: FilterStatementKeysMap;\n};\n\n/**\n * The well-known group id for the primary (ungrouped) key suggestion slot.\n * Individual key entries in the array format and all object-format keys are assigned\n * to this id so they map to `groupedSuggestions.key` in the suggestion pipeline.\n * @internal\n */\nexport const KEY_GROUP_ID = 'strato-filter-field-key-suggestions';\n\n/**\n * Normalizes a `FilterFieldValidatorMap` into an `InternalValidatorMap`.\n * Handles all formats of `keyPredicates` (deprecated object, new array).\n * Computes `fallbackKeys` and `filterStatementKeysMap` in the same pass.\n * @internal\n */\nexport function toInternalValidatorMap(\n  validatorMap: FilterFieldValidatorMap | undefined,\n): InternalValidatorMap | undefined {\n  if (!validatorMap) {\n    return undefined;\n  }\n  const byKey = new Map<string, NormalizedKeyConfig>();\n  const valuesMap: FilterStatementValuesMap = new Map<string, string[]>();\n  const functionsMap: FilterStatementFunctionMap = new Map<\n    string,\n    FilterFieldValueMatchFn\n  >();\n  const fallbackKeysList: FallbackKeys = [];\n  let groups: KeyGroup[] | undefined;\n\n  const { keyPredicates, exhaustive, comparisonOperators } = validatorMap;\n\n  if (keyPredicates !== undefined) {\n    if (Array.isArray(keyPredicates)) {\n      groups = processKeyPredicatesArray(\n        keyPredicates,\n        byKey,\n        valuesMap,\n        functionsMap,\n        fallbackKeysList,\n      );\n    } else {\n      processKeyPredicatesObject(\n        keyPredicates,\n        byKey,\n        valuesMap,\n        functionsMap,\n        fallbackKeysList,\n      );\n    }\n  }\n\n  const filterStatementKeysMap: FilterStatementKeysMap | undefined =\n    valuesMap.size > 0 || functionsMap.size > 0\n      ? { values: valuesMap, functions: functionsMap }\n      : undefined;\n\n  const resolvedGroups = groups && groups.length > 0 ? groups : undefined;\n  const keyToGroup = new Map<string, KeyGroup>();\n\n  if (resolvedGroups) {\n    for (const group of resolvedGroups) {\n      for (const key of group.keys) {\n        keyToGroup.set(key, group);\n      }\n    }\n  } else {\n    // Object format: all keys fall into a single implicit group.\n    const implicitGroup: KeyGroup = {\n      id: `${KEY_GROUP_ID}-implicit-0`,\n      keys: [...byKey.keys()],\n    };\n    for (const key of byKey.keys()) {\n      keyToGroup.set(key, implicitGroup);\n    }\n  }\n\n  return {\n    normalizedKeys: {\n      byKey,\n      groups: resolvedGroups,\n      keyToGroup,\n    },\n    exhaustive,\n    comparisonOperators,\n    sortSuggestions: validatorMap.sortSuggestions,\n    fallbackKeys: fallbackKeysList.length > 0 ? fallbackKeysList : undefined,\n    filterStatementKeysMap,\n  };\n}\n\n/**\n * Processes the new array format for `keyPredicates`.\n * Returns all groups in declaration order, both explicit named groups and implicit\n * groups formed by consecutive individual key entries.\n * Individual keys are collected into an implicit group to preserve the correct order\n * of suggestions when groups and individual keys are combined.\n * E.g.:\n * ```\n * [\n *   'key1',\n *   { key: 'key2', ... },\n *   { label: 'Group A', suggestions: ['key3', { key: 'key4', ... }] },\n *   'key5',\n * ]\n * ```\n * Result groups:\n * ```\n * { id: 'key-group-0', keys: ['key1', 'key2'] }\n * { id: 'group-a', label: 'Group A', keys: ['key3', 'key4'] }\n * { id: 'key-group-1', keys: ['key5'] }\n * ```\n */\nfunction processKeyPredicatesArray(\n  keyPredicates: Array<\n    | string\n    | FilterFieldKeySuggestionConfig\n    | FilterFieldKeySuggestionGroupConfig\n  >,\n  byKey: Map<string, NormalizedKeyConfig>,\n  valuesMap: FilterStatementValuesMap,\n  functionsMap: FilterStatementFunctionMap,\n  fallbackKeysList: FallbackKeys,\n): KeyGroup[] {\n  const groups: KeyGroup[] = [];\n  // Collect consecutive individual keys to be added as an implicit group.\n  let pendingKeys: string[] = [];\n\n  /**\n   * Push accumulated individual items into an implicit group.\n   * Individual keys are collected into an implicit group to preserve the correct\n   * declaration order when mixing groups and individual keys in the key predicates.\n   */\n  function processPendingKeys() {\n    if (pendingKeys.length === 0) {\n      return;\n    }\n\n    groups.push({\n      id: `${KEY_GROUP_ID}-implicit-${groups.length}`,\n      keys: pendingKeys,\n    });\n    pendingKeys = [];\n  }\n\n  for (let index = 0; index < keyPredicates.length; index++) {\n    const item = keyPredicates[index];\n\n    // Plain string key \u2014 no per-key restrictions.\n    if (typeof item === 'string') {\n      byKey.set(item, {});\n      pendingKeys.push(item);\n      continue;\n    }\n\n    // Individual key suggestion config.\n    if (isFilterFieldKeySuggestionConfig(item)) {\n      byKey.set(item.key, item);\n      collectFallbackAndStatements(\n        item.key,\n        item,\n        fallbackKeysList,\n        valuesMap,\n        functionsMap,\n      );\n      pendingKeys.push(item.key);\n      continue;\n    }\n\n    // Explicit group config.\n    if (isFilterFieldKeySuggestionGroupConfig(item)) {\n      // Pending keys are first pushed as an implicit group to preserve declaration order relative to the explicit group.\n      processPendingKeys();\n\n      const { label, 'aria-label': ariaLabel } = item;\n      const groupId = resolveGroupId(item, `key-group-${index}`);\n      const groupKeys: string[] = [];\n\n      for (const suggestion of item.suggestions) {\n        if (typeof suggestion === 'string') {\n          byKey.set(suggestion, {});\n          groupKeys.push(suggestion);\n        } else if (isFilterFieldKeySuggestionConfig(suggestion)) {\n          byKey.set(suggestion.key, suggestion);\n          groupKeys.push(suggestion.key);\n          collectFallbackAndStatements(\n            suggestion.key,\n            suggestion,\n            fallbackKeysList,\n            valuesMap,\n            functionsMap,\n          );\n        }\n      }\n\n      if (groupKeys.length > 0) {\n        groups.push({\n          id: groupId,\n          label,\n          'aria-label': ariaLabel,\n          keys: groupKeys,\n        });\n      }\n    }\n  }\n\n  // Push any remaining individual keys at the end as an implicit group.\n  processPendingKeys();\n\n  return groups;\n}\n\n/**\n * Processes the deprecated object format for `keyPredicates`.\n */\nfunction processKeyPredicatesObject(\n  keyPredicates: Extract<\n    NonNullable<FilterFieldValidatorMap['keyPredicates']>,\n    Record<string, unknown>\n  >,\n  byKey: Map<string, NormalizedKeyConfig>,\n  valuesMap: FilterStatementValuesMap,\n  functionsMap: FilterStatementFunctionMap,\n  fallbackKeysList: FallbackKeys,\n): void {\n  for (const [key, rawPredicate] of Object.entries(keyPredicates)) {\n    let config: NormalizedKeyConfig;\n\n    if (isFilterFieldValidatorMapTypeSpecification(rawPredicate)) {\n      config = { valuePredicate: rawPredicate };\n    } else {\n      config = {\n        comparisonOperators: rawPredicate.comparisonOperators,\n        valuePredicate: rawPredicate.valuePredicate,\n        fallbackKey: rawPredicate.fallbackKey,\n        suggestStatementOnValueMatch: rawPredicate.suggestStatementOnValueMatch,\n        displayValue: rawPredicate.displayValue,\n        details: rawPredicate.details,\n      };\n    }\n\n    byKey.set(key, config);\n    collectFallbackAndStatements(\n      key,\n      config,\n      fallbackKeysList,\n      valuesMap,\n      functionsMap,\n    );\n  }\n}\n\n/**\n * Collects fallback key info and statement suggestion mappings from a normalized config.\n */\nfunction collectFallbackAndStatements(\n  key: string,\n  config: NormalizedKeyConfig,\n  fallbackKeysList: FallbackKeys,\n  valuesMap: FilterStatementValuesMap,\n  functionsMap: FilterStatementFunctionMap,\n): void {\n  if (config.fallbackKey) {\n    fallbackKeysList.push({\n      value: key,\n      comparisonOperators: Array.isArray(config.fallbackKey)\n        ? config.fallbackKey\n        : undefined,\n    });\n  }\n\n  if (config.suggestStatementOnValueMatch) {\n    if (typeof config.suggestStatementOnValueMatch === 'function') {\n      functionsMap.set(key, config.suggestStatementOnValueMatch);\n    } else if (\n      config.valuePredicate !== undefined &&\n      typeof config.valuePredicate !== 'function'\n    ) {\n      extractLiteralValuesToMap(config.valuePredicate, key, valuesMap);\n    }\n  }\n}\n\n/**\n * Extracts literal value strings from a `FilterFieldValuePredicate` into the\n * `valuesMap` for statement suggestion lookup.\n * Handles grouped value configs by recursing into their `suggestions` arrays.\n */\nfunction extractLiteralValuesToMap(\n  valuePredicate: Exclude<\n    FilterFieldValuePredicate,\n    FilterFieldValuePredicateFn\n  >,\n  key: string,\n  valuesMap: FilterStatementValuesMap,\n): void {\n  if (Array.isArray(valuePredicate)) {\n    for (const item of valuePredicate) {\n      if (isFilterFieldValueSuggestionGroupConfig(item)) {\n        for (const suggestion of item.suggestions) {\n          if (!isFilterFieldValidatorMapTypeSpecification(suggestion)) {\n            addToValuesMap(valuesMap, key, suggestion);\n          }\n        }\n      } else if (!isFilterFieldValidatorMapTypeSpecification(item)) {\n        addToValuesMap(valuesMap, key, item);\n      }\n    }\n  } else if (isFilterFieldValueSuggestionGroupConfig(valuePredicate)) {\n    for (const suggestion of valuePredicate.suggestions) {\n      if (!isFilterFieldValidatorMapTypeSpecification(suggestion)) {\n        addToValuesMap(valuesMap, key, suggestion);\n      }\n    }\n  } else if (!isFilterFieldValidatorMapTypeSpecification(valuePredicate)) {\n    addToValuesMap(valuesMap, key, valuePredicate);\n  }\n}\n\n/**\n * Adds a key \u2192 value string mapping to the values map.\n * Inlined from `getValuePredicateTextValue` to avoid circular imports.\n */\nfunction addToValuesMap(\n  valuesMap: FilterStatementValuesMap,\n  key: string,\n  value: FilterFieldValuePredicateItem,\n): void {\n  let stringValue: string;\n  if (isFilterFieldValidatorMapDurationSpecification(value)) {\n    stringValue = `${value.value}${value.unit}`;\n  } else if (isFilterFieldRichValuePredicate(value)) {\n    stringValue = `${value.value}`;\n  } else {\n    stringValue = `${value}`;\n  }\n  const existingKeys = valuesMap.get(stringValue) ?? [];\n  if (!existingKeys.includes(key)) {\n    valuesMap.set(stringValue, [...existingKeys, key]);\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/esm/filters/filter-field/utils/validation-utils/type-guards.js

@@ -9,9 +9,21 @@ function isFilterFieldRichValuePredicate(valueSpecification) {
   const castedValueSpecification = valueSpecification;
   return typeof valueSpecification === "object" && castedValueSpecification !== null && "value" in castedValueSpecification && !isFilterFieldValidatorMapTypeSpecification(valueSpecification) && ("displayValue" in castedValueSpecification || "details" in castedValueSpecification);
 }
+function isFilterFieldKeySuggestionConfig(value) {
+  return typeof value === "object" && value !== null && "key" in value && typeof value.key === "string";
+}
+function isFilterFieldKeySuggestionGroupConfig(value) {
+  return typeof value === "object" && value !== null && "suggestions" in value && Array.isArray(value.suggestions) && !("key" in value);
+}
+function isFilterFieldValueSuggestionGroupConfig(value) {
+  return typeof value === "object" && value !== null && "suggestions" in value && Array.isArray(value.suggestions);
+}
 export {
+  isFilterFieldKeySuggestionConfig,
+  isFilterFieldKeySuggestionGroupConfig,
   isFilterFieldRichValuePredicate,
   isFilterFieldValidatorMapDurationSpecification,
-  isFilterFieldValidatorMapTypeSpecification
+  isFilterFieldValidatorMapTypeSpecification,
+  isFilterFieldValueSuggestionGroupConfig
 };
 //# sourceMappingURL=type-guards.js.map

package/esm/filters/filter-field/utils/validation-utils/type-guards.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/filters/filter-field/utils/validation-utils/type-guards.ts"],
-  "sourcesContent": ["import type {\n  FilterFieldDuration,\n  FilterFieldValidatorMapTypePredicate,\n  FilterFieldRichValuePredicate,\n} from '../../types/validation.js';\n\n/**\n * Check whether the given value specification is a type specification.\n * @internal\n */\nexport function isFilterFieldValidatorMapTypeSpecification(\n  valueSpecification: unknown,\n): valueSpecification is FilterFieldValidatorMapTypePredicate {\n  return (\n    typeof valueSpecification === 'object' &&\n    valueSpecification !== null &&\n    'type' in valueSpecification &&\n    !('value' in valueSpecification)\n  );\n}\n\n/**\n * Check whether the given value specification is a duration specification.\n * @internal\n */\nexport function isFilterFieldValidatorMapDurationSpecification(\n  valueSpecification: unknown,\n): valueSpecification is FilterFieldDuration {\n  const castedValueSpecification = valueSpecification as FilterFieldDuration;\n\n  return (\n    typeof valueSpecification === 'object' &&\n    castedValueSpecification.value !== undefined &&\n    castedValueSpecification.unit !== undefined\n  );\n}\n\n/**\n * Check whether the given value specification is a value predicate with metadata.\n * @internal\n */\nexport function isFilterFieldRichValuePredicate(\n  valueSpecification: unknown,\n): valueSpecification is FilterFieldRichValuePredicate {\n  const castedValueSpecification =\n    valueSpecification as FilterFieldRichValuePredicate;\n\n  return (\n    typeof valueSpecification === 'object' &&\n    castedValueSpecification !== null &&\n    'value' in castedValueSpecification &&\n    !isFilterFieldValidatorMapTypeSpecification(valueSpecification) &&\n    ('displayValue' in castedValueSpecification ||\n      'details' in castedValueSpecification)\n  );\n}\n"],
-  "mappings": "AAUO,SAAS,2CACd,oBAC4D;AAC5D,SACE,OAAO,uBAAuB,YAC9B,uBAAuB,QACvB,UAAU,sBACV,EAAE,WAAW;AAEjB;AAMO,SAAS,+CACd,oBAC2C;AAC3C,QAAM,2BAA2B;AAEjC,SACE,OAAO,uBAAuB,YAC9B,yBAAyB,UAAU,UACnC,yBAAyB,SAAS;AAEtC;AAMO,SAAS,gCACd,oBACqD;AACrD,QAAM,2BACJ;AAEF,SACE,OAAO,uBAAuB,YAC9B,6BAA6B,QAC7B,WAAW,4BACX,CAAC,2CAA2C,kBAAkB,MAC7D,kBAAkB,4BACjB,aAAa;AAEnB;",
+  "sourcesContent": ["import type {\n  FilterFieldDuration,\n  FilterFieldKeySuggestionConfig,\n  FilterFieldKeySuggestionGroupConfig,\n  FilterFieldValidatorMapTypePredicate,\n  FilterFieldRichValuePredicate,\n  FilterFieldValueSuggestionGroupConfig,\n} from '../../types/validation.js';\n\n/**\n * Check whether the given value specification is a type specification.\n * @internal\n */\nexport function isFilterFieldValidatorMapTypeSpecification(\n  valueSpecification: unknown,\n  // DEPRECATION: [APPDEV-16872] BREAKING-CHANGE\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n): valueSpecification is FilterFieldValidatorMapTypePredicate {\n  return (\n    typeof valueSpecification === 'object' &&\n    valueSpecification !== null &&\n    'type' in valueSpecification &&\n    !('value' in valueSpecification)\n  );\n}\n\n/**\n * Check whether the given value specification is a duration specification.\n * @internal\n */\nexport function isFilterFieldValidatorMapDurationSpecification(\n  valueSpecification: unknown,\n  // DEPRECATION: [APPDEV-16872] BREAKING-CHANGE\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n): valueSpecification is FilterFieldDuration {\n  // DEPRECATION: [APPDEV-16872] BREAKING-CHANGE\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const castedValueSpecification = valueSpecification as FilterFieldDuration;\n\n  return (\n    typeof valueSpecification === 'object' &&\n    castedValueSpecification.value !== undefined &&\n    castedValueSpecification.unit !== undefined\n  );\n}\n\n/**\n * Check whether the given value specification is a value predicate with metadata.\n * @internal\n */\nexport function isFilterFieldRichValuePredicate(\n  valueSpecification: unknown,\n): valueSpecification is FilterFieldRichValuePredicate {\n  const castedValueSpecification =\n    valueSpecification as FilterFieldRichValuePredicate;\n\n  return (\n    typeof valueSpecification === 'object' &&\n    castedValueSpecification !== null &&\n    'value' in castedValueSpecification &&\n    !isFilterFieldValidatorMapTypeSpecification(valueSpecification) &&\n    ('displayValue' in castedValueSpecification ||\n      'details' in castedValueSpecification)\n  );\n}\n\n/**\n * Check whether the given value is a key suggestion config (has a `key` string property).\n * @internal\n */\nexport function isFilterFieldKeySuggestionConfig(\n  value: unknown,\n): value is FilterFieldKeySuggestionConfig {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'key' in value &&\n    typeof (value as FilterFieldKeySuggestionConfig).key === 'string'\n  );\n}\n\n/**\n * Check whether the given value is a key suggestion group config (has a `suggestions` array and no `key` property).\n * @internal\n */\nexport function isFilterFieldKeySuggestionGroupConfig(\n  value: unknown,\n): value is FilterFieldKeySuggestionGroupConfig {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'suggestions' in value &&\n    Array.isArray((value as FilterFieldKeySuggestionGroupConfig).suggestions) &&\n    !('key' in value)\n  );\n}\n\n/**\n * Check whether the given value is a value suggestion group config (has a `suggestions` array).\n * @internal\n */\nexport function isFilterFieldValueSuggestionGroupConfig(\n  value: unknown,\n): value is FilterFieldValueSuggestionGroupConfig {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'suggestions' in value &&\n    Array.isArray((value as FilterFieldValueSuggestionGroupConfig).suggestions)\n  );\n}\n"],
+  "mappings": "AAaO,SAAS,2CACd,oBAG4D;AAC5D,SACE,OAAO,uBAAuB,YAC9B,uBAAuB,QACvB,UAAU,sBACV,EAAE,WAAW;AAEjB;AAMO,SAAS,+CACd,oBAG2C;AAG3C,QAAM,2BAA2B;AAEjC,SACE,OAAO,uBAAuB,YAC9B,yBAAyB,UAAU,UACnC,yBAAyB,SAAS;AAEtC;AAMO,SAAS,gCACd,oBACqD;AACrD,QAAM,2BACJ;AAEF,SACE,OAAO,uBAAuB,YAC9B,6BAA6B,QAC7B,WAAW,4BACX,CAAC,2CAA2C,kBAAkB,MAC7D,kBAAkB,4BACjB,aAAa;AAEnB;AAMO,SAAS,iCACd,OACyC;AACzC,SACE,OAAO,UAAU,YACjB,UAAU,QACV,SAAS,SACT,OAAQ,MAAyC,QAAQ;AAE7D;AAMO,SAAS,sCACd,OAC8C;AAC9C,SACE,OAAO,UAAU,YACjB,UAAU,QACV,iBAAiB,SACjB,MAAM,QAAS,MAA8C,WAAW,KACxE,EAAE,SAAS;AAEf;AAMO,SAAS,wCACd,OACgD;AAChD,SACE,OAAO,UAAU,YACjB,UAAU,QACV,iBAAiB,SACjB,MAAM,QAAS,MAAgD,WAAW;AAE9E;",
   "names": []
 }

package/esm/filters/filter-field/utils/validation-utils/validation-helper-functions.js

@@ -7,7 +7,8 @@ import {
 import {
   isFilterFieldRichValuePredicate,
   isFilterFieldValidatorMapDurationSpecification,
-  isFilterFieldValidatorMapTypeSpecification
+  isFilterFieldValidatorMapTypeSpecification,
+  isFilterFieldValueSuggestionGroupConfig
 } from "./type-guards.js";
 import {
   isValidIPAddress,
@@ -83,6 +84,14 @@ function isValidSmartscapeIdType(valueType, textValue, validTypes, parserConfig)
   }
   return false;
 }
+function checkIsValidType(valueType, valueTextValue, validTypes, parserConfig, customTypes) {
+  return validTypes.includes("Any") || validTypes.includes(valueType) || validTypes.includes("String") && valueType === "Identifier" || validTypes.includes("Number") && valueType === "BigInt" || isValidIPAddressType(valueType, valueTextValue, validTypes, parserConfig) || isValidUIDType(valueType, valueTextValue, validTypes, parserConfig) || isValidSmartscapeIdType(
+    valueType,
+    valueTextValue,
+    validTypes,
+    parserConfig
+  ) || isValidTimestampType(valueType, valueTextValue, validTypes, parserConfig) || !!isValidCustomType(valueTextValue, customTypes);
+}
 function hasValuePredicate(entry) {
   return !!entry && typeof entry === "object" && typeof entry.valuePredicate === "function";
 }
@@ -103,7 +112,7 @@ function isValidCustomType(textValue, customTypes) {
   }
   return false;
 }
-function isValidOperator(textValue, key, validatorMap, parserConfig) {
+function isValidOperator(textValue, key, internalValidatorMap, parserConfig) {
   const operatorName = getOperatorName(textValue);
   if (operatorName === "") {
     return false;
@@ -111,24 +120,19 @@ function isValidOperator(textValue, key, validatorMap, parserConfig) {
   if (operatorName === "search" && !parserConfig?.searchConversion) {
     return true;
   }
-  return getValidOperators(key, validatorMap, parserConfig).includes(
+  return getValidOperators(key, internalValidatorMap, parserConfig).includes(
     operatorName
   );
 }
-function isValidValue(key, valueTextValue, valueType, validatorMap, currentStatement, filterFieldValue, customTypes, parserConfig) {
-  if (!key || !validatorMap || !validatorMap.keyPredicates || Array.isArray(validatorMap.keyPredicates) || // For now if the value is a variable it should always be valid as we currently
-  // don't have any further information on what the actual value is
-  valueType === "Variable") {
+function isValidValue(key, valueTextValue, valueType, internalValidatorMap, currentStatement, filterFieldValue, customTypes, parserConfig) {
+  if (!key || !internalValidatorMap) {
     return { isValid: true };
   }
-  const predicate = validatorMap.keyPredicates[key];
+  const predicate = internalValidatorMap.normalizedKeys.byKey.get(key);
   if (!predicate) {
     return { isValid: true };
   }
-  const validValues = isFilterFieldValidatorMapTypeSpecification(predicate) ? predicate : predicate.valuePredicate;
-  if (!validValues) {
-    return { isValid: true };
-  }
+  const validValues = predicate.valuePredicate;
   if (typeof validValues === "function") {
     const result = validValues({
       currentStatement,
@@ -139,43 +143,87 @@ function isValidValue(key, valueTextValue, valueType, validatorMap, currentState
     }
     return { isValid: false, message: result };
   }
-  const { types: validTypes, hasLiteralValues } = getValidValueTypes(validValues);
-  const isValidType = validTypes.includes("Any") || validTypes.includes(valueType) || validTypes.includes("String") && valueType === "Identifier" || validTypes.includes("Number") && valueType === "BigInt" || isValidIPAddressType(valueType, valueTextValue, validTypes, parserConfig) || isValidUIDType(valueType, valueTextValue, validTypes, parserConfig) || isValidSmartscapeIdType(
+  if (valueType === "Variable") {
+    return { isValid: true };
+  }
+  let validTypes;
+  let hasLiteralValues;
+  if (predicate.valueType) {
+    validTypes = Array.isArray(predicate.valueType) ? predicate.valueType : [predicate.valueType];
+    hasLiteralValues = Array.isArray(validValues);
+  } else if (validValues !== void 0) {
+    ({ types: validTypes, hasLiteralValues } = getValidValueTypes(validValues));
+  } else {
+    return { isValid: true };
+  }
+  const isValidType = checkIsValidType(
     valueType,
     valueTextValue,
     validTypes,
-    parserConfig
-  ) || isValidTimestampType(valueType, valueTextValue, validTypes, parserConfig) || !!isValidCustomType(valueTextValue, customTypes);
+    parserConfig,
+    customTypes
+  );
   if (Array.isArray(validValues)) {
     let textMatches = false;
     for (const validValue of validValues) {
       if (isFilterFieldValidatorMapTypeSpecification(validValue)) {
         if (!isValidType && !hasLiteralValues || isValidType) {
-          return { isValid: isValidType };
+          return { isValid: isValidType, validTypes };
         }
-      } else if (isFilterFieldValidatorMapDurationSpecification(validValue) || isFilterFieldRichValuePredicate(validValue)) {
-        if (valueTextValue === getValuePredicateTextValue(validValue)) {
-          textMatches = true;
-        }
-      } else {
-        const cleanValidValue = `${validValue}`.replaceAll(/(?<!\\)(?:\\\\)*(\\)(?!\\)/g, "").replaceAll(/(\\\\)/g, "\\");
-        if (valueTextValue === cleanValidValue) {
+      } else if (isFilterFieldValueSuggestionGroupConfig(validValue)) {
+        if (validValue.suggestions.some((suggestion) => {
+          if (isFilterFieldValidatorMapTypeSpecification(suggestion)) {
+            return false;
+          }
+          return literalMatchesTextValue(valueTextValue, suggestion);
+        })) {
           textMatches = true;
         }
+        continue;
+      } else if (literalMatchesTextValue(valueTextValue, validValue)) {
+        textMatches = true;
       }
     }
-    if (!textMatches) {
-      return { isValid: isWildCardOperator(currentStatement) };
-    }
-    return { isValid: textMatches };
+    return {
+      isValid: textMatches || isWildCardOperator(currentStatement),
+      validTypes
+    };
   }
   if (isFilterFieldValidatorMapTypeSpecification(validValues)) {
+    return { isValid: isValidType, validTypes };
+  }
+  if (isFilterFieldValueSuggestionGroupConfig(validValues)) {
+    const groupSuggestionMatches = validValues.suggestions.some(
+      (suggestion) => {
+        if (isFilterFieldValidatorMapTypeSpecification(suggestion)) {
+          return false;
+        }
+        return literalMatchesTextValue(valueTextValue, suggestion);
+      }
+    );
+    return {
+      isValid: groupSuggestionMatches || isWildCardOperator(currentStatement)
+    };
+  }
+  if (validValues === void 0) {
     return { isValid: isValidType };
   }
   return {
-    isValid: valueTextValue === getValuePredicateTextValue(validValues)
+    isValid: literalMatchesTextValue(valueTextValue, validValues),
+    validTypes
   };
 }
+function literalMatchesTextValue(textValue, predicate) {
+  if (isFilterFieldValidatorMapDurationSpecification(predicate)) {
+    return textValue === `${predicate.value}${predicate.unit}`;
+  }
+  if (isFilterFieldRichValuePredicate(predicate)) {
+    const cleaned2 = `${predicate.value}`.replaceAll(/(?<!\\)(?:\\\\)*(\\)(?!\\)/g, "").replaceAll(/(\\\\)/g, "\\");
+    return textValue === cleaned2;
+  }
+  const cleaned = `${predicate}`.replaceAll(/(?<!\\)(?:\\\\)*(\\)(?!\\)/g, "").replaceAll(/(\\\\)/g, "\\");
+  return textValue === cleaned;
+}
 function getValuePredicateTextValue(predicate) {
   if (isFilterFieldValidatorMapDurationSpecification(predicate)) {
     return `${predicate.value}${predicate.unit}`;
@@ -185,43 +233,42 @@ function getValuePredicateTextValue(predicate) {
     return `${predicate}`;
   }
 }
-function getValidOperators(key, validatorMap, parserConfig) {
+function getValidOperators(key, internalValidatorMap, parserConfig) {
   key = typeof key === "string" ? key.replace(/^"(.*?(?<!\\)(?:\\\\)*)"$/, "$1") : key;
   const defaultOperators = [
     ...FILTERFIELD_DEFAULT_OPERATORS,
     // eslint-disable-next-line @typescript-eslint/no-deprecated
     ...parserConfig?.searchConversion ? ["search"] : []
   ];
-  if (!validatorMap) {
+  if (!internalValidatorMap) {
     return defaultOperators;
   }
-  const globalOperators = validatorMap.comparisonOperators || defaultOperators;
-  if (Array.isArray(validatorMap.keyPredicates)) {
-    return globalOperators;
-  }
-  const predicate = key && validatorMap.keyPredicates ? validatorMap.keyPredicates[key] : void 0;
+  const globalOperators = internalValidatorMap.comparisonOperators || defaultOperators;
+  const predicate = key ? internalValidatorMap.normalizedKeys.byKey.get(key) : void 0;
   if (!predicate && key === "*") {
     return [];
   }
   if (!predicate) {
     return globalOperators;
   }
-  const isTypeSpecification = isFilterFieldValidatorMapTypeSpecification(predicate);
-  const valuePredicate = isTypeSpecification ? predicate : predicate.valuePredicate;
-  const allowedTypes = !valuePredicate || typeof valuePredicate === "function" ? "Any" : getValidValueTypes(valuePredicate).types;
-  if (!isTypeSpecification && predicate.comparisonOperators) {
-    return predicate.comparisonOperators || [];
+  if (predicate.comparisonOperators) {
+    return predicate.comparisonOperators;
+  }
+  let allowedTypes;
+  if (predicate.valueType) {
+    allowedTypes = Array.isArray(predicate.valueType) ? predicate.valueType : [predicate.valueType];
+  } else if (!predicate.valuePredicate || typeof predicate.valuePredicate === "function") {
+    allowedTypes = "Any";
+  } else {
+    allowedTypes = getValidValueTypes(predicate.valuePredicate).types;
   }
-  if (allowedTypes && allowedTypes !== "Any") {
+  if (allowedTypes !== "Any") {
     return intersectOperators(
       globalOperators,
-      (Array.isArray(allowedTypes) ? allowedTypes : [allowedTypes]).reduce(
-        (acc, type) => {
-          acc.push(...getAllowedOperatorsForType(type));
-          return acc;
-        },
-        []
-      )
+      allowedTypes.reduce((acc, type) => {
+        acc.push(...getAllowedOperatorsForType(type));
+        return acc;
+      }, [])
     );
   }
   return globalOperators;
@@ -246,8 +293,8 @@ const OPERATOR_SHORT_NAME_MAP = {
   exists: "= *",
   "not-exists": "!= *"
 };
-function getValidOperatorsShort(key, validatorMap, parserConfig) {
-  const operators = getValidOperators(key, validatorMap, parserConfig);
+function getValidOperatorsShort(key, internalValidatorMap, parserConfig) {
+  const operators = getValidOperators(key, internalValidatorMap, parserConfig);
   const result = [];
   for (const [key2, value] of Object.entries(OPERATOR_SHORT_NAME_MAP)) {
     if (operators.includes(key2)) {
@@ -256,8 +303,8 @@ function getValidOperatorsShort(key, validatorMap, parserConfig) {
   }
   return result;
 }
-function getValidOperatorsColored(key, validatorMap, parserConfig) {
-  return getValidOperatorsShort(key, validatorMap, parserConfig).map(
+function getValidOperatorsColored(key, internalValidatorMap, parserConfig) {
+  return getValidOperatorsShort(key, internalValidatorMap, parserConfig).map(
     (operator) => `<span style="color: ${Colors.Syntax.Operators}">${operator}</span>`
   ).join(", ");
 }