@mendylanda/ui 0.1.0

package/dist/filters/filter-select-editor.js

@@ -0,0 +1,46 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useRef, useState } from "react";
+import { Input } from "../customization.js";
+import { Label } from "../customization.js";
+import { Search } from "lucide-react";
+import { DropdownMenuRadioGroup, DropdownMenuRadioItem } from "../primitives/dropdown-menu.js";
+import { FilterCheckboxItem } from "./filters.js";
+function handleSearchKey(event) {
+    if (event.key === "ArrowDown") {
+        event.preventDefault();
+        event.currentTarget
+            .closest("[data-slot=filter-options]")
+            ?.querySelector('[role^="menuitem"]:not([data-disabled])')
+            ?.focus();
+    }
+    if (event.key !== "Escape" && event.key !== "Tab")
+        event.stopPropagation();
+}
+function SearchableOptions({ label, options, searchable, searchPlaceholder, emptyMessage = "No options found.", children, }) {
+    const [query, setQuery] = useState("");
+    const inputRef = useRef(null);
+    useEffect(() => {
+        if (!searchable)
+            return;
+        const frame = requestAnimationFrame(() => inputRef.current?.focus());
+        return () => cancelAnimationFrame(frame);
+    }, [searchable]);
+    const id = useId();
+    const filtered = options.filter((option) => option.label.toLocaleLowerCase().includes(query.toLocaleLowerCase()));
+    return (_jsxs("div", { className: "mui-72b37c1a040d mui-81b198a2db84", "data-mendy-ui": "", "data-slot": "filter-options", onKeyDown: (event) => {
+            if (event.key === "Tab")
+                event.stopPropagation();
+        }, children: [searchable && (_jsxs("div", { "data-mendy-ui": "", className: "mui-d2d9e1f13413 mui-bbe39cfb5cc6 mui-b97db4a9f432", children: [_jsx(Search, { className: "mui-33228ff7d583 mui-747355bdc2a2 mui-866c339ea145 mui-4e45f4841abb mui-5dde0fd996f0 mui-100c22d5776b mui-0b5a4d1257ab", strokeWidth: 1.5, "aria-hidden": "true" }), _jsx(Label, { htmlFor: id, className: "mui-32fb090591d9", children: label }), _jsx(Input, { ref: inputRef, id: id, type: "search", className: "mui-75b27e813dcc mui-4f05a238500e", placeholder: searchPlaceholder ?? label, value: query, onChange: (event) => setQuery(event.target.value), onKeyDown: handleSearchKey })] })), filtered.length ? (_jsx("div", { role: "menu", "aria-label": label, className: "mui-1dee6e3ec67d", children: children(filtered) })) : (_jsx("p", { role: "status", className: "mui-094f5333853b mui-c74ab393b96d mui-35f35c41d134", children: emptyMessage }))] }));
+}
+/** Single selection applies immediately and closes the dropdown. */
+export function FilterSelectEditor({ value, onValueChange, ...props }) {
+    return (_jsx(SearchableOptions, { ...props, children: (options) => (_jsx(DropdownMenuRadioGroup, { value: value, onValueChange: onValueChange, "aria-label": props.label, children: options.map((option) => (_jsx(DropdownMenuRadioItem, { value: option.value, disabled: option.disabled, children: option.label }, option.value))) })) }));
+}
+/** Multiple selections apply immediately and keep the editor open. */
+export function FilterMultiSelectEditor({ values, onValuesChange, ...props }) {
+    const selected = new Set(values);
+    return (_jsx(SearchableOptions, { ...props, children: (options) => (_jsx("div", { role: "group", "aria-label": props.label, children: options.map((option) => (_jsx(FilterCheckboxItem, { disabled: option.disabled, checked: selected.has(option.value), onCheckedChange: (checked) => onValuesChange(checked
+                    ? [...new Set([...values, option.value])]
+                    : values.filter((value) => value !== option.value)), children: option.label }, option.value))) })) }));
+}

package/dist/filters/filter-state.d.ts

@@ -0,0 +1,34 @@
+import type { FilterDefinitions, RuntimeField } from "./filter-definition.js";
+export interface FilterEntry {
+    id: string;
+    field: RuntimeField;
+    value: unknown;
+}
+export interface PasteCandidate {
+    id: string;
+    label: string;
+    value: unknown;
+}
+export interface PasteAmbiguity {
+    token: string;
+    searchRange?: {
+        start: number;
+        end: number;
+    };
+    candidates: PasteCandidate[];
+}
+export interface PasteResult {
+    changes: Record<string, unknown>;
+    unmatched: string[];
+    ambiguous: PasteAmbiguity[];
+}
+export declare function classifyPaste(text: string, entries: readonly FilterEntry[]): PasteResult;
+export declare function initialValues(definitions: FilterDefinitions): Record<string, unknown>;
+export declare function decodeFilters(definitions: FilterDefinitions, params: URLSearchParams): Record<string, unknown>;
+export declare function encodeFilters(definitions: FilterDefinitions, values: Record<string, unknown>, base?: URLSearchParams): URLSearchParams;
+export declare function validateDefinitions(definitions: FilterDefinitions, searchKey: string, markerKey: string): void;
+/** Remove only the occurrence inserted by this paste, retaining pre-existing search text. */
+export declare function resolvePasteAmbiguity(search: string, item: PasteAmbiguity, all: PasteAmbiguity[]): {
+    search: string;
+    remaining: PasteAmbiguity[];
+};

package/dist/filters/filter-state.js

@@ -0,0 +1,107 @@
+import { equalValues } from "./filter-definition.js";
+export function classifyPaste(text, entries) {
+    const result = { changes: {}, unmatched: [], ambiguous: [] };
+    const entriesById = new Map(entries.map((entry) => [entry.id, entry]));
+    for (const token of new Set(text
+        .split(/[\r\n\t,]+/)
+        .map((part) => part.trim())
+        .filter(Boolean))) {
+        const matches = [];
+        for (const { id, field } of entries) {
+            if (!field.recognize || field.disabled || field.hidden)
+                continue;
+            try {
+                const recognized = field.recognize(token);
+                if (recognized === undefined)
+                    continue;
+                const value = field.normalize(recognized);
+                if (field.validate(value) || !field.isActive(value))
+                    continue;
+                matches.push({ id, label: field.label, value, priority: field.pastePriority });
+            }
+            catch {
+                /* A rejected token stays in search; recognition is not validation of a request. */
+            }
+        }
+        const priority = Math.max(...matches.map((match) => match.priority));
+        const best = matches.filter((match) => match.priority === priority);
+        if (best.length === 0)
+            result.unmatched.push(token);
+        else if (best.length > 1)
+            result.ambiguous.push({ token, candidates: best });
+        else {
+            const match = best[0];
+            const entry = entriesById.get(match.id);
+            result.changes[match.id] = entry.field.merge(result.changes[match.id] ?? entry.value, match.value);
+        }
+    }
+    return result;
+}
+export function initialValues(definitions) {
+    return Object.fromEntries(Object.entries(definitions).map(([key, field]) => [key, field.defaultValue]));
+}
+export function decodeFilters(definitions, params) {
+    return Object.fromEntries(Object.entries(definitions).map(([key, field]) => {
+        const raw = params.get(field.urlKey ?? key);
+        if (raw === null)
+            return [key, field.defaultValue];
+        // Explicit null is distinct from an absent key when a field has an applied default.
+        if (raw === "~null")
+            return [key, null];
+        try {
+            const decoded = field.codec.parse(raw.startsWith("~~") ? raw.slice(1) : raw);
+            if (decoded === null || field.validate(decoded))
+                return [key, field.defaultValue];
+            return [key, decoded];
+        }
+        catch {
+            return [key, field.defaultValue];
+        }
+    }));
+}
+export function encodeFilters(definitions, values, base = new URLSearchParams()) {
+    const params = new URLSearchParams(base);
+    for (const [key, field] of Object.entries(definitions)) {
+        const value = values[key] === undefined ? field.defaultValue : values[key];
+        const urlKey = field.urlKey ?? key;
+        if (equalValues(value, field.defaultValue))
+            params.delete(urlKey);
+        else {
+            const raw = value === null ? "~null" : field.codec.serialize(value);
+            params.set(urlKey, value !== null && raw.startsWith("~") ? `~${raw}` : raw);
+        }
+    }
+    return params;
+}
+export function validateDefinitions(definitions, searchKey, markerKey) {
+    const keys = new Set([searchKey, markerKey]);
+    if (searchKey === markerKey)
+        throw new Error("Search and overflow keys must differ.");
+    for (const [id, field] of Object.entries(definitions)) {
+        const key = field.urlKey ?? id;
+        if (keys.has(key))
+            throw new Error(`Duplicate filter URL key: ${key}`);
+        keys.add(key);
+    }
+}
+/** Remove only the occurrence inserted by this paste, retaining pre-existing search text. */
+export function resolvePasteAmbiguity(search, item, all) {
+    const range = item.searchRange;
+    const remaining = all.filter((other) => other !== item);
+    if (!range || search.slice(range.start, range.end) !== item.token)
+        return { search, remaining };
+    const start = range.start > 0 && search[range.start - 1] === " " ? range.start - 1 : range.start;
+    const end = start === 0 && search[range.end] === " " ? range.end + 1 : range.end;
+    return {
+        search: search.slice(0, start) + search.slice(end),
+        remaining: remaining.map((other) => other.searchRange && other.searchRange.start >= end
+            ? {
+                ...other,
+                searchRange: {
+                    start: other.searchRange.start - (end - start),
+                    end: other.searchRange.end - (end - start),
+                },
+            }
+            : other),
+    };
+}

package/dist/filters/filter-text-editor.d.ts

@@ -0,0 +1,11 @@
+export interface FilterTextEditorProps {
+    label: string;
+    defaultValue: string;
+    applyLabel?: string;
+    commitMode?: "enter" | "apply";
+    placeholder?: string;
+    onApply: (value: string) => void;
+    validate?: (value: string) => string | undefined;
+}
+/** A draft is local to the open editor. Enter commits it by default; explicit button submission is optional. */
+export declare function FilterTextEditor({ label, defaultValue, onApply, validate, applyLabel, commitMode, placeholder, }: FilterTextEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/filters/filter-text-editor.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useRef, useState } from "react";
+import { Button } from "../customization.js";
+import { Label } from "../customization.js";
+import { Textarea } from "../customization.js";
+/** A draft is local to the open editor. Enter commits it by default; explicit button submission is optional. */
+export function FilterTextEditor({ label, defaultValue, onApply, validate, applyLabel = "Apply", commitMode = "enter", placeholder, }) {
+    const id = useId();
+    const inputRef = useRef(null);
+    const [draft, setDraft] = useState(defaultValue);
+    const error = validate?.(draft);
+    useEffect(() => {
+        // Let a parent submenu finish setting up its focus scope first.
+        const frame = requestAnimationFrame(() => inputRef.current?.focus());
+        return () => cancelAnimationFrame(frame);
+    }, []);
+    return (_jsxs("div", { "data-mendy-ui": "", className: "mui-37535002f0f7 mui-81b198a2db84 mui-267171770524 mui-094f5333853b", onKeyDown: (event) => {
+            if (event.key === "Tab")
+                event.stopPropagation();
+        }, children: [_jsx(Label, { htmlFor: id, className: "mui-c74ab393b96d mui-daaac3fbf55e", children: label }), _jsx(Textarea, { ref: inputRef, id: id, value: draft, placeholder: placeholder, "aria-invalid": Boolean(error), "aria-describedby": error ? `${id}-error` : undefined, onChange: (event) => setDraft(event.target.value), onKeyDown: (event) => {
+                    if (commitMode === "enter" &&
+                        event.key === "Enter" &&
+                        !event.shiftKey &&
+                        !event.nativeEvent.isComposing) {
+                        event.preventDefault();
+                        if (!error)
+                            onApply(draft);
+                    }
+                    // Let the textarea handle typing and cursor movement, not menu typeahead.
+                    if (event.key !== "Escape" && event.key !== "Tab")
+                        event.stopPropagation();
+                } }), error && (_jsx("p", { id: `${id}-error`, className: "mui-c74ab393b96d mui-887b9502d5c7", children: error })), commitMode === "apply" ? (_jsx(Button, { type: "button", size: "sm", disabled: Boolean(error), onClick: () => onApply(draft), children: applyLabel })) : (_jsx("p", { className: "mui-3992de70b033 mui-35f35c41d134", children: "Enter to save. Shift+Enter for a new line." }))] }));
+}

package/dist/filters/filter-utils.d.ts

@@ -0,0 +1 @@
+export declare function parseFilterValues(value: string): string[];

package/dist/filters/filter-utils.js

@@ -0,0 +1,8 @@
+export function parseFilterValues(value) {
+    return [
+        ...new Set(value
+            .split(/[,\n\t]+/)
+            .map((part) => part.trim())
+            .filter(Boolean)),
+    ];
+}

package/dist/filters/filters.d.ts

@@ -0,0 +1,38 @@
+import type { ComponentProps, ReactNode } from "react";
+import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuTrigger } from "../primitives/dropdown-menu.js";
+export type FilterEditorProps = ComponentProps<typeof DropdownMenu>;
+export declare function FilterEditor(props: FilterEditorProps): import("react/jsx-runtime").JSX.Element;
+export type FilterChipProps = ComponentProps<"div">;
+export declare function FilterChip({ className, ...props }: FilterChipProps): import("react/jsx-runtime").JSX.Element;
+export type FilterEditorTriggerProps = ComponentProps<typeof DropdownMenuTrigger>;
+export declare function FilterEditorTrigger({ className, asChild, ...props }: FilterEditorTriggerProps): import("react/jsx-runtime").JSX.Element;
+export type FilterEditorContentProps = ComponentProps<typeof DropdownMenuContent>;
+export declare function FilterEditorContent({ className, onClick, ...props }: FilterEditorContentProps): import("react/jsx-runtime").JSX.Element;
+export type FilterRemoveProps = ComponentProps<"button"> & {
+    "aria-label": string;
+};
+export declare function FilterRemove({ className, children, ...props }: FilterRemoveProps): import("react/jsx-runtime").JSX.Element;
+export type AppliedFilterProps = FilterChipProps & {
+    label: string;
+    editor?: ReactNode;
+    onRemove?: () => void;
+    disabled?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    editLabel?: string;
+    removeLabel?: string;
+    contentProps?: FilterEditorContentProps;
+    triggerProps?: FilterEditorTriggerProps;
+    removeProps?: Omit<FilterRemoveProps, "aria-label" | "onClick">;
+};
+/** Editing and removal are independent. Values remain owned by the caller. */
+export declare function AppliedFilter({ label, editor, onRemove, disabled, open, onOpenChange, editLabel, removeLabel, contentProps, triggerProps, removeProps, children, ...props }: AppliedFilterProps): import("react/jsx-runtime").JSX.Element;
+export type FilterMenuItemProps = ComponentProps<typeof DropdownMenuSub> & {
+    label: ReactNode;
+    icon?: ReactNode;
+    contentProps?: ComponentProps<typeof DropdownMenuSubContent>;
+};
+export declare function FilterMenuItem({ label, icon, children, contentProps, open, defaultOpen, onOpenChange, ...props }: FilterMenuItemProps): import("react/jsx-runtime").JSX.Element;
+export type FilterCheckboxItemProps = ComponentProps<typeof DropdownMenuCheckboxItem>;
+/** Keep the editor open after pointer or keyboard selection. */
+export declare function FilterCheckboxItem({ onSelect, ...props }: FilterCheckboxItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/filters/filters.js

@@ -0,0 +1,94 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { XIcon } from "lucide-react";
+import { Button } from "../customization.js";
+import { cn } from "../utils.js";
+import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, } from "../primitives/dropdown-menu.js";
+export function FilterEditor(props) {
+    return _jsx(DropdownMenu, { modal: false, ...props });
+}
+export function FilterChip({ className, ...props }) {
+    return (_jsx("div", { "data-mendy-ui": "", "data-slot": "filter-chip", className: cn("mui-123306850fe1 mui-539ae144f076 mui-81b198a2db84 mui-d5111d0e9f48 mui-3fa8c572949b mui-71556df3b421 mui-d191cb569aac mui-c74ab393b96d mui-35f35c41d134 mui-5e49f8678d00 mui-3bc474178684 motion-safe:slide-in-from-bottom-2.5 mui-b225f0361d28 mui-bc94a66158a3", className), ...props }));
+}
+export function FilterEditorTrigger({ className, asChild, ...props }) {
+    return (_jsx(DropdownMenuTrigger, { asChild: true, children: _jsx(Button, { asChild: asChild, variant: "ghost", "data-mendy-ui": "", "data-slot": "filter-editor-trigger", "aria-haspopup": "dialog", className: cn("mui-222f930b8752 mui-57c930dc1c31 mui-66b490dd6005 mui-52417259a4f5 mui-52101fc7d8bb mui-184ddc11e5f9 mui-71556df3b421 mui-70007b876865 mui-e7e01cc7f4df mui-1a5d10977b93 mui-37ad15a95595 mui-4d6720d47806 mui-2e357972fc10 mui-355efe22aedb mui-50aafa8694bb mui-db549d38ff19 mui-8d3c1014b967 mui-4600b77303d6 mui-4027d9c589b6 mui-6f73a280432e", className), ...props }) }));
+}
+export function FilterEditorContent({ className, onClick, ...props }) {
+    return (_jsx(DropdownMenuContent, { "data-mendy-ui": "", "data-slot": "filter-editor-content", role: "dialog", "aria-orientation": undefined, align: "start", sideOffset: 6, loop: true, onClick: (event) => {
+            event.stopPropagation();
+            onClick?.(event);
+        }, className: cn("mui-dcd942c18ddc mui-34055e6f8c1b mui-2368e909f3a5 mui-04760bcd507f mui-37d8a3f448ff", className), ...props }));
+}
+export function FilterRemove({ className, children, ...props }) {
+    return (_jsx(Button, { variant: "ghost", type: "button", "data-mendy-ui": "", "data-slot": "filter-remove", className: cn("mui-222f930b8752 mui-57c930dc1c31 mui-52417259a4f5 mui-04760bcd507f mui-8867d85ed290 mui-27ead27a81df mui-71556df3b421 mui-a503dd374cca mui-8d940fccb093 mui-163a623b3716 mui-37ad15a95595 mui-4d6720d47806 mui-2e357972fc10 mui-355efe22aedb mui-50aafa8694bb mui-db549d38ff19 mui-8d3c1014b967 mui-4600b77303d6", className), ...props, children: children ?? _jsx(XIcon, { className: "mui-61c000c8a98a", "aria-hidden": "true" }) }));
+}
+/** Editing and removal are independent. Values remain owned by the caller. */
+export function AppliedFilter({ label, editor, onRemove, disabled, open, onOpenChange, editLabel = `Edit ${label} filter`, removeLabel = `Remove ${label} filter`, contentProps, triggerProps, removeProps, children, ...props }) {
+    return (_jsx(FilterEditor, { open: open, onOpenChange: onOpenChange, children: _jsxs(FilterChip, { ...props, children: [editor ? (_jsx(FilterEditorTrigger, { disabled: disabled, "aria-label": editLabel, ...triggerProps, onClick: (event) => {
+                        event.stopPropagation();
+                        triggerProps?.onClick?.(event);
+                    }, children: children })) : (_jsx("span", { className: "mui-184ddc11e5f9 mui-e7e01cc7f4df", children: children })), onRemove && (_jsx(FilterRemove, { ...removeProps, disabled: disabled, "aria-label": removeLabel, onClick: (event) => {
+                        event.stopPropagation();
+                        onRemove();
+                    } })), editor && (_jsx(FilterEditorContent, { "aria-label": `${label} filter`, ...contentProps, children: editor }))] }) }));
+}
+export function FilterMenuItem({ label, icon, children, contentProps, open, defaultOpen, onOpenChange, ...props }) {
+    const [internalOpen, setInternalOpen] = useState(defaultOpen ?? false);
+    const triggerRef = useRef(null);
+    const [sideOffset, setSideOffset] = useState(14);
+    const isOpen = open ?? internalOpen;
+    useEffect(() => {
+        const trigger = triggerRef.current;
+        if (!trigger)
+            return;
+        const update = () => {
+            // Overlap the parent menu when there isn't room for two panels side by side.
+            const contentId = trigger.getAttribute("aria-controls");
+            const content = contentId ? document.getElementById(contentId) : null;
+            if (!content)
+                return;
+            const bounds = trigger.getBoundingClientRect();
+            const available = Math.max(bounds.left, window.innerWidth - bounds.right);
+            setSideOffset(available < content.offsetWidth + 14 ? -bounds.width : 14);
+        };
+        const observer = new ResizeObserver(update);
+        observer.observe(trigger);
+        window.addEventListener("resize", update);
+        update();
+        return () => {
+            observer.disconnect();
+            window.removeEventListener("resize", update);
+        };
+    }, [isOpen]);
+    return (_jsxs(DropdownMenuSub, { ...props, open: isOpen, onOpenChange: (nextOpen) => {
+            setInternalOpen(nextOpen);
+            onOpenChange?.(nextOpen);
+        }, children: [_jsxs(DropdownMenuSubTrigger, { ref: triggerRef, "aria-haspopup": contentProps?.role === "dialog" ? "dialog" : "menu", onKeyDown: (event) => {
+                    const forward = getComputedStyle(event.currentTarget).direction === "rtl" ? "ArrowLeft" : "ArrowRight";
+                    if (!isOpen && [forward, "Enter", " "].includes(event.key)) {
+                        const contentId = event.currentTarget.getAttribute("aria-controls");
+                        // A submenu reopened during its exit animation is still inert until
+                        // React commits the open state. Restore keyboard entry after that commit.
+                        requestAnimationFrame(() => {
+                            const content = contentId ? document.getElementById(contentId) : null;
+                            const input = content?.querySelector('input[type="search"], textarea');
+                            (input ?? content)?.focus();
+                        });
+                    }
+                }, children: [icon, _jsx("span", { children: label })] }), _jsx(DropdownMenuPortal, { children: _jsx(DropdownMenuSubContent, { loop: true, sideOffset: sideOffset, alignOffset: -4, ...contentProps, onFocusOutside: (event) => {
+                        contentProps?.onFocusOutside?.(event);
+                        // On narrow screens, leaving the row can focus its parent menu while
+                        // the pointer crosses into the overlapping submenu.
+                        if (event.target === triggerRef.current?.closest("[data-radix-menu-content]")) {
+                            event.preventDefault();
+                        }
+                    }, inert: !isOpen || contentProps?.inert, "aria-hidden": !isOpen || contentProps?.["aria-hidden"], ...(contentProps?.["aria-label"] ? { "aria-labelledby": undefined } : {}), className: cn("mui-dcd942c18ddc mui-34055e6f8c1b mui-2368e909f3a5 mui-04760bcd507f mui-237747164b60", contentProps?.className), children: children }) })] }));
+}
+/** Keep the editor open after pointer or keyboard selection. */
+export function FilterCheckboxItem({ onSelect, ...props }) {
+    return (_jsx(DropdownMenuCheckboxItem, { ...props, onSelect: (event) => {
+            onSelect?.(event);
+            event.preventDefault();
+        } }));
+}

package/dist/filters/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./filter-definition.js";
+export * from "./filter-state.js";
+export * from "./filter-utils.js";
+export * from "./use-filters.js";
+export * from "./use-filter-options.js";
+export * from "./filter-bar.js";
+export * from "./filters.js";
+export * from "./filter-text-editor.js";
+export * from "./filter-select-editor.js";
+export * from "../customization.js";

package/dist/filters/index.js

@@ -0,0 +1,10 @@
+export * from "./filter-definition.js";
+export * from "./filter-state.js";
+export * from "./filter-utils.js";
+export * from "./use-filters.js";
+export * from "./use-filter-options.js";
+export * from "./filter-bar.js";
+export * from "./filters.js";
+export * from "./filter-text-editor.js";
+export * from "./filter-select-editor.js";
+export * from "../customization.js";

package/dist/filters/nuqs.d.ts

@@ -0,0 +1 @@
+export * from "./use-url-filters.js";

package/dist/filters/nuqs.js

@@ -0,0 +1,2 @@
+"use client";
+export * from "./use-url-filters.js";

package/dist/filters/use-filter-options.d.ts

@@ -0,0 +1,24 @@
+import type { Choice, OptionPage, RuntimeField } from "./filter-definition.js";
+interface Request {
+    promise: Promise<OptionPage<Choice>>;
+    abort: AbortController;
+    users: number;
+    settled: boolean;
+    created: number;
+}
+export type OptionCache = Map<string, Request>;
+export declare const FilterOptionCache: import("react").Context<OptionCache | null>;
+export declare function selectedIds(value: unknown): string[];
+export declare function useFilterOptions(id: string, field: RuntimeField, value: unknown, enabled: boolean): {
+    query: string;
+    setQuery(next: string): void;
+    items: readonly Choice[];
+    selected: Choice[];
+    loading: boolean;
+    resolving: boolean;
+    error: string | null | undefined;
+    retry(): void;
+    hasMore: boolean;
+    loadMore(): void;
+};
+export {};