silver-ui 0.1.0

package/dist/chunk-ELCRG7WZ.js

@@ -0,0 +1,2090 @@
+import { VStack, HStack } from './chunk-Z2STCD6I.js';
+import { TagsInput } from './chunk-2XCNB2O6.js';
+import { Select } from './chunk-XQMLA75S.js';
+import { NumberInput } from './chunk-3PSQDJQH.js';
+import { TextInput } from './chunk-H6OY6FLC.js';
+import { TimeInput } from './chunk-NOZ6U6ZJ.js';
+import { DateInput } from './chunk-IWSS5745.js';
+import { plainDateFromUnixSeconds, plainDateToUnixSeconds } from './chunk-QSEDH7T2.js';
+import { AutocompleteInputItem, createStaticSource, AutocompleteInput } from './chunk-IT72TF72.js';
+import { Tag } from './chunk-2FUG6NKO.js';
+import { Popover } from './chunk-2QK2NZN5.js';
+import { getBrowserTimezoneID, nowEpochMilliseconds } from './chunk-OX4ZMUF4.js';
+import { Button } from './chunk-VLIQPSPM.js';
+import { Text } from './chunk-PZO5MZ46.js';
+import { css } from './chunk-UHQRL4OA.js';
+import { Search, X } from 'lucide-react';
+import { useState, useRef, useEffect, useMemo, useImperativeHandle, useCallback } from 'react';
+import { Temporal } from '@js-temporal/polyfill';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+function enumItemsToSearchableItems(values) {
+  return values.map((item) => ({ id: item.value, label: item.label }));
+}
+function emptySource() {
+  return { bootstrap: () => [], search: () => [] };
+}
+function StringEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  const currentValue = filterValue?.type === "string" ? filterValue.value : "";
+  if (operatorValue.searchSource != null) {
+    const selectedItem = currentValue === "" ? null : { id: currentValue, label: currentValue };
+    return /* @__PURE__ */ jsx(
+      AutocompleteInput,
+      {
+        debounceMs: 150,
+        isLabelHidden: true,
+        label: "Value",
+        onChange: (item) => {
+          onChange({ type: "string", value: item?.label ?? "" }, item != null);
+        },
+        placeholder: "Search...",
+        searchSource: operatorValue.searchSource,
+        value: selectedItem
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    TextInput,
+    {
+      isLabelHidden: true,
+      label: "Value",
+      onChange: (value) => onChange({ type: "string", value }),
+      placeholder: "Enter value...",
+      value: currentValue
+    }
+  );
+}
+function StringListEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  const currentValue = useMemo(() => {
+    if (filterValue?.type !== "string_list") {
+      return [];
+    }
+    return filterValue.value.map((value) => ({ id: value, label: value }));
+  }, [filterValue]);
+  const source = operatorValue.searchSource ?? emptySource();
+  const hasCreate = operatorValue.isArbitraryStringAllowed === true || operatorValue.searchSource == null;
+  return /* @__PURE__ */ jsx(
+    TagsInput,
+    {
+      debounceMs: operatorValue.searchSource == null ? 0 : 150,
+      hasCreate,
+      isLabelHidden: true,
+      label: "Values",
+      onChange: (items) => {
+        onChange({
+          type: "string_list",
+          value: items.map((item) => item.label)
+        });
+      },
+      placeholder: "Add values...",
+      searchSource: source,
+      value: currentValue
+    }
+  );
+}
+function IntegerEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  return /* @__PURE__ */ jsx(
+    NumberInput,
+    {
+      isIntegerOnly: true,
+      isLabelHidden: true,
+      label: "Value",
+      max: operatorValue.maxValue,
+      min: operatorValue.minValue,
+      onChange: (value) => onChange({ type: "integer", value }),
+      placeholder: "Enter number...",
+      units: operatorValue.units,
+      value: filterValue?.type === "integer" ? filterValue.value : null
+    }
+  );
+}
+function FloatEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  return /* @__PURE__ */ jsx(
+    NumberInput,
+    {
+      isLabelHidden: true,
+      label: "Value",
+      max: operatorValue.maxValue,
+      min: operatorValue.minValue,
+      onChange: (value) => onChange({ type: "float", value }),
+      placeholder: "Enter number...",
+      units: operatorValue.units,
+      value: filterValue?.type === "float" ? filterValue.value : null
+    }
+  );
+}
+function TimeEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  return /* @__PURE__ */ jsx(
+    TimeInput,
+    {
+      isLabelHidden: true,
+      label: "Time",
+      max: typeof operatorValue.maxValue === "string" ? Temporal.PlainTime.from(operatorValue.maxValue) : void 0,
+      min: typeof operatorValue.minValue === "string" ? Temporal.PlainTime.from(operatorValue.minValue) : void 0,
+      onChange: (value) => {
+        if (value != null) {
+          onChange({ type: "time", value: value.toString() });
+        }
+      },
+      value: filterValue?.type === "time" ? Temporal.PlainTime.from(filterValue.value) : void 0
+    }
+  );
+}
+function DateAbsoluteEditor({
+  filterValue,
+  onChange,
+  timezoneID
+}) {
+  return /* @__PURE__ */ jsx(
+    DateInput,
+    {
+      isLabelHidden: true,
+      label: "Date",
+      onChange: (value) => {
+        if (value != null) {
+          onChange({
+            type: "date_absolute",
+            unixSeconds: plainDateToUnixSeconds(value, timezoneID)
+          });
+        }
+      },
+      value: filterValue?.type === "date_absolute" ? plainDateFromUnixSeconds(filterValue.unixSeconds, timezoneID) : void 0
+    }
+  );
+}
+function DateRelativeEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  const options = useMemo(() => {
+    const result = [];
+    const units = [
+      { plural: "days", unit: "day" },
+      { plural: "weeks", unit: "week" },
+      { plural: "months", unit: "month" }
+    ];
+    for (const { plural, unit } of units) {
+      const amounts = unit === "day" ? [1, 3, 7, 14, 30] : unit === "week" ? [1, 2, 4] : [1, 3, 6, 12];
+      for (const amount of amounts) {
+        if (operatorValue.isPastAllowed !== false) {
+          result.push({
+            label: `${amount} ${amount === 1 ? unit : plural} ago`,
+            value: `${amount}${unit[0]}_ago`
+          });
+        }
+        if (operatorValue.isFutureAllowed !== false) {
+          result.push({
+            label: `${amount} ${amount === 1 ? unit : plural} from now`,
+            value: `${amount}${unit[0]}_from_now`
+          });
+        }
+      }
+    }
+    return result;
+  }, [operatorValue.isFutureAllowed, operatorValue.isPastAllowed]);
+  return /* @__PURE__ */ jsx(
+    Select,
+    {
+      isLabelHidden: true,
+      label: "Relative date",
+      onChange: (value) => {
+        if (value != null) {
+          onChange({ type: "date_relative", value }, true);
+        }
+      },
+      options,
+      value: filterValue?.type === "date_relative" ? filterValue.value : null
+    }
+  );
+}
+function DateRangeEditor({
+  filterValue,
+  onChange,
+  timezoneID
+}) {
+  const startValue = filterValue?.type === "date_range" && filterValue.value.start.type === "ABSOLUTE" ? plainDateFromUnixSeconds(
+    filterValue.value.start.unixSeconds,
+    timezoneID
+  ) : void 0;
+  const endValue = filterValue?.type === "date_range" && filterValue.value.end.type === "ABSOLUTE" ? plainDateFromUnixSeconds(filterValue.value.end.unixSeconds, timezoneID) : void 0;
+  const handleStartChange = useCallback(
+    (value) => {
+      const existingEnd = filterValue?.type === "date_range" ? filterValue.value.end : { type: "NOW" };
+      onChange({
+        type: "date_range",
+        value: {
+          end: existingEnd,
+          start: {
+            type: "ABSOLUTE",
+            unixSeconds: value == null ? 0 : plainDateToUnixSeconds(value, timezoneID)
+          }
+        }
+      });
+    },
+    [filterValue, onChange, timezoneID]
+  );
+  const handleEndChange = useCallback(
+    (value) => {
+      const existingStart = filterValue?.type === "date_range" ? filterValue.value.start : { type: "NOW" };
+      onChange({
+        type: "date_range",
+        value: {
+          end: {
+            type: "ABSOLUTE",
+            unixSeconds: value == null ? 0 : plainDateToUnixSeconds(value, timezoneID)
+          },
+          start: existingStart
+        }
+      });
+    },
+    [filterValue, onChange, timezoneID]
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      DateInput,
+      {
+        isLabelHidden: true,
+        label: "Start date",
+        onChange: handleStartChange,
+        value: startValue
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      DateInput,
+      {
+        isLabelHidden: true,
+        label: "End date",
+        onChange: handleEndChange,
+        value: endValue
+      }
+    )
+  ] });
+}
+function EnumEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  return /* @__PURE__ */ jsx(
+    Select,
+    {
+      isLabelHidden: true,
+      label: "Value",
+      onChange: (value) => {
+        if (value != null) {
+          onChange({ type: "enum", value }, true);
+        }
+      },
+      options: operatorValue.values.map((item) => ({
+        icon: item.icon,
+        label: item.label,
+        value: item.value
+      })),
+      value: filterValue?.type === "enum" ? filterValue.value : null
+    }
+  );
+}
+function EnumListEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  const items = useMemo(
+    () => enumItemsToSearchableItems(operatorValue.values),
+    [operatorValue.values]
+  );
+  const source = useMemo(() => createStaticSource(items), [items]);
+  const currentValue = useMemo(() => {
+    if (filterValue?.type !== "enum_list") {
+      return [];
+    }
+    return filterValue.value.map((value) => ({
+      id: value,
+      label: operatorValue.values.find((item) => item.value === value)?.label ?? value
+    }));
+  }, [filterValue, operatorValue.values]);
+  return /* @__PURE__ */ jsx(
+    TagsInput,
+    {
+      debounceMs: 0,
+      hasEntriesOnFocus: true,
+      isLabelHidden: true,
+      label: "Values",
+      onChange: (items2) => {
+        onChange({ type: "enum_list", value: items2.map((item) => item.id) });
+      },
+      placeholder: "Select values...",
+      searchSource: source,
+      value: currentValue
+    }
+  );
+}
+function EntityListEditor({
+  operatorValue,
+  filterValue,
+  onChange
+}) {
+  const source = operatorValue.searchSource ?? emptySource();
+  const currentValue = useMemo(() => {
+    if (filterValue?.type !== "entity_list") {
+      return [];
+    }
+    return filterValue.value.map((entity) => ({
+      auxiliaryData: entity.photo == null ? void 0 : { photo: entity.photo },
+      id: entity.id,
+      label: entity.label
+    }));
+  }, [filterValue]);
+  return /* @__PURE__ */ jsx(
+    TagsInput,
+    {
+      debounceMs: operatorValue.searchSource == null ? 0 : 150,
+      isLabelHidden: true,
+      label: "Entities",
+      onChange: (items) => {
+        onChange({
+          type: "entity_list",
+          value: items.map((item) => ({
+            id: item.id,
+            label: item.label,
+            ...typeof item.auxiliaryData === "object" && item.auxiliaryData != null && "photo" in item.auxiliaryData ? { photo: String(item.auxiliaryData.photo) } : {}
+          }))
+        });
+      },
+      placeholder: "Search...",
+      renderItem: operatorValue.renderItem,
+      searchSource: source,
+      value: currentValue
+    }
+  );
+}
+function CustomEditor({
+  operatorValue,
+  filterValue,
+  isDisabled,
+  onChange
+}) {
+  const EditorComponent = operatorValue.Editor;
+  return /* @__PURE__ */ jsx(
+    EditorComponent,
+    {
+      isDisabled,
+      onChange: (value) => {
+        if (value != null) {
+          onChange({ type: "custom", value });
+        }
+      },
+      placeholder: "Enter value...",
+      value: filterValue?.type === "custom" ? filterValue.value : null
+    }
+  );
+}
+function SearchFilterInputValueEditor({
+  filterValue,
+  isDisabled,
+  onChange,
+  onEnter,
+  operatorValue,
+  timezoneID
+}) {
+  const effectiveTimezoneID = timezoneID ?? getBrowserTimezoneID();
+  switch (operatorValue.type) {
+    case "empty":
+    case "nested":
+      return null;
+    case "string":
+      return /* @__PURE__ */ jsx(
+        StringEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "string_list":
+      return /* @__PURE__ */ jsx(
+        StringListEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "integer":
+      return /* @__PURE__ */ jsx(
+        IntegerEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "float":
+      return /* @__PURE__ */ jsx(
+        FloatEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "time":
+      return /* @__PURE__ */ jsx(
+        TimeEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "date_absolute":
+      return /* @__PURE__ */ jsx(
+        DateAbsoluteEditor,
+        {
+          filterValue,
+          onChange,
+          timezoneID: effectiveTimezoneID
+        }
+      );
+    case "date_relative":
+      return /* @__PURE__ */ jsx(
+        DateRelativeEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "date_range":
+      return /* @__PURE__ */ jsx(
+        DateRangeEditor,
+        {
+          filterValue,
+          onChange,
+          timezoneID: effectiveTimezoneID
+        }
+      );
+    case "enum":
+      return /* @__PURE__ */ jsx(
+        EnumEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "enum_list":
+      return /* @__PURE__ */ jsx(
+        EnumListEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "entity_list":
+      return /* @__PURE__ */ jsx(
+        EntityListEditor,
+        {
+          filterValue,
+          onChange,
+          operatorValue
+        }
+      );
+    case "custom":
+      return /* @__PURE__ */ jsx(
+        CustomEditor,
+        {
+          filterValue,
+          isDisabled,
+          onChange,
+          operatorValue
+        }
+      );
+  }
+}
+var styles = {
+  root: css({
+    overflow: "hidden",
+    minW: "100"
+  }),
+  content: css({
+    p: "4"
+  }),
+  footer: css({
+    px: "3",
+    pb: "3"
+  }),
+  fieldSelector: css({
+    flexShrink: 0
+  }),
+  operatorSelector: css({
+    flex: "1 0 auto"
+  }),
+  valueEditor: css({
+    flex: "2 1 0",
+    minW: 0
+  }),
+  nestedList: css({
+    display: "flex",
+    flexDirection: "column",
+    gap: "2",
+    w: "full",
+    listStyleType: "none",
+    m: 0,
+    p: 0
+  }),
+  nestedNode: css({
+    display: "flex",
+    flexDirection: "column",
+    gap: "2",
+    ps: "3",
+    borderInlineStartWidth: "default",
+    borderInlineStartStyle: "solid",
+    borderColor: "border"
+  }),
+  nestedRow: css({
+    display: "flex",
+    alignItems: "center",
+    gap: "2",
+    w: "full"
+  }),
+  nestedCell: css({
+    minW: 0
+  }),
+  nestedField: css({
+    flex: "0 0 200px"
+  }),
+  nestedOperator: css({
+    flex: "0 0 180px"
+  }),
+  nestedValue: css({
+    flex: "2 1 0"
+  })
+};
+function initEditableFilter(config, filter) {
+  const operator = config.getOperator(filter.field, filter.operator);
+  if (operator?.value.type === "nested" && filter.value.type === "nested") {
+    return {
+      _subFilters: filter.value.value.map(
+        (subFilter) => initEditableFilter(config, subFilter)
+      ),
+      field: filter.field,
+      operator: filter.operator,
+      value: filter.value
+    };
+  }
+  return {
+    field: filter.field,
+    operator: filter.operator,
+    value: filter.value
+  };
+}
+function isEditableFilterComplete(config, filter) {
+  if (filter.operator == null) {
+    return false;
+  }
+  const operator = config.getOperator(filter.field, filter.operator);
+  if (operator?.value.type === "nested") {
+    const subFilters = filter._subFilters ?? [];
+    return subFilters.length > 0 && subFilters.every((subFilter) => isEditableFilterComplete(config, subFilter));
+  }
+  return filter.value != null;
+}
+function editableToCompleteFilter(config, filter) {
+  if (filter.operator == null) {
+    return null;
+  }
+  const operator = config.getOperator(filter.field, filter.operator);
+  if (operator?.value.type === "nested") {
+    return {
+      field: filter.field,
+      operator: filter.operator,
+      value: {
+        type: "nested",
+        value: (filter._subFilters ?? []).map((subFilter) => editableToCompleteFilter(config, subFilter)).filter(
+          (subFilter) => subFilter != null
+        )
+      }
+    };
+  }
+  if (filter.value == null) {
+    return null;
+  }
+  return { field: filter.field, operator: filter.operator, value: filter.value };
+}
+function NestedSubFilterRow({
+  config,
+  isReadOnly,
+  onChange,
+  onRemove,
+  subFilter
+}) {
+  const fieldOptions = useMemo(
+    () => config.getVisibleFields().map((field) => ({ label: field.label, value: field.key })),
+    [config]
+  );
+  const operatorOptions = useMemo(
+    () => config.getVisibleOperators(subFilter.field).map((operator) => ({ label: operator.label, value: operator.key })),
+    [config, subFilter.field]
+  );
+  const currentOperator = subFilter.operator == null ? void 0 : config.getOperator(subFilter.field, subFilter.operator);
+  const operatorValue = currentOperator?.value;
+  const isNested = operatorValue?.type === "nested";
+  const isEmpty = operatorValue?.type === "empty";
+  return /* @__PURE__ */ jsxs("div", { className: styles.nestedRow, children: [
+    /* @__PURE__ */ jsx("div", { className: `${styles.nestedCell} ${styles.nestedField}`, children: /* @__PURE__ */ jsx(
+      Select,
+      {
+        isDisabled: isReadOnly,
+        isLabelHidden: true,
+        label: "Field",
+        onChange: (fieldKey) => {
+          if (fieldKey == null) {
+            return;
+          }
+          const defaultOperator = config.getDefaultOperator(fieldKey);
+          const nextOperator = defaultOperator == null ? void 0 : config.getOperator(fieldKey, defaultOperator.key);
+          onChange({
+            _subFilters: nextOperator?.value.type === "nested" ? [] : void 0,
+            field: fieldKey,
+            operator: defaultOperator?.key,
+            value: void 0
+          });
+        },
+        options: fieldOptions,
+        value: subFilter.field
+      }
+    ) }),
+    operatorOptions.length > 0 ? /* @__PURE__ */ jsx("div", { className: `${styles.nestedCell} ${styles.nestedOperator}`, children: /* @__PURE__ */ jsx(
+      Select,
+      {
+        isDisabled: isReadOnly,
+        isLabelHidden: true,
+        label: "Operator",
+        onChange: (operatorKey) => {
+          if (operatorKey == null) {
+            return;
+          }
+          const nextOperator = config.getOperator(
+            subFilter.field,
+            operatorKey
+          );
+          const keepValue = nextOperator != null && nextOperator.value.type === currentOperator?.value.type;
+          onChange({
+            ...subFilter,
+            _subFilters: nextOperator?.value.type === "nested" ? subFilter._subFilters ?? [] : void 0,
+            operator: operatorKey,
+            value: keepValue ? subFilter.value : void 0
+          });
+        },
+        options: operatorOptions,
+        value: subFilter.operator ?? null
+      }
+    ) }) : null,
+    operatorValue != null && !isEmpty && !isNested ? /* @__PURE__ */ jsx("div", { className: `${styles.nestedCell} ${styles.nestedValue}`, children: /* @__PURE__ */ jsx(
+      SearchFilterInputValueEditor,
+      {
+        config,
+        filterValue: subFilter.value,
+        isDisabled: isReadOnly,
+        onChange: (value) => onChange({ ...subFilter, value }),
+        operatorValue
+      }
+    ) }) : null,
+    !isReadOnly ? /* @__PURE__ */ jsx(
+      Button,
+      {
+        icon: X,
+        isIconOnly: true,
+        label: "Remove filter",
+        onClick: onRemove,
+        size: "sm",
+        variant: "ghost"
+      }
+    ) : null
+  ] });
+}
+function NestedEditor({
+  config,
+  isReadOnly,
+  onPartialFilterChange,
+  onOperatorChange,
+  operatorOptions,
+  partialFilter
+}) {
+  const [subFilters, setSubFilters] = useState(() => {
+    if (partialFilter.value?.type === "nested") {
+      return partialFilter.value.value.map(
+        (filter) => initEditableFilter(config, filter)
+      );
+    }
+    return [];
+  });
+  const syncToParent = useCallback(
+    (nextSubFilters) => {
+      if (nextSubFilters.length > 0 && nextSubFilters.every((filter) => isEditableFilterComplete(config, filter))) {
+        onPartialFilterChange({
+          ...partialFilter,
+          value: {
+            type: "nested",
+            value: nextSubFilters.map((filter) => editableToCompleteFilter(config, filter)).filter(
+              (filter) => filter != null
+            )
+          }
+        });
+      } else {
+        onPartialFilterChange({ ...partialFilter, value: void 0 });
+      }
+    },
+    [config, onPartialFilterChange, partialFilter]
+  );
+  const addSubFilter = () => {
+    const fields = config.getVisibleFields();
+    if (fields.length === 0) {
+      return;
+    }
+    const field = fields[0];
+    const operator = config.getDefaultOperator(field.key);
+    const next = {
+      field: field.key,
+      operator: operator?.key,
+      value: void 0,
+      _subFilters: operator?.value.type === "nested" ? [] : void 0
+    };
+    setSubFilters((previous) => {
+      const updated = [...previous, next];
+      syncToParent(updated);
+      return updated;
+    });
+  };
+  const updateSubFilter = (index, nextSubFilter) => {
+    setSubFilters((previous) => {
+      const updated = [...previous];
+      updated[index] = nextSubFilter;
+      syncToParent(updated);
+      return updated;
+    });
+  };
+  const removeSubFilter = (index) => {
+    setSubFilters((previous) => {
+      const updated = previous.filter((_, i) => i !== index);
+      syncToParent(updated);
+      return updated;
+    });
+  };
+  return /* @__PURE__ */ jsxs(VStack, { gap: 2, children: [
+    operatorOptions.length > 1 ? /* @__PURE__ */ jsx(
+      Select,
+      {
+        isDisabled: isReadOnly,
+        isLabelHidden: true,
+        label: "Group operator",
+        onChange: (operatorKey) => {
+          if (operatorKey != null) {
+            onOperatorChange(operatorKey);
+          }
+        },
+        options: operatorOptions,
+        value: partialFilter.operator ?? null
+      }
+    ) : null,
+    /* @__PURE__ */ jsx("ul", { className: styles.nestedList, role: "group", children: subFilters.map((subFilter, index) => /* @__PURE__ */ jsx("li", { className: styles.nestedNode, children: /* @__PURE__ */ jsx(
+      NestedSubFilterRow,
+      {
+        config,
+        isReadOnly,
+        onChange: (nextSubFilter) => updateSubFilter(index, nextSubFilter),
+        onRemove: () => removeSubFilter(index),
+        subFilter
+      }
+    ) }, `${subFilter.field}-${index}`)) }),
+    !isReadOnly ? /* @__PURE__ */ jsx(
+      Button,
+      {
+        label: "+ Add filter",
+        onClick: addSubFilter,
+        size: "sm",
+        variant: "ghost"
+      }
+    ) : null
+  ] });
+}
+function SearchFilterInputEditPopover({
+  config,
+  filter: initialFilter,
+  isReadOnly = false,
+  maxOperatorMenuItems,
+  mode,
+  onCancel,
+  onSave,
+  saveButtonLabel = "Apply"
+}) {
+  const [partialFilter, setPartialFilter] = useState(initialFilter);
+  const valueEditorRef = useRef(null);
+  const currentOperator = partialFilter.operator == null ? void 0 : config.getOperator(partialFilter.field, partialFilter.operator);
+  const operatorValue = currentOperator?.value;
+  const isEmptyType = operatorValue?.type === "empty";
+  const isNestedType = operatorValue?.type === "nested";
+  useEffect(() => {
+    let innerFrame;
+    const frame = requestAnimationFrame(() => {
+      innerFrame = requestAnimationFrame(() => {
+        valueEditorRef.current?.querySelector(
+          'input:not([disabled]), button:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])'
+        )?.focus();
+      });
+    });
+    return () => {
+      cancelAnimationFrame(frame);
+      if (innerFrame != null) {
+        cancelAnimationFrame(innerFrame);
+      }
+    };
+  }, []);
+  useEffect(() => {
+    if (isEmptyType && partialFilter.operator != null) {
+      onSave({
+        field: partialFilter.field,
+        operator: partialFilter.operator,
+        value: { type: "empty" }
+      });
+    }
+  }, [isEmptyType, onSave, partialFilter.field, partialFilter.operator]);
+  const fieldOptions = useMemo(
+    () => config.getVisibleFields().map((field) => ({ label: field.label, value: field.key })),
+    [config]
+  );
+  const operatorOptions = useMemo(() => {
+    const allOptions = config.getVisibleOperators(partialFilter.field).map((operator) => ({ label: operator.label, value: operator.key }));
+    return maxOperatorMenuItems != null ? allOptions.slice(0, maxOperatorMenuItems) : allOptions;
+  }, [config, maxOperatorMenuItems, partialFilter.field]);
+  const isSaveDisabled = partialFilter.operator == null || partialFilter.value == null;
+  const handleSave = () => {
+    if (partialFilter.operator != null && partialFilter.value != null) {
+      onSave({
+        field: partialFilter.field,
+        operator: partialFilter.operator,
+        value: partialFilter.value
+      });
+    }
+  };
+  const handleFieldChange = (fieldKey) => {
+    if (fieldKey == null) {
+      return;
+    }
+    const defaultOperator = config.getDefaultOperator(fieldKey);
+    setPartialFilter({
+      field: fieldKey,
+      operator: defaultOperator?.key,
+      value: void 0
+    });
+  };
+  const handleOperatorChange = (operatorKey) => {
+    if (operatorKey == null) {
+      return;
+    }
+    const nextOperator = config.getOperator(partialFilter.field, operatorKey);
+    const keepValue = nextOperator != null && nextOperator.value.type === currentOperator?.value.type;
+    setPartialFilter((previous) => ({
+      ...previous,
+      operator: operatorKey,
+      value: keepValue ? previous.value : void 0
+    }));
+  };
+  const footer = !isEmptyType ? /* @__PURE__ */ jsx("div", { className: styles.footer, children: /* @__PURE__ */ jsxs(HStack, { gap: 2, hAlign: "between", children: [
+    !isReadOnly && mode === "edit" ? /* @__PURE__ */ jsx(
+      Button,
+      {
+        label: "Delete",
+        onClick: () => onSave(null),
+        size: "sm",
+        variant: "ghost"
+      }
+    ) : /* @__PURE__ */ jsx("div", {}),
+    /* @__PURE__ */ jsxs(HStack, { gap: 2, children: [
+      /* @__PURE__ */ jsx(Button, { label: "Cancel", onClick: onCancel, size: "sm", variant: "ghost" }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          isDisabled: isSaveDisabled,
+          label: saveButtonLabel,
+          onClick: handleSave,
+          size: "sm",
+          variant: "primary"
+        }
+      )
+    ] })
+  ] }) }) : null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: styles.root,
+      onKeyDown: (event) => {
+        if (event.key === "Enter" && !isSaveDisabled) {
+          const target = event.target;
+          const isInsideSelect = target.closest('[role="listbox"]') != null || target.closest('[role="option"]') != null || target.getAttribute("aria-expanded") === "true";
+          if (!isInsideSelect) {
+            event.preventDefault();
+            handleSave();
+          }
+        } else if (event.key === "Escape" && !event.defaultPrevented) {
+          event.preventDefault();
+          onCancel();
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", { className: styles.content, children: /* @__PURE__ */ jsxs(VStack, { gap: 2, children: [
+          /* @__PURE__ */ jsxs(HStack, { gap: 2, children: [
+            /* @__PURE__ */ jsx("div", { className: styles.fieldSelector, children: /* @__PURE__ */ jsx(
+              Select,
+              {
+                isDisabled: isReadOnly,
+                isLabelHidden: true,
+                label: "Field",
+                onChange: handleFieldChange,
+                options: fieldOptions,
+                value: partialFilter.field
+              }
+            ) }),
+            !isNestedType && operatorOptions.length > 0 ? /* @__PURE__ */ jsx("div", { className: styles.operatorSelector, children: /* @__PURE__ */ jsx(
+              Select,
+              {
+                isDisabled: isReadOnly,
+                isLabelHidden: true,
+                label: "Operator",
+                onChange: handleOperatorChange,
+                options: operatorOptions,
+                value: partialFilter.operator ?? null
+              }
+            ) }) : null,
+            operatorValue != null && !isEmptyType && !isNestedType ? /* @__PURE__ */ jsx("div", { className: styles.valueEditor, ref: valueEditorRef, children: /* @__PURE__ */ jsx(
+              SearchFilterInputValueEditor,
+              {
+                config,
+                filterValue: partialFilter.value,
+                isDisabled: isReadOnly,
+                onChange: (value, shouldSave) => {
+                  const updated = { ...partialFilter, value };
+                  setPartialFilter(updated);
+                  if (shouldSave === true && updated.operator != null) {
+                    onSave({
+                      field: updated.field,
+                      operator: updated.operator,
+                      value: updated.value
+                    });
+                  }
+                },
+                onEnter: handleSave,
+                operatorValue
+              }
+            ) }) : null
+          ] }),
+          isNestedType ? /* @__PURE__ */ jsx(
+            NestedEditor,
+            {
+              config,
+              isReadOnly,
+              onOperatorChange: (operatorKey) => setPartialFilter((previous) => ({
+                ...previous,
+                operator: operatorKey
+              })),
+              onPartialFilterChange: setPartialFilter,
+              operatorOptions,
+              partialFilter
+            }
+          ) : null
+        ] }) }),
+        footer
+      ]
+    }
+  );
+}
+SearchFilterInputEditPopover.displayName = "SearchFilterInputEditPopover";
+
+// src/components/SearchFilterInput/formatFilterValue.ts
+function truncate(value, maxLength) {
+  return value.length > maxLength ? `${value.slice(0, maxLength - 1)}...` : value;
+}
+function enumLabel(value, values) {
+  return values.find((item) => item.value === value)?.label ?? value;
+}
+function numberValue(value, units) {
+  const formatted = new Intl.NumberFormat().format(value);
+  return units == null ? formatted : `${formatted} ${units}`;
+}
+function formatFilterValue(_config, operatorValue, filterValue, maxLength, timezoneID) {
+  switch (filterValue.type) {
+    case "empty":
+      return "";
+    case "string":
+      return truncate(filterValue.value, maxLength);
+    case "string_list": {
+      const joined = filterValue.value.join(", ");
+      return joined.length <= maxLength ? joined : `${filterValue.value.length} items`;
+    }
+    case "integer":
+      return numberValue(
+        filterValue.value,
+        operatorValue.type === "integer" ? operatorValue.units : void 0
+      );
+    case "float":
+      return numberValue(
+        filterValue.value,
+        operatorValue.type === "float" ? operatorValue.units : void 0
+      );
+    case "time":
+      return filterValue.value;
+    case "date_absolute":
+      return truncate(
+        new Intl.DateTimeFormat(void 0, {
+          day: "numeric",
+          hour: "numeric",
+          minute: "2-digit",
+          month: "short",
+          timeZone: timezoneID,
+          year: "numeric"
+        }).format(filterValue.unixSeconds * 1e3),
+        maxLength
+      );
+    case "date_relative":
+      return filterValue.value;
+    case "date_range":
+      return "date range";
+    case "enum":
+      return truncate(
+        operatorValue.type === "enum" ? enumLabel(filterValue.value, operatorValue.values) : filterValue.value,
+        maxLength
+      );
+    case "enum_list": {
+      const labels = operatorValue.type === "enum_list" ? filterValue.value.map(
+        (value) => enumLabel(value, operatorValue.values)
+      ) : filterValue.value;
+      const joined = labels.join(", ");
+      return joined.length <= maxLength ? joined : `${labels.length} items`;
+    }
+    case "entity_list": {
+      const joined = filterValue.value.map((entity) => entity.label).join(", ");
+      return joined.length <= maxLength ? joined : `${filterValue.value.length} entities`;
+    }
+    case "custom":
+      return truncate(
+        operatorValue.type === "custom" ? operatorValue.getString(filterValue.value) : filterValue.value,
+        maxLength
+      );
+    case "nested":
+      return filterValue.value.length === 1 ? "1 filter" : `${filterValue.value.length} filters`;
+  }
+}
+function useInternalSearchFilterInputConfig(config) {
+  return useMemo(() => {
+    const fieldMap = /* @__PURE__ */ new Map();
+    const operatorMap = /* @__PURE__ */ new Map();
+    for (const field of config.fields) {
+      fieldMap.set(field.key, field);
+      operatorMap.set(
+        field.key,
+        new Map(field.operators.map((operator) => [operator.key, operator]))
+      );
+    }
+    return {
+      config,
+      getDefaultOperator(fieldKey) {
+        const field = fieldMap.get(fieldKey);
+        if (field == null) {
+          return void 0;
+        }
+        if (field.defaultOperator != null) {
+          return operatorMap.get(fieldKey)?.get(field.defaultOperator);
+        }
+        return field.operators[0];
+      },
+      getField: (key) => fieldMap.get(key),
+      getOperator: (fieldKey, operatorKey) => operatorMap.get(fieldKey)?.get(operatorKey),
+      getVisibleFields: () => config.fields,
+      getVisibleOperators(fieldKey) {
+        return fieldMap.get(fieldKey)?.operators ?? [];
+      }
+    };
+  }, [config]);
+}
+function useSearchFilterInputSource(config) {
+  return useMemo(() => {
+    const allItems = buildFieldItems(config);
+    return {
+      bootstrap: () => allItems,
+      search(query) {
+        const lower = query.toLowerCase().trim();
+        if (lower === "") {
+          return allItems;
+        }
+        const results = [];
+        const seen = /* @__PURE__ */ new Set();
+        for (const field of config.getVisibleFields()) {
+          if (field.comboboxMinQueryLength != null && lower.length < field.comboboxMinQueryLength) {
+            continue;
+          }
+          const fieldMatches = field.label.toLowerCase().includes(lower) || field.comboboxAliases?.some(
+            (alias) => alias.toLowerCase().includes(lower)
+          ) === true;
+          if (fieldMatches) {
+            const defaultOperator = config.getDefaultOperator(field.key);
+            if (!seen.has(field.key)) {
+              seen.add(field.key);
+              results.push({
+                auxiliaryData: {
+                  fieldKey: field.key,
+                  operatorKey: defaultOperator?.key
+                },
+                id: field.key,
+                label: field.label
+              });
+            }
+          }
+          for (const operator of field.operators) {
+            const combinedLabel = `${field.label} ${operator.label}`.toLowerCase();
+            if (combinedLabel.includes(lower)) {
+              const id = `${field.key}:${operator.key}`;
+              if (!seen.has(id)) {
+                seen.add(id);
+                results.push({
+                  auxiliaryData: {
+                    fieldKey: field.key,
+                    operatorKey: operator.key
+                  },
+                  id,
+                  label: `${field.label} ${operator.label}`
+                });
+              }
+            }
+          }
+        }
+        for (const field of config.getVisibleFields()) {
+          if (field.isValueMatchAllowed === false) {
+            continue;
+          }
+          const fieldLabel = field.label.toLowerCase();
+          let hasExactOperatorMatch = false;
+          for (const operator of field.operators) {
+            const prefix = `${fieldLabel} ${operator.label.toLowerCase()} `;
+            if (lower.startsWith(prefix) && lower.length > prefix.length) {
+              const rawValue = query.slice(prefix.length);
+              const matches = resolveValueMatches(operator, rawValue);
+              if (matches.length > 0) {
+                hasExactOperatorMatch = true;
+              }
+              for (const match of matches) {
+                const id = `${field.key}:${operator.key}:value:${match.displayValue}`;
+                if (!seen.has(id)) {
+                  seen.add(id);
+                  results.push({
+                    auxiliaryData: {
+                      fieldKey: field.key,
+                      filterValue: match.filterValue,
+                      operatorKey: operator.key
+                    },
+                    id,
+                    label: `${field.label} ${operator.label} ${match.quoted ? `"${match.displayValue}"` : match.displayValue}`
+                  });
+                }
+              }
+            }
+          }
+          const fieldPrefix = `${fieldLabel} `;
+          if (!hasExactOperatorMatch && lower.startsWith(fieldPrefix) && lower.length > fieldPrefix.length) {
+            const remainder = lower.slice(fieldPrefix.length);
+            const isOperatorPrefix = field.operators.some(
+              (operator) => operator.label.toLowerCase().startsWith(remainder)
+            );
+            if (!isOperatorPrefix) {
+              const rawValue = query.slice(fieldPrefix.length);
+              for (const operator of field.operators) {
+                const matches = resolveValueMatches(operator, rawValue);
+                for (const match of matches) {
+                  const id = `${field.key}:${operator.key}:value:${match.displayValue}`;
+                  if (!seen.has(id)) {
+                    seen.add(id);
+                    results.push({
+                      auxiliaryData: {
+                        fieldKey: field.key,
+                        filterValue: match.filterValue,
+                        operatorKey: operator.key
+                      },
+                      id,
+                      label: `${field.label} ${operator.label} ${match.quoted ? `"${match.displayValue}"` : match.displayValue}`
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
+        const contentFieldKey = config.config.contentSearchFieldKey;
+        const hasExactMatch = config.getVisibleFields().some(
+          (field) => field.label.toLowerCase() === lower || field.operators.some(
+            (operator) => `${field.label} ${operator.label}`.toLowerCase() === lower
+          )
+        );
+        if (contentFieldKey != null && !hasExactMatch) {
+          const contentField = config.getField(contentFieldKey);
+          const contentOperator = config.getDefaultOperator(contentFieldKey);
+          if (contentField != null && contentOperator != null) {
+            results.unshift({
+              auxiliaryData: {
+                fieldKey: contentFieldKey,
+                filterValue: { type: "string", value: query },
+                operatorKey: contentOperator.key
+              },
+              id: `__content_search__:${query}`,
+              label: `"${query}"`
+            });
+          }
+        }
+        return results;
+      }
+    };
+  }, [config]);
+}
+function resolveValueMatches(operator, rawValue) {
+  if (operator.value.type === "string") {
+    return [
+      {
+        displayValue: rawValue,
+        filterValue: { type: "string", value: rawValue },
+        quoted: true
+      }
+    ];
+  }
+  if (operator.value.type === "string_list") {
+    return [
+      {
+        displayValue: rawValue,
+        filterValue: { type: "string_list", value: [rawValue] },
+        quoted: true
+      }
+    ];
+  }
+  if (operator.value.type === "enum") {
+    const lower = rawValue.toLowerCase();
+    return operator.value.values.filter((item) => item.label.toLowerCase().includes(lower)).map((item) => ({
+      displayValue: item.label,
+      filterValue: { type: "enum", value: item.value },
+      quoted: false
+    }));
+  }
+  if (operator.value.type === "enum_list") {
+    const lower = rawValue.toLowerCase();
+    return operator.value.values.filter((item) => item.label.toLowerCase().includes(lower)).map((item) => ({
+      displayValue: item.label,
+      filterValue: { type: "enum_list", value: [item.value] },
+      quoted: false
+    }));
+  }
+  return [];
+}
+function buildFieldItems(config) {
+  return config.getVisibleFields().map((field) => {
+    const defaultOperator = config.getDefaultOperator(field.key);
+    return {
+      auxiliaryData: {
+        fieldKey: field.key,
+        operatorKey: defaultOperator?.key
+      },
+      id: field.key,
+      label: field.label
+    };
+  });
+}
+var styles2 = {
+  entityPhoto: css({
+    width: "16px",
+    height: "16px",
+    borderRadius: "full",
+    objectFit: "cover",
+    flexShrink: 0
+  }),
+  root: css({
+    w: "full"
+  }),
+  popover: css({
+    minW: "400px"
+  }),
+  resultCount: css({
+    whiteSpace: "nowrap"
+  }),
+  value: css({
+    fontWeight: "bold"
+  })
+};
+function SearchFilterInput({
+  className,
+  components,
+  config: configFromProps,
+  "data-testid": dataTestId,
+  endContent,
+  filters,
+  handleRef,
+  hasAutoFocus = false,
+  hasClear = true,
+  isDisabled = false,
+  isLabelHidden = true,
+  isReadOnly = false,
+  label = "Search",
+  maxOperatorMenuItems,
+  maxTagLength = 40,
+  onBlur,
+  onChange,
+  onFocus,
+  placeholder = "Search...",
+  popoverSaveButtonLabel = "Apply",
+  ref,
+  resultCount,
+  size = "md",
+  startIcon,
+  status,
+  style,
+  tagOverflowBehavior,
+  timezoneID
+}) {
+  const config = useInternalSearchFilterInputConfig(configFromProps);
+  const searchSource = useSearchFilterInputSource(config);
+  const tagsInputRef = useRef(null);
+  const rootRef = useRef(null);
+  const [popoverState, setPopoverState] = useState({
+    type: "idle"
+  });
+  useImperativeHandle(handleRef, () => ({
+    blurInput: () => tagsInputRef.current?.blur(),
+    focusInput: () => tagsInputRef.current?.focus()
+  }));
+  const tagsInputValue = useMemo(
+    () => filters.map((filter, index) => {
+      const field = config.getField(filter.field);
+      const operator = config.getOperator(filter.field, filter.operator);
+      const operatorLabel = operator?.label ? ` ${operator.label}` : "";
+      const value = operator == null ? "" : formatFilterValue(
+        config,
+        operator.value,
+        filter.value,
+        maxTagLength,
+        timezoneID
+      );
+      return {
+        auxiliaryData: {
+          fieldKey: filter.field,
+          filterIndex: index,
+          filterValue: filter.value,
+          operatorKey: filter.operator
+        },
+        id: `filter-${index}-${filter.field}-${filter.operator}`,
+        label: value ? `${field?.label ?? filter.field}${operatorLabel} ${value}` : `${field?.label ?? filter.field}${operatorLabel}`
+      };
+    }),
+    [config, filters, maxTagLength, timezoneID]
+  );
+  const openEditor = useCallback(
+    (state) => {
+      tagsInputRef.current?.blur();
+      setPopoverState(state);
+    },
+    []
+  );
+  const handleTagsInputChange = useCallback(
+    (_items, change) => {
+      if (change.type === "remove") {
+        const index = change.item.auxiliaryData?.filterIndex;
+        if (index != null) {
+          onChange(
+            filters.filter((_, i) => i !== index),
+            "remove",
+            index
+          );
+        }
+        return;
+      }
+      if (change.type !== "add") {
+        return;
+      }
+      const auxiliaryData = change.item.auxiliaryData;
+      if (auxiliaryData == null) {
+        return;
+      }
+      const operator = auxiliaryData.operatorKey == null ? config.getDefaultOperator(auxiliaryData.fieldKey) : config.getOperator(
+        auxiliaryData.fieldKey,
+        auxiliaryData.operatorKey
+      );
+      if (operator == null) {
+        return;
+      }
+      if (auxiliaryData.filterValue != null) {
+        const nextFilter = {
+          field: auxiliaryData.fieldKey,
+          operator: operator.key,
+          value: auxiliaryData.filterValue
+        };
+        onChange([...filters, nextFilter], "add", filters.length);
+        return;
+      }
+      if (operator.value.type === "empty") {
+        const nextFilter = {
+          field: auxiliaryData.fieldKey,
+          operator: operator.key,
+          value: { type: "empty" }
+        };
+        onChange([...filters, nextFilter], "add", filters.length);
+        return;
+      }
+      openEditor({
+        partialFilter: {
+          field: auxiliaryData.fieldKey,
+          operator: operator.key,
+          value: void 0
+        },
+        type: "adding"
+      });
+    },
+    [config, filters, onChange, openEditor]
+  );
+  const handleTagClick = (index) => {
+    if (isReadOnly || isDisabled) {
+      return;
+    }
+    const filter = filters[index];
+    if (filter.isReadOnly === true) {
+      return;
+    }
+    openEditor({
+      filterIndex: index,
+      partialFilter: {
+        field: filter.field,
+        operator: filter.operator,
+        value: filter.value
+      },
+      type: "editing"
+    });
+  };
+  const renderTag = (item, onRemove) => {
+    const auxiliaryData = item.auxiliaryData;
+    const filterIndex = auxiliaryData?.filterIndex ?? -1;
+    const filter = filterIndex >= 0 ? filters[filterIndex] : void 0;
+    const field = auxiliaryData == null ? void 0 : config.getField(auxiliaryData.fieldKey);
+    const operator = auxiliaryData?.operatorKey == null ? void 0 : config.getOperator(auxiliaryData.fieldKey, auxiliaryData.operatorKey);
+    const canInteract = !isReadOnly && !isDisabled && filter?.isReadOnly !== true;
+    const TagOverride = operator == null ? void 0 : components?.[operator.value.type]?.Tag;
+    if (TagOverride != null && filter != null && field != null && operator != null) {
+      return /* @__PURE__ */ jsx(
+        TagOverride,
+        {
+          config: configFromProps,
+          field,
+          filter,
+          isDisabled,
+          maxLength: maxTagLength,
+          onClick: canInteract ? () => handleTagClick(filterIndex) : void 0,
+          onRemove: canInteract ? onRemove : void 0,
+          operator
+        }
+      );
+    }
+    const value = operator != null && filter != null ? formatFilterValue(
+      config,
+      operator.value,
+      filter.value,
+      Math.max(
+        maxTagLength - (field?.label.length ?? 0) - operator.label.length,
+        10
+      ),
+      timezoneID
+    ) : "";
+    const entityPhoto = filter?.value.type === "entity_list" ? (() => {
+      const entities = filter.value.value;
+      return entities.length === 1 && entities[0].photo != null ? entities[0].photo : void 0;
+    })() : void 0;
+    return /* @__PURE__ */ jsx(
+      Tag,
+      {
+        endContent: value === "" ? void 0 : /* @__PURE__ */ jsx("span", { className: styles2.value, children: value }),
+        isDisabled,
+        label: `${field?.label ?? ""} ${operator?.label ?? ""}`.trim(),
+        onClick: canInteract ? (event) => {
+          event.stopPropagation();
+          handleTagClick(filterIndex);
+        } : void 0,
+        onRemove: canInteract ? onRemove : void 0,
+        size,
+        startContent: entityPhoto != null ? /* @__PURE__ */ jsx("img", { alt: "", className: styles2.entityPhoto, src: entityPhoto }) : void 0
+      }
+    );
+  };
+  const renderItem = (item) => {
+    const field = item.auxiliaryData == null ? void 0 : config.getField(item.auxiliaryData.fieldKey);
+    return /* @__PURE__ */ jsx(
+      AutocompleteInputItem,
+      {
+        description: field?.description,
+        icon: field?.icon ?? Search,
+        item
+      }
+    );
+  };
+  const handleSave = (savedFilter) => {
+    if (popoverState.type === "adding") {
+      if (savedFilter != null) {
+        onChange([...filters, savedFilter], "add", filters.length);
+      }
+    } else if (popoverState.type === "editing") {
+      if (savedFilter == null) {
+        onChange(
+          filters.filter((_, index) => index !== popoverState.filterIndex),
+          "remove",
+          popoverState.filterIndex
+        );
+      } else {
+        const nextFilters = [...filters];
+        nextFilters[popoverState.filterIndex] = savedFilter;
+        onChange(nextFilters, "edit", popoverState.filterIndex);
+      }
+    }
+    setPopoverState({ type: "idle" });
+    requestAnimationFrame(() => tagsInputRef.current?.focus());
+  };
+  const partialFilter = popoverState.type === "idle" ? null : popoverState.partialFilter;
+  const EditorOverride = partialFilter?.operator == null ? void 0 : components?.[config.getOperator(partialFilter.field, partialFilter.operator)?.value.type ?? "empty"]?.Editor;
+  const editorContent = partialFilter == null ? null : EditorOverride != null ? /* @__PURE__ */ jsx(
+    EditorOverride,
+    {
+      config: configFromProps,
+      filter: partialFilter,
+      isReadOnly,
+      mode: popoverState.type === "editing" ? "edit" : "create",
+      onCancel: () => setPopoverState({ type: "idle" }),
+      onSave: handleSave,
+      saveButtonLabel: popoverSaveButtonLabel,
+      timezoneID
+    }
+  ) : /* @__PURE__ */ jsx(
+    SearchFilterInputEditPopover,
+    {
+      config,
+      filter: partialFilter,
+      isReadOnly,
+      maxOperatorMenuItems,
+      mode: popoverState.type === "editing" ? "edit" : "create",
+      onCancel: () => setPopoverState({ type: "idle" }),
+      onSave: handleSave,
+      saveButtonLabel: popoverSaveButtonLabel
+    }
+  );
+  const resultCountNode = resultCount == null ? null : /* @__PURE__ */ jsx(
+    Text,
+    {
+      as: "span",
+      className: styles2.resultCount,
+      color: "secondary",
+      type: "supporting",
+      children: typeof resultCount === "number" ? `${new Intl.NumberFormat().format(resultCount)} ${resultCount === 1 ? "result" : "results"}` : resultCount
+    }
+  );
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("div", { className: styles2.root, ref: rootRef, children: /* @__PURE__ */ jsx(
+      TagsInput,
+      {
+        className,
+        "data-testid": dataTestId,
+        debounceMs: 0,
+        endContent: /* @__PURE__ */ jsxs(Fragment, { children: [
+          resultCountNode,
+          endContent
+        ] }),
+        handleRef: tagsInputRef,
+        hasAutoFocus,
+        hasClear: hasClear && !isReadOnly,
+        hasEntriesOnFocus: true,
+        isDisabled,
+        isLabelHidden,
+        isReadOnly,
+        label,
+        onBlur,
+        onChange: handleTagsInputChange,
+        onFocus,
+        placeholder: isReadOnly ? "" : filters.length === 0 ? placeholder : "",
+        ref,
+        renderItem,
+        renderTag,
+        searchSource,
+        size,
+        startIcon,
+        status,
+        style,
+        tagOverflowBehavior,
+        value: tagsInputValue
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      Popover,
+      {
+        anchorRef: rootRef,
+        className: styles2.popover,
+        content: editorContent,
+        hasAutoFocus: false,
+        hasCloseButton: false,
+        hasLightDismiss: false,
+        isOpen: popoverState.type !== "idle",
+        onOpenChange: (isOpen) => {
+          if (!isOpen) {
+            setPopoverState({ type: "idle" });
+          }
+        }
+      }
+    )
+  ] });
+}
+SearchFilterInput.displayName = "SearchFilterInput";
+function SearchFilterInputFilterEditor({
+  config,
+  filter,
+  isReadOnly,
+  mode,
+  onCancel,
+  onSave,
+  saveButtonLabel
+}) {
+  const internalConfig = useInternalSearchFilterInputConfig(config);
+  return /* @__PURE__ */ jsx(
+    SearchFilterInputEditPopover,
+    {
+      config: internalConfig,
+      filter,
+      isReadOnly,
+      mode,
+      onCancel,
+      onSave,
+      saveButtonLabel
+    }
+  );
+}
+SearchFilterInputFilterEditor.displayName = "SearchFilterInputFilterEditor";
+var styles3 = {
+  value: css({
+    fontWeight: "bold"
+  }),
+  entityPhoto: css({
+    width: "16px",
+    height: "16px",
+    borderRadius: "full",
+    objectFit: "cover",
+    flexShrink: 0
+  })
+};
+function getSingleEntityPhoto(value) {
+  if (value.type !== "entity_list") {
+    return void 0;
+  }
+  const entities = value.value;
+  if (entities.length === 1 && entities[0].photo != null) {
+    return entities[0].photo;
+  }
+  return void 0;
+}
+function SearchFilterInputTag({
+  config: configFromProps,
+  field,
+  filter,
+  isDisabled,
+  maxLength,
+  onClick,
+  onRemove,
+  operator
+}) {
+  const config = useInternalSearchFilterInputConfig(configFromProps);
+  const tagLabel = `${field.label}${operator.label ? ` ${operator.label}` : ""}`;
+  const adjustedMaxLength = Math.max(
+    maxLength - field.label.length - operator.label.length,
+    10
+  );
+  const value = formatFilterValue(
+    config,
+    operator.value,
+    filter.value,
+    adjustedMaxLength
+  );
+  const entityPhoto = getSingleEntityPhoto(filter.value);
+  return /* @__PURE__ */ jsx(
+    Tag,
+    {
+      endContent: value === "" ? void 0 : /* @__PURE__ */ jsx("span", { className: styles3.value, children: value }),
+      isDisabled,
+      label: tagLabel,
+      onClick: onClick == null ? void 0 : (event) => {
+        event.stopPropagation();
+        onClick();
+      },
+      onRemove,
+      startContent: entityPhoto != null ? /* @__PURE__ */ jsx("img", { alt: "", className: styles3.entityPhoto, src: entityPhoto }) : void 0
+    }
+  );
+}
+SearchFilterInputTag.displayName = "SearchFilterInputTag";
+var StringOps = {
+  CONTAINS: "contains",
+  ENDS_WITH: "ends_with",
+  IS: "is",
+  IS_NOT: "is_not",
+  NOT_CONTAINS: "not_contains",
+  NOT_ENDS_WITH: "not_ends_with",
+  NOT_STARTS_WITH: "not_starts_with",
+  STARTS_WITH: "starts_with"
+};
+var NumberOps = {
+  EQUALS: "equals",
+  GREATER_THAN: "greater_than",
+  GREATER_THAN_OR_EQUAL: "greater_than_or_equal",
+  LESS_THAN: "less_than",
+  LESS_THAN_OR_EQUAL: "less_than_or_equal",
+  NOT_EQUALS: "not_equals"
+};
+var DateOps = {
+  AFTER: "after",
+  BEFORE: "before",
+  BETWEEN: "between"
+};
+var BooleanOps = {
+  IS_FALSE: "is_false",
+  IS_TRUE: "is_true"
+};
+var EnumOps = {
+  IS: "is",
+  IS_NOT: "is_not"
+};
+var ListOps = {
+  IS_ANY_OF: "is_any_of",
+  IS_NONE_OF: "is_none_of"
+};
+function stringOperators() {
+  return {
+    defaultOperator: StringOps.CONTAINS,
+    operators: [
+      { key: StringOps.CONTAINS, label: "contains", value: { type: "string" } },
+      {
+        key: StringOps.NOT_CONTAINS,
+        label: "does not contain",
+        value: { type: "string" }
+      },
+      {
+        key: StringOps.STARTS_WITH,
+        label: "starts with",
+        value: { type: "string" }
+      },
+      {
+        key: StringOps.NOT_STARTS_WITH,
+        label: "does not start with",
+        value: { type: "string" }
+      },
+      { key: StringOps.ENDS_WITH, label: "ends with", value: { type: "string" } },
+      {
+        key: StringOps.NOT_ENDS_WITH,
+        label: "does not end with",
+        value: { type: "string" }
+      },
+      { key: StringOps.IS, label: "is", value: { type: "string" } },
+      { key: StringOps.IS_NOT, label: "is not", value: { type: "string" } }
+    ]
+  };
+}
+function numberOperators() {
+  return {
+    defaultOperator: NumberOps.EQUALS,
+    operators: [
+      { key: NumberOps.EQUALS, label: "is", value: { type: "float" } },
+      { key: NumberOps.NOT_EQUALS, label: "is not", value: { type: "float" } },
+      {
+        key: NumberOps.GREATER_THAN,
+        label: "is greater than",
+        value: { type: "float" }
+      },
+      {
+        key: NumberOps.LESS_THAN,
+        label: "is less than",
+        value: { type: "float" }
+      },
+      {
+        key: NumberOps.GREATER_THAN_OR_EQUAL,
+        label: "is greater than or equal to",
+        value: { type: "float" }
+      },
+      {
+        key: NumberOps.LESS_THAN_OR_EQUAL,
+        label: "is less than or equal to",
+        value: { type: "float" }
+      }
+    ]
+  };
+}
+function operatorsFor(definition) {
+  switch (definition.type) {
+    case "string":
+      return stringOperators();
+    case "number":
+      return numberOperators();
+    case "date":
+      return {
+        defaultOperator: DateOps.AFTER,
+        operators: [
+          {
+            key: DateOps.BEFORE,
+            label: "is before",
+            value: { type: "date_absolute" }
+          },
+          {
+            key: DateOps.AFTER,
+            label: "is after",
+            value: { type: "date_absolute" }
+          },
+          {
+            key: DateOps.BETWEEN,
+            label: "is between",
+            value: { type: "date_range" }
+          }
+        ]
+      };
+    case "boolean":
+      return {
+        defaultOperator: BooleanOps.IS_TRUE,
+        operators: [
+          { key: BooleanOps.IS_TRUE, label: "is true", value: { type: "empty" } },
+          { key: BooleanOps.IS_FALSE, label: "is false", value: { type: "empty" } }
+        ]
+      };
+    case "enum":
+      return {
+        defaultOperator: EnumOps.IS,
+        operators: [
+          {
+            key: EnumOps.IS,
+            label: "is",
+            value: { type: "enum", values: definition.enumValues ?? [] }
+          },
+          {
+            key: EnumOps.IS_NOT,
+            label: "is not",
+            value: { type: "enum", values: definition.enumValues ?? [] }
+          },
+          {
+            key: ListOps.IS_ANY_OF,
+            label: "is any of",
+            value: { type: "enum_list", values: definition.enumValues ?? [] }
+          },
+          {
+            key: ListOps.IS_NONE_OF,
+            label: "is none of",
+            value: { type: "enum_list", values: definition.enumValues ?? [] }
+          }
+        ]
+      };
+    case "enum_list":
+      return {
+        defaultOperator: ListOps.IS_ANY_OF,
+        operators: [
+          {
+            key: ListOps.IS_ANY_OF,
+            label: "is any of",
+            value: { type: "enum_list", values: definition.enumValues ?? [] }
+          },
+          {
+            key: ListOps.IS_NONE_OF,
+            label: "is none of",
+            value: { type: "enum_list", values: definition.enumValues ?? [] }
+          }
+        ]
+      };
+    case "string_list":
+      return {
+        defaultOperator: ListOps.IS_ANY_OF,
+        operators: [
+          {
+            key: ListOps.IS_ANY_OF,
+            label: "is any of",
+            value: { type: "string_list" }
+          },
+          {
+            key: ListOps.IS_NONE_OF,
+            label: "is none of",
+            value: { type: "string_list" }
+          }
+        ]
+      };
+  }
+}
+function nowUnixSeconds() {
+  return Math.floor(nowEpochMilliseconds() / 1e3);
+}
+function toUnixSeconds(value) {
+  return value instanceof Temporal.Instant ? Math.floor(value.epochMilliseconds / 1e3) : value;
+}
+function toStringArray(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return value;
+  }
+  return null;
+}
+function resolveRangePart(part) {
+  switch (part.type) {
+    case "NOW":
+      return nowUnixSeconds();
+    case "ABSOLUTE":
+      return part.unixSeconds;
+    case "RELATIVE": {
+      const multipliers = {
+        day: 86400,
+        hour: 3600,
+        minute: 60,
+        month: 2592e3,
+        second: 1,
+        week: 604800,
+        year: 31536e3
+      };
+      return nowUnixSeconds() - part.backValue * multipliers[part.unit];
+    }
+  }
+}
+function matchesFilter(row, filter) {
+  const fieldValue = row[filter.field];
+  const { operator, value } = filter;
+  switch (value.type) {
+    case "empty":
+      return operator === BooleanOps.IS_TRUE ? Boolean(fieldValue) === true : operator === BooleanOps.IS_FALSE ? Boolean(fieldValue) === false : true;
+    case "string": {
+      if (typeof fieldValue !== "string") {
+        return false;
+      }
+      const source = fieldValue.toLowerCase();
+      const target = value.value.toLowerCase();
+      switch (operator) {
+        case StringOps.CONTAINS:
+          return source.includes(target);
+        case StringOps.NOT_CONTAINS:
+          return !source.includes(target);
+        case StringOps.STARTS_WITH:
+          return source.startsWith(target);
+        case StringOps.NOT_STARTS_WITH:
+          return !source.startsWith(target);
+        case StringOps.ENDS_WITH:
+          return source.endsWith(target);
+        case StringOps.NOT_ENDS_WITH:
+          return !source.endsWith(target);
+        case StringOps.IS:
+          return source === target;
+        case StringOps.IS_NOT:
+          return source !== target;
+        default:
+          return true;
+      }
+    }
+    case "float":
+    case "integer": {
+      if (typeof fieldValue !== "number") {
+        return false;
+      }
+      switch (operator) {
+        case NumberOps.EQUALS:
+          return fieldValue === value.value;
+        case NumberOps.NOT_EQUALS:
+          return fieldValue !== value.value;
+        case NumberOps.GREATER_THAN:
+          return fieldValue > value.value;
+        case NumberOps.LESS_THAN:
+          return fieldValue < value.value;
+        case NumberOps.GREATER_THAN_OR_EQUAL:
+          return fieldValue >= value.value;
+        case NumberOps.LESS_THAN_OR_EQUAL:
+          return fieldValue <= value.value;
+        default:
+          return true;
+      }
+    }
+    case "date_absolute": {
+      if (!(fieldValue instanceof Temporal.Instant) && typeof fieldValue !== "number") {
+        return false;
+      }
+      const unixSeconds = toUnixSeconds(fieldValue);
+      return operator === DateOps.BEFORE ? unixSeconds < value.unixSeconds : operator === DateOps.AFTER ? unixSeconds > value.unixSeconds : true;
+    }
+    case "date_range": {
+      if (!(fieldValue instanceof Temporal.Instant) && typeof fieldValue !== "number") {
+        return false;
+      }
+      const unixSeconds = toUnixSeconds(fieldValue);
+      return unixSeconds >= resolveRangePart(value.value.start) && unixSeconds <= resolveRangePart(value.value.end);
+    }
+    case "enum":
+      return typeof fieldValue === "string" ? operator === EnumOps.IS ? fieldValue === value.value : operator === EnumOps.IS_NOT ? fieldValue !== value.value : true : false;
+    case "enum_list":
+    case "string_list": {
+      const values = toStringArray(fieldValue);
+      if (values == null) {
+        return false;
+      }
+      return operator === ListOps.IS_ANY_OF ? values.some((item) => value.value.includes(item)) : operator === ListOps.IS_NONE_OF ? values.every((item) => !value.value.includes(item)) : true;
+    }
+    case "custom":
+    case "date_relative":
+    case "entity_list":
+    case "nested":
+    case "time":
+      return true;
+  }
+}
+function createSearchFilterInputConfig(definitions, configName) {
+  const config = {
+    fields: definitions.map((definition) => ({
+      key: definition.key,
+      label: definition.label ?? definition.key,
+      ...operatorsFor(definition)
+    })),
+    name: configName ?? "SearchFilterInputConfig"
+  };
+  return {
+    applyFilters(filters, data) {
+      return filters.length === 0 ? [...data] : data.filter(
+        (row) => filters.every(
+          (filter) => matchesFilter(row, filter)
+        )
+      );
+    },
+    config
+  };
+}
+function useSearchFilterInputConfig(definitions, configName) {
+  return useMemo(
+    () => createSearchFilterInputConfig(definitions, configName),
+    [configName, definitions]
+  );
+}
+
+export { SearchFilterInput, SearchFilterInputEditPopover, SearchFilterInputFilterEditor, SearchFilterInputTag, createSearchFilterInputConfig, formatFilterValue, useSearchFilterInputConfig, useSearchFilterInputSource };
+//# sourceMappingURL=chunk-ELCRG7WZ.js.map
+//# sourceMappingURL=chunk-ELCRG7WZ.js.map