doom-design-system 0.6.0 → 0.7.0

package/dist/components/Rating/Rating.module.css

@@ -0,0 +1,131 @@
+@layer doom.components {
+  .rating {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--control-gap);
+    position: relative;
+  }
+  .rating.disabled {
+    opacity: 0.6;
+    cursor: not-allowed !important;
+    background-image: repeating-linear-gradient(45deg, transparent, transparent 10px, rgba(0, 0, 0, 0.05) 10px, rgba(0, 0, 0, 0.05) 20px) !important;
+  }
+  .rating.disabled:hover {
+    transform: none !important;
+    filter: none !important;
+  }
+  .rating.disabled {
+    cursor: not-allowed;
+  }
+  .sm {
+    gap: var(--space-1);
+  }
+  .lg {
+    gap: var(--space-2);
+  }
+  .iconWrapper {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+  }
+  .icon {
+    display: inline-flex;
+    transition: transform var(--duration-fast) var(--ease-in-out), color var(--duration-fast) var(--ease-in-out);
+  }
+  .filled {
+    color: var(--warning);
+  }
+  .unfilled {
+    color: var(--muted-foreground);
+  }
+  .filledOverlay {
+    position: absolute;
+    inset: 0;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    pointer-events: none;
+  }
+  .halfClip {
+    clip-path: inset(0 50% 0 0);
+  }
+  .iconButton {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0;
+    border: none;
+    background: none;
+    cursor: pointer;
+    transition: transform var(--duration-fast) var(--ease-in-out), color var(--duration-fast) var(--ease-in-out);
+  }
+  .iconButton:focus-visible:focus-visible {
+    outline: none;
+    transform: translate(calc(-1 * var(--space-0\.5)), calc(-1 * var(--space-0\.5)));
+    box-shadow: var(--shadow-offset-xl) var(--shadow-primary);
+    border-color: var(--primary);
+  }
+  .iconButton:focus-visible:focus {
+    outline: none;
+  }
+  .iconButton:focus-visible {
+    border-radius: var(--radius-md);
+  }
+  .iconButton:focus {
+    outline: none;
+  }
+  .iconButton:hover {
+    transform: scale(1.15);
+  }
+  .iconButton:active {
+    transform: scale(0.85);
+  }
+  .iconButton:disabled {
+    cursor: not-allowed;
+    pointer-events: none;
+  }
+  .radioButton {
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    padding: 0;
+    border: none;
+    background: none;
+    cursor: pointer;
+    z-index: 1;
+  }
+  .radioButton:focus-visible:focus-visible {
+    outline: none;
+    transform: translate(calc(-1 * var(--space-0\.5)), calc(-1 * var(--space-0\.5)));
+    box-shadow: var(--shadow-offset-xl) var(--shadow-primary);
+    border-color: var(--primary);
+  }
+  .radioButton:focus-visible:focus {
+    outline: none;
+  }
+  .radioButton:focus-visible {
+    border-radius: var(--radius-md);
+  }
+  .radioButton:focus {
+    outline: none;
+  }
+  .radioButton:disabled {
+    cursor: not-allowed;
+    pointer-events: none;
+  }
+  .halfLeft {
+    left: 0;
+    width: 50%;
+  }
+  .halfRight {
+    right: 0;
+    width: 50%;
+  }
+  .iconWrapper:hover .icon {
+    transform: scale(1.15);
+  }
+  .iconWrapper:active .icon {
+    transform: scale(0.85);
+  }
+}

package/dist/components/Rating/index.d.ts

@@ -0,0 +1 @@
+export * from "./Rating";

package/dist/components/Rating/index.js

@@ -0,0 +1 @@
+export * from "./Rating.js";

package/dist/components/Table/Table.d.ts

@@ -1,7 +1,6 @@
 import { ColumnDef, Row } from "@tanstack/react-table";
 import React from "react";
-import { type FilterOperatorKey } from "./FilterBuilder/FilterBuilder";
-import type { FilterGroupItem } from "./FilterBuilder/FilterGroup";
+import { type FilterDraftGroup, type FilterOperatorKey } from "../../lib/filter";
 export interface TableProps<T> {
     data: T[];
     /**
@@ -16,7 +15,7 @@ export interface TableProps<T> {
     enableSorting?: boolean;
     enableVirtualization?: boolean;
     enableAdvancedFiltering?: boolean;
-    onAdvancedFilterChange?: (value: FilterGroupItem) => void;
+    onAdvancedFilterChange?: (value: FilterDraftGroup) => void;
     pageSize?: number;
     height?: string | number;
     maxHeight?: string | number;

package/dist/components/Table/Table.js

@@ -4,38 +4,20 @@ import { useVirtualizer } from "@tanstack/react-virtual";
 import clsx from "clsx";
 import { ChevronRight, Filter, ListFilter, Search } from "lucide-react";
 import React, { useMemo, useState } from "react";
+import { countConditions, draftToFilter, evaluateFilter, FilterSheetNested, } from "../../lib/filter/index.js";
 import { Button } from "../Button/Button.js";
 import { Chip } from "../Chip/Chip.js";
 import { Input } from "../Input/Input.js";
 import { Flex } from "../Layout/Layout.js";
 import { Pagination } from "../Pagination/Pagination.js";
 import { Select } from "../Select/Select.js";
-import { countConditions, } from "./FilterBuilder/FilterBuilder.js";
-import { FilterSheetNested } from "./FilterBuilder/FilterSheetNested.js";
 import styles from "./Table.module.css";
 import { TableHeaderFilter } from "./TableHeaderFilter.js";
-import { evaluateFilter } from "./utils/filterAst.js";
 const coreRowModel = getCoreRowModel();
 const sortedRowModel = getSortedRowModel();
 const paginationRowModel = getPaginationRowModel();
 const filteredRowModel = getFilteredRowModel();
 const expandedRowModel = getExpandedRowModel();
-const convertToFilterNode = (item) => {
-    if (item.type === "group") {
-        return {
-            type: "group",
-            logic: item.logic,
-            conditions: (item.children || []).map(convertToFilterNode),
-        };
-    }
-    return {
-        type: "condition",
-        field: item.field,
-        operator: item.operator,
-        value: item.value,
-        logic: item.logic,
-    };
-};
 function VirtualTableBody({ table, columns, striped, density, scrollElement, onRowClick, renderExpandedRow, totalColumns, }) {
     const { rows } = table.getRowModel();
     const rowVirtualizer = useVirtualizer({
@@ -94,7 +76,7 @@ export function Table({ data, columns, enablePagination = true, enableFiltering
         if (!advancedFilterValue || !enableAdvancedFiltering) {
             return data;
         }
-        const filterNode = convertToFilterNode(advancedFilterValue);
+        const filterNode = draftToFilter(advancedFilterValue);
         if (filterNode.type === "group" && filterNode.conditions.length === 0) {
             return data;
         }

package/dist/components/ToggleGroup/ToggleGroup.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import type { ControlSize } from "../../styles/types";
+export interface ToggleGroupProps {
+    type: "single" | "multiple";
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    size?: ControlSize;
+    disabled?: boolean;
+    className?: string;
+    children: React.ReactNode;
+    "aria-label"?: string;
+}
+export declare function ToggleGroup({ type, value: controlledValue, defaultValue, onValueChange, size, disabled, className, children, "aria-label": ariaLabel, }: ToggleGroupProps): import("react/jsx-runtime").JSX.Element;
+export interface ToggleGroupItemProps {
+    value: string;
+    disabled?: boolean;
+    "aria-label"?: string;
+    className?: string;
+    children: React.ReactNode;
+}
+export declare function ToggleGroupItem({ value, disabled: itemDisabled, "aria-label": ariaLabel, className, children, }: ToggleGroupItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ToggleGroup/ToggleGroup.js

@@ -0,0 +1,157 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import clsx from "clsx";
+import { createContext, useCallback, useContext, useRef, useState, } from "react";
+import styles from "./ToggleGroup.module.css";
+const ToggleGroupContext = createContext(null);
+export function ToggleGroup({ type, value: controlledValue, defaultValue, onValueChange, size = "md", disabled = false, className, children, "aria-label": ariaLabel, }) {
+    const [internalValue, setInternalValue] = useState(defaultValue !== null && defaultValue !== void 0 ? defaultValue : (type === "multiple" ? [] : ""));
+    const isControlled = controlledValue !== undefined;
+    const activeValue = isControlled ? controlledValue : internalValue;
+    const itemRefs = useRef(new Map());
+    const itemOrder = useRef([]);
+    const [focusedValue, setFocusedValue] = useState(null);
+    const [items, setItems] = useState([]);
+    const toggle = useCallback((itemValue) => {
+        let nextValue;
+        if (type === "single") {
+            const current = (typeof activeValue === "string" ? activeValue : "");
+            nextValue = current === itemValue ? "" : itemValue;
+        }
+        else {
+            const arr = Array.isArray(activeValue) ? activeValue : [];
+            nextValue = arr.includes(itemValue)
+                ? arr.filter((v) => v !== itemValue)
+                : [...arr, itemValue];
+        }
+        if (!isControlled) {
+            setInternalValue(nextValue);
+        }
+        onValueChange === null || onValueChange === void 0 ? void 0 : onValueChange(nextValue);
+    }, [type, activeValue, isControlled, onValueChange]);
+    const registerItem = useCallback((ref, value, itemDisabled) => {
+        if (ref) {
+            itemRefs.current.set(value, ref);
+            if (!itemOrder.current.includes(value)) {
+                itemOrder.current.push(value);
+            }
+            setItems((prev) => {
+                const existing = prev.find((it) => it.value === value);
+                if (existing && existing.disabled === itemDisabled) {
+                    return prev;
+                }
+                const filtered = prev.filter((it) => it.value !== value);
+                const idx = itemOrder.current.indexOf(value);
+                filtered.splice(idx, 0, { value, disabled: itemDisabled });
+                return filtered;
+            });
+        }
+    }, []);
+    const unregisterItem = useCallback((value) => {
+        itemRefs.current.delete(value);
+        itemOrder.current = itemOrder.current.filter((v) => v !== value);
+        setItems((prev) => prev.filter((it) => it.value !== value));
+    }, []);
+    const getEnabledItems = useCallback(() => {
+        return itemOrder.current.filter((v) => {
+            const el = itemRefs.current.get(v);
+            return el && !el.disabled;
+        });
+    }, []);
+    // Compute the tabbable item: focused > pressed > first enabled
+    const tabbableValue = (() => {
+        var _a;
+        const enabledValues = items
+            .filter((it) => !it.disabled)
+            .map((it) => it.value);
+        if (enabledValues.length === 0) {
+            return null;
+        }
+        if (focusedValue && enabledValues.includes(focusedValue)) {
+            return focusedValue;
+        }
+        if (type === "single") {
+            const pressed = typeof activeValue === "string" ? activeValue : "";
+            if (pressed && enabledValues.includes(pressed)) {
+                return pressed;
+            }
+        }
+        else {
+            const arr = Array.isArray(activeValue) ? activeValue : [];
+            const firstPressed = arr.find((v) => enabledValues.includes(v));
+            if (firstPressed) {
+                return firstPressed;
+            }
+        }
+        return (_a = enabledValues[0]) !== null && _a !== void 0 ? _a : null;
+    })();
+    const handleKeyDown = useCallback((e, _value) => {
+        const enabledItems = getEnabledItems();
+        if (enabledItems.length === 0) {
+            return;
+        }
+        const currentEl = e.currentTarget;
+        const currentValue = currentEl.getAttribute("data-value") || "";
+        const currentIndex = enabledItems.indexOf(currentValue);
+        let nextIndex = null;
+        if (e.key === "ArrowRight" || e.key === "ArrowDown") {
+            e.preventDefault();
+            nextIndex = (currentIndex + 1) % enabledItems.length;
+        }
+        else if (e.key === "ArrowLeft" || e.key === "ArrowUp") {
+            e.preventDefault();
+            nextIndex =
+                (currentIndex - 1 + enabledItems.length) % enabledItems.length;
+        }
+        if (nextIndex !== null) {
+            const nextVal = enabledItems[nextIndex];
+            setFocusedValue(nextVal);
+            const nextEl = itemRefs.current.get(nextVal);
+            nextEl === null || nextEl === void 0 ? void 0 : nextEl.focus();
+        }
+    }, [getEnabledItems]);
+    return (_jsx(ToggleGroupContext.Provider, { value: {
+            activeValue,
+            toggle,
+            type,
+            size,
+            disabled,
+            registerItem,
+            unregisterItem,
+            handleKeyDown,
+            tabbableValue,
+        }, children: _jsx("div", { "aria-label": ariaLabel, className: clsx(styles.toggleGroup, className), role: "group", children: children }) }));
+}
+export function ToggleGroupItem({ value, disabled: itemDisabled, "aria-label": ariaLabel, className, children, }) {
+    const context = useContext(ToggleGroupContext);
+    if (!context) {
+        throw new Error("ToggleGroupItem must be used within <ToggleGroup>");
+    }
+    const isDisabled = itemDisabled || context.disabled;
+    const isPressed = context.type === "single"
+        ? context.activeValue === value
+        : Array.isArray(context.activeValue) &&
+            context.activeValue.includes(value);
+    const refCallback = useCallback((el) => {
+        if (el) {
+            context.registerItem(el, value, isDisabled);
+        }
+        else {
+            context.unregisterItem(value);
+        }
+    }, [value, isDisabled, context.registerItem, context.unregisterItem]);
+    const handleClick = () => {
+        if (!isDisabled) {
+            context.toggle(value);
+        }
+    };
+    const handleKeyDown = (e) => {
+        if (e.key === "ArrowRight" ||
+            e.key === "ArrowDown" ||
+            e.key === "ArrowLeft" ||
+            e.key === "ArrowUp") {
+            context.handleKeyDown(e, value);
+        }
+    };
+    return (_jsx("button", { ref: refCallback, "aria-label": ariaLabel, "aria-pressed": isPressed, className: clsx(styles.toggleGroupItem, styles[context.size], isPressed && styles.pressed, isDisabled && styles.disabled, className), "data-value": value, disabled: isDisabled, tabIndex: context.tabbableValue === value ? 0 : -1, type: "button", onClick: handleClick, onKeyDown: handleKeyDown, children: children }));
+}

package/dist/components/ToggleGroup/ToggleGroup.module.css

@@ -0,0 +1,81 @@
+@layer doom.components {
+  .toggleGroup {
+    display: inline-flex;
+    align-items: stretch;
+    border: var(--surface-border-width) solid var(--card-border);
+    border-radius: var(--control-radius);
+    box-shadow: var(--shadow-sm);
+  }
+  .toggleGroupItem {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--control-gap);
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    cursor: pointer;
+    background: var(--card-bg);
+    color: var(--foreground);
+    height: var(--control-height);
+    padding: var(--control-padding-y) var(--control-padding-x);
+    font-size: var(--control-font-size);
+    border: none;
+    border-left: var(--surface-border-width) solid var(--card-border);
+    border-radius: 0;
+  }
+  .toggleGroupItem:first-child {
+    border-left: none;
+    border-radius: var(--radius-sm) 0 0 var(--radius-sm);
+  }
+  .toggleGroupItem:last-child {
+    border-radius: 0 var(--radius-sm) var(--radius-sm) 0;
+  }
+  .toggleGroupItem:first-child:last-child {
+    border-radius: var(--radius-sm);
+  }
+  .toggleGroupItem:not(.pressed):not(.disabled):hover {
+    background: color-mix(in srgb, var(--primary), transparent 85%);
+  }
+  .toggleGroupItem:focus-visible {
+    box-shadow: inset 0 0 0 var(--surface-border-width) var(--primary);
+    z-index: 1;
+  }
+  .toggleGroupItem:focus {
+    outline: none;
+  }
+  .toggleGroupItem.pressed {
+    background: var(--primary);
+    color: var(--primary-foreground);
+  }
+  .toggleGroupItem.sm {
+    --control-height: var(--size-7);
+    --control-padding-x: var(--space-2);
+    --control-padding-y: var(--space-1);
+    --control-font-size: var(--text-xs);
+    --control-icon-size: var(--size-4);
+    --control-gap: var(--space-1);
+    --control-radius: var(--radius-sm);
+  }
+  .toggleGroupItem.lg {
+    --control-height: var(--size-10);
+    --control-padding-x: var(--space-4);
+    --control-padding-y: var(--space-2);
+    --control-font-size: var(--text-base);
+    --control-icon-size: var(--size-5);
+    --control-gap: var(--space-2);
+    --control-radius: var(--radius-md);
+  }
+  .toggleGroupItem.disabled {
+    opacity: 0.6;
+    cursor: not-allowed !important;
+    background-image: repeating-linear-gradient(45deg, transparent, transparent 10px, rgba(0, 0, 0, 0.05) 10px, rgba(0, 0, 0, 0.05) 20px) !important;
+  }
+  .toggleGroupItem.disabled:hover {
+    transform: none !important;
+    filter: none !important;
+  }
+  .toggleGroupItem.disabled {
+    cursor: not-allowed;
+  }
+}

package/dist/components/ToggleGroup/index.d.ts

@@ -0,0 +1 @@
+export * from "./ToggleGroup";

package/dist/components/ToggleGroup/index.js

@@ -0,0 +1 @@
+export * from "./ToggleGroup.js";

package/dist/index.d.ts

@@ -28,6 +28,7 @@ export * from "./components/Pagination";
 export * from "./components/Popover";
 export * from "./components/ProgressBar";
 export * from "./components/RadioGroup";
+export * from "./components/Rating";
 export * from "./components/Select";
 export * from "./components/Sheet";
 export * from "./components/Sidebar";
@@ -42,6 +43,7 @@ export * from "./components/Tabs";
 export * from "./components/Text";
 export * from "./components/Textarea";
 export * from "./components/Toast";
+export * from "./components/ToggleGroup";
 export * from "./components/Tooltip";
 export * from "./DesignSystemProvider";
 export * from "./styles/themes";

package/dist/index.js

@@ -28,6 +28,7 @@ export * from "./components/Pagination/index.js";
 export * from "./components/Popover/index.js";
 export * from "./components/ProgressBar/index.js";
 export * from "./components/RadioGroup/index.js";
+export * from "./components/Rating/index.js";
 export * from "./components/Select/index.js";
 export * from "./components/Sheet/index.js";
 export * from "./components/Sidebar/index.js";
@@ -42,6 +43,7 @@ export * from "./components/Tabs/index.js";
 export * from "./components/Text/index.js";
 export * from "./components/Textarea/index.js";
 export * from "./components/Toast/index.js";
+export * from "./components/ToggleGroup/index.js";
 export * from "./components/Tooltip/index.js";
 export * from "./DesignSystemProvider.js";
 export * from "./styles/themes/index.js";

package/dist/lib/filter/ast/array-filter.d.ts

@@ -0,0 +1,7 @@
+import { FilterFn } from "@tanstack/react-table";
+/**
+ * TanStack Table FilterFn that matches a row when its column value appears
+ * in the supplied filter array. Values are compared as strings to support
+ * typed columns.
+ */
+export declare const arrayIncludesFilter: FilterFn<unknown>;

package/dist/lib/filter/ast/array-filter.js

@@ -0,0 +1,16 @@
+/**
+ * TanStack Table FilterFn that matches a row when its column value appears
+ * in the supplied filter array. Values are compared as strings to support
+ * typed columns.
+ */
+export const arrayIncludesFilter = (row, columnId, filterValue) => {
+    if (!filterValue || !Array.isArray(filterValue) || filterValue.length === 0) {
+        return true;
+    }
+    const cellValue = row.getValue(columnId);
+    if (cellValue === null || cellValue === undefined) {
+        return filterValue.includes("");
+    }
+    return filterValue.includes(String(cellValue));
+};
+arrayIncludesFilter.autoRemove = (val) => !val || !Array.isArray(val) || val.length === 0;

package/dist/lib/filter/ast/evaluate.d.ts

@@ -0,0 +1,6 @@
+import { Filter } from "./types";
+/**
+ * Recursively evaluates a Filter against a row of data.
+ * Returns true if the row matches the filter expression.
+ */
+export declare function evaluateFilter(filter: Filter, row: Record<string, unknown>): boolean;

package/dist/lib/filter/ast/evaluate.js

@@ -0,0 +1,35 @@
+import { OPERATORS } from "./operators.js";
+/**
+ * Recursively evaluates a Filter against a row of data.
+ * Returns true if the row matches the filter expression.
+ */
+export function evaluateFilter(filter, row) {
+    if (filter.type === "condition") {
+        const { field, operator, value } = filter;
+        const cellValue = row[field];
+        const operatorDef = OPERATORS[operator];
+        if (!operatorDef) {
+            console.warn(`Unknown operator: ${operator}`);
+            return true;
+        }
+        return operatorDef.fn(cellValue, value);
+    }
+    // Group: short-circuit on empty, otherwise fold conditions left-to-right
+    // respecting each child's `logic` (and | or). Implicit "and" when omitted.
+    const { conditions } = filter;
+    if (!conditions || conditions.length === 0) {
+        return true;
+    }
+    let result = evaluateFilter(conditions[0], row);
+    for (let i = 1; i < conditions.length; i++) {
+        const next = conditions[i];
+        const nextResult = evaluateFilter(next, row);
+        if (next.logic === "or") {
+            result = result || nextResult;
+        }
+        else {
+            result = result && nextResult;
+        }
+    }
+    return result;
+}

package/dist/lib/filter/ast/index.d.ts

@@ -0,0 +1,5 @@
+export { arrayIncludesFilter } from "./array-filter";
+export { evaluateFilter } from "./evaluate";
+export { type FilterOperatorDef, OPERATORS } from "./operators";
+export { simpleFiltersToFilter } from "./simple";
+export type { Filter, FilterCondition, FilterGroup, FilterOperatorKey, } from "./types";

package/dist/lib/filter/ast/index.js

@@ -0,0 +1,4 @@
+export { arrayIncludesFilter } from "./array-filter.js";
+export { evaluateFilter } from "./evaluate.js";
+export { OPERATORS } from "./operators.js";
+export { simpleFiltersToFilter } from "./simple.js";

package/dist/lib/filter/ast/operators.d.ts

@@ -0,0 +1,7 @@
+import { FilterOperatorKey } from "./types";
+export interface FilterOperatorDef {
+    readonly key: FilterOperatorKey;
+    readonly label: string;
+    readonly fn: (cellValue: unknown, filterValue: unknown) => boolean;
+}
+export declare const OPERATORS: Readonly<Record<FilterOperatorKey, FilterOperatorDef>>;

package/dist/{components/Table/utils/filterAst.js → lib/filter/ast/operators.js}

@@ -65,55 +65,3 @@ export const OPERATORS = {
         fn: (a) => a != null && a !== "",
     },
 };
-export function evaluateFilter(node, row) {
-    if (node.type === "condition") {
-        const { field, operator, value } = node;
-        const cellValue = row[field];
-        const operatorDef = OPERATORS[operator];
-        if (!operatorDef) {
-            console.warn(`Unknown operator: ${operator}`);
-            return true;
-        }
-        return operatorDef.fn(cellValue, value);
-    }
-    if (node.type === "group") {
-        const { conditions } = node;
-        if (!conditions || conditions.length === 0) {
-            return true;
-        }
-        let accumulatedResult = evaluateFilter(conditions[0], row);
-        for (let i = 1; i < conditions.length; i++) {
-            const current = conditions[i];
-            const result = evaluateFilter(current, row);
-            if (current.logic === "or") {
-                accumulatedResult = accumulatedResult || result;
-            }
-            else {
-                accumulatedResult = accumulatedResult && result;
-            }
-        }
-        return accumulatedResult;
-    }
-    return true;
-}
-export function simpleFiltersToAST(selections) {
-    const conditions = Object.entries(selections)
-        .filter(([, value]) => value !== "" && value != null)
-        .map(([field, value], index) => ({
-        type: "condition",
-        field,
-        operator: "eq",
-        value,
-        logic: index > 0 ? "and" : undefined,
-    }));
-    if (conditions.length === 0) {
-        return null;
-    }
-    if (conditions.length === 1) {
-        return conditions[0];
-    }
-    return {
-        type: "group",
-        conditions,
-    };
-}

package/dist/lib/filter/ast/simple.d.ts

@@ -0,0 +1,7 @@
+import { Filter } from "./types";
+/**
+ * Convenience helper that converts a flat `{ field: value }` map to a Filter
+ * tree using equality operators joined by AND. Returns null when no
+ * non-empty values are present.
+ */
+export declare function simpleFiltersToFilter(selections: Record<string, string>): Filter | null;