@1771technologies/lytenyte-pro 1.0.14 → 1.0.16

package/dist/filter-selects/filter-row.js

@@ -0,0 +1,118 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useCallback, useMemo } from "react";
+import { useFilterSelectRoot } from "./context.js";
+import { context } from "./filter-row-context.js";
+import { dateOptions, filterNeedsValue, numberOptions, operatorsThatAreNumbers, operatorToOption, stringOptions, } from "./options.js";
+function FilterRowImpl({ filter, children }, forwarded) {
+    const ctx = useFilterSelectRoot();
+    const index = ctx.filters.indexOf(filter);
+    const isLast = ctx.filters.at(-1) === filter;
+    if (index === -1)
+        throw new Error("Filter should be defined among the root filters.");
+    const onOperatorChange = useCallback((opt) => {
+        ctx.setFilters((prev) => {
+            const next = [...prev];
+            const filter = next[index];
+            if (filter.kind === "function")
+                return prev;
+            next[index] = {
+                ...filter,
+                operator: opt.value,
+            };
+            return next;
+        });
+    }, [ctx, index]);
+    const options = useMemo(() => {
+        if (filter.kind === "function")
+            return [];
+        if (filter.kind === "number")
+            return numberOptions;
+        if (filter.kind === "date")
+            return dateOptions;
+        return stringOptions;
+    }, [filter.kind]);
+    const operatorValue = useMemo(() => {
+        if (filter.kind === "function")
+            return { value: "-", label: "-" };
+        return operatorToOption[filter.operator ?? "equals"];
+    }, [filter]);
+    const value = useMemo(() => {
+        if (filter.kind === "function")
+            return null;
+        return filter.value;
+    }, [filter]);
+    const onValueChange = useCallback((v) => {
+        if (filter.kind === "function")
+            return;
+        ctx.setFilters((prev) => {
+            const next = [...prev];
+            const filter = next[index];
+            if (filter.kind === "function")
+                return prev;
+            if (filter.kind === "number") {
+                next[index] = {
+                    ...filter,
+                    value: filter.operator === "not_equals" || filter.operator === "equals"
+                        ? typeof v === "number"
+                            ? v
+                            : !v
+                                ? null
+                                : Number.parseFloat(v)
+                        : typeof v === "number"
+                            ? v
+                            : Number.parseFloat(v ?? ""),
+                };
+                return next;
+            }
+            const isNumber = operatorsThatAreNumbers.has(filter.operator);
+            next[index] = {
+                ...filter,
+                value: isNumber ? (typeof v === "number" ? v : Number.parseFloat(v)) : v,
+            };
+            return next;
+        });
+    }, [ctx, filter.kind, index]);
+    const extenderValue = useMemo(() => {
+        return filter.kind == "function" ? null : (filter.nextExtender ?? "AND");
+    }, [filter]);
+    const onExtenderChange = useCallback((v) => {
+        ctx.setFilters((prev) => {
+            const next = [...prev];
+            const filter = next[index];
+            if (filter.kind === "function")
+                return prev;
+            next[index] = {
+                ...filter,
+                nextExtender: v,
+            };
+            return next;
+        });
+    }, [ctx, index]);
+    const showExtender = useMemo(() => {
+        if (filter.kind === "function")
+            return false;
+        // If the filter isn't the last one then show the extender
+        if (!isLast)
+            return true;
+        if (filter.operator != null && filter.value != null && index + 1 < ctx.maxCount)
+            return true;
+        return false;
+    }, [ctx.maxCount, filter, index, isLast]);
+    return (_jsx(context.Provider, { value: {
+            filter,
+            extender: extenderValue,
+            onExtenderChange,
+            showExtender: showExtender,
+            operatorOnChange: onOperatorChange,
+            operatorOptions: options,
+            operatorValue: operatorValue,
+            value,
+            onValueChange,
+            isNumberInput: filter.kind === "function"
+                ? false
+                : filter.kind === "number" || operatorsThatAreNumbers.has(filter.operator),
+            filterHasNoValue: filter.kind === "function" || filterNeedsValue.has(filter.operator),
+            valueDisabled: filter.kind === "function" || !filter.operator,
+        }, children: _jsx("div", { ref: forwarded, children: children }) }));
+}
+export const FilterRow = forwardRef(FilterRowImpl);

package/dist/filter-selects/index.d.ts

@@ -0,0 +1,20 @@
+import { Root } from "./root.js";
+export declare const FilterSelect: {
+    useFilterSelect: <T>({ grid, column, maxCount }: import("./use-filter-select.js").UseFilterSelectParams<T>) => {
+        reset: () => void;
+        apply: () => void;
+        defaultFilter: import("./use-filter-select.js").FilterSelectFlat;
+        filters: import("./use-filter-select.js").FilterSelectFlat[];
+        setFilters: (v: import("./use-filter-select.js").FilterSelectFlat[] | ((v: import("./use-filter-select.js").FilterSelectFlat[]) => import("./use-filter-select.js").FilterSelectFlat[])) => void;
+        maxCount: number;
+    };
+    Root: typeof Root;
+    FilterRow: import("react").ForwardRefExoticComponent<import("./filter-row.js").FilterRowProps & {
+        children?: import("react").ReactNode | undefined;
+    } & import("react").RefAttributes<HTMLDivElement>>;
+    OperatorSelect: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLSelectElement> & import("react").SelectHTMLAttributes<HTMLSelectElement> & import("./operator-select.js").OperatorSelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;
+    ValueInput: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLInputElement> & import("react").InputHTMLAttributes<HTMLInputElement> & import("./value-input.js").ValueInputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+    FilterCombinator: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & import("./filter-combinator.js").FilterCombinatorProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Apply: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("./apply.js").ApplyProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+    Reset: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & import("./reset.js").ResetProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+};

package/dist/filter-selects/index.js

@@ -0,0 +1,18 @@
+import { Apply } from "./apply.js";
+import { FilterCombinator } from "./filter-combinator.js";
+import { FilterRow } from "./filter-row.js";
+import { OperatorSelect } from "./operator-select.js";
+import { Reset } from "./reset.js";
+import { Root } from "./root.js";
+import { useFilterSelect } from "./use-filter-select.js";
+import { ValueInput } from "./value-input.js";
+export const FilterSelect = {
+    useFilterSelect,
+    Root,
+    FilterRow,
+    OperatorSelect,
+    ValueInput,
+    FilterCombinator,
+    Apply,
+    Reset,
+};

package/dist/filter-selects/is-complete-filter.d.ts

@@ -0,0 +1,2 @@
+import type { FilterSelectFlat } from "./use-filter-select";
+export declare function isCompleteFilter(c: FilterSelectFlat): boolean;

package/dist/filter-selects/is-complete-filter.js

@@ -0,0 +1,5 @@
+export function isCompleteFilter(c) {
+    if (c.kind === "function")
+        return true;
+    return c.operator != null && c.value !== undefined;
+}

package/dist/filter-selects/operator-select.d.ts

@@ -0,0 +1,14 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
+export type SelectOption = {
+    label: string;
+    value: string;
+};
+export interface OperatorSelectSlotProps {
+    readonly options: SelectOption[];
+    readonly value: SelectOption | null;
+    readonly onChange: (v: SelectOption) => void;
+}
+export interface OperatorSelectProps {
+    readonly as?: SlotComponent<OperatorSelectSlotProps>;
+}
+export declare const OperatorSelect: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLSelectElement> & import("react").SelectHTMLAttributes<HTMLSelectElement> & OperatorSelectProps, "ref"> & import("react").RefAttributes<HTMLSelectElement>>;

package/dist/filter-selects/operator-select.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
+import { forwardRef } from "react";
+import { useFilterRow } from "./filter-row-context.js";
+function OperatorSelectImpl({ as, ...props }, ref) {
+    const ctx = useFilterRow();
+    const slot = useSlot({
+        props: [props],
+        state: {
+            options: ctx.operatorOptions,
+            value: ctx.operatorValue,
+            onChange: ctx.operatorOnChange,
+        },
+        ref: ref,
+        slot: as ?? (_jsx("select", { value: ctx.operatorValue?.value ?? "", onChange: (c) => {
+                const val = c.target.value;
+                const opt = ctx.operatorOptions.find((c) => c.value === val);
+                ctx.operatorOnChange(opt);
+            }, children: ctx.operatorOptions.map((c) => {
+                return (_jsx("option", { value: c.value, children: c.label }, c.value));
+            }) })),
+    });
+    return slot;
+}
+export const OperatorSelect = forwardRef(OperatorSelectImpl);

package/dist/filter-selects/options.d.ts

@@ -0,0 +1,9 @@
+import type { SelectOption } from "./operator-select";
+export declare const numberOptions: SelectOption[];
+export declare const stringOptions: SelectOption[];
+export declare const dateOptions: SelectOption[];
+export declare const operatorToOption: {
+    [k: string]: SelectOption;
+};
+export declare const operatorsThatAreNumbers: Set<string>;
+export declare const filterNeedsValue: Set<string>;

package/dist/filter-selects/options.js

@@ -0,0 +1,100 @@
+export const numberOptions = [
+    { label: "Equals", value: "equals" },
+    { label: "Not Equals", value: "not_equals" },
+    { label: "Less Than", value: "less_than" },
+    { label: "Less Than Or Equals", value: "less_than_or_equals" },
+    { label: "Greater Than", value: "greater_than" },
+    { label: "Greater Than or Equals", value: "greater_than_or_equals" },
+];
+export const stringOptions = [
+    { label: "Equals", value: "equals" },
+    { label: "Not Equals", value: "not_equals" },
+    { label: "Less Than", value: "less_than" },
+    { label: "Less Than Or Equals", value: "less_than_or_equals" },
+    { label: "Greater Than", value: "greater_than" },
+    { label: "Greater Than Or Equals", value: "greater_than_or_equals" },
+    { label: "Begins With", value: "begins_with" },
+    { label: "Not Begins With", value: "not_begins_with" },
+    { label: "Ends With", value: "ends_with" },
+    { label: "Not Ends With", value: "not_ends_with" },
+    { label: "Contains", value: "contains" },
+    { label: "Not Contains", value: "not_contains" },
+    { label: "Length", value: "length" },
+    { label: "Not Length", value: "not_length" },
+    { label: "Matches", value: "matches" },
+    { label: "Length Less Than", value: "length_less_than" },
+    { label: "Length Less Than Or Equals", value: "length_less_than_or_equals" },
+    { label: "Length Greater Than", value: "length_greater_than" },
+    { label: "Length Greater Than Or Equals", value: "length_greater_than_or_equals" },
+];
+export const dateOptions = [
+    { label: "Equals", value: "equals" },
+    { label: "Not Equals", value: "not_equals" },
+    { label: "Before", value: "before" },
+    { label: "Before Or Equals", value: "before_or_equals" },
+    { label: "After", value: "after" },
+    { label: "After Or Equals", value: "after_or_equals" },
+    { label: "Year To Date", value: "year_to_date" },
+    { label: "This Week", value: "this_week" },
+    { label: "This Month", value: "this_month" },
+    { label: "This Year", value: "this_year" },
+    { label: "Last Week", value: "last_week" },
+    { label: "Last Month", value: "last_month" },
+    { label: "Last Year", value: "last_year" },
+    { label: "Next Week", value: "next_week" },
+    { label: "Next Month", value: "next_month" },
+    { label: "Next Year", value: "next_year" },
+    { label: "Today", value: "today" },
+    { label: "Tomorrow", value: "tomorrow" },
+    { label: "Yesterday", value: "yesterday" },
+    { label: "Week Of Year", value: "week_of_year" },
+    { label: "Quarter Of Year", value: "quarter_of_year" },
+    { label: "Is Weekend", value: "is_weekend" },
+    { label: "Is Weekday", value: "is_weekday" },
+    { label: "N Days Ago", value: "n_days_ago" },
+    { label: "N Days Ahead", value: "n_days_ahead" },
+    { label: "N Weeks Ago", value: "n_weeks_ago" },
+    { label: "N Weeks Ahead", value: "n_weeks_ahead" },
+    { label: "N Months Ago", value: "n_months_ago" },
+    { label: "N Months Ahead", value: "n_months_ahead" },
+    { label: "N Years Ago", value: "n_years_ago" },
+    { label: "N Years Ahead", value: "n_years_ahead" },
+];
+export const operatorToOption = Object.fromEntries([...numberOptions, ...stringOptions, ...dateOptions].map((c) => {
+    return [c.value, c];
+}));
+export const operatorsThatAreNumbers = new Set([
+    "n_days_ago",
+    "n_days_ahead",
+    "n_weeks_ago",
+    "n_weeks_ahead",
+    "n_months_ago",
+    "n_months_ahead",
+    "n_years_ago",
+    "n_years_ahead",
+    "length",
+    "not_length",
+    "length_less_than",
+    "length_less_than_or_equals",
+    "length_greater_than",
+    "length_greater_than_or_equals",
+    "week_of_year",
+    "quarter_of_year",
+]);
+export const filterNeedsValue = new Set([
+    "year_to_date",
+    "this_week",
+    "this_month",
+    "this_year",
+    "last_week",
+    "last_month",
+    "last_year",
+    "next_week",
+    "next_month",
+    "next_year",
+    "today",
+    "tomorrow",
+    "yesterday",
+    "is_weekend",
+    "is_weekday",
+]);

package/dist/filter-selects/reset.d.ts

@@ -0,0 +1,7 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
+export interface ResetProps {
+    readonly as?: SlotComponent<{
+        onReset: () => void;
+    }>;
+}
+export declare const Reset: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & ResetProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/filter-selects/reset.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
+import { forwardRef } from "react";
+import { useFilterSelectRoot } from "./context.js";
+function ResetImpl({ as, ...props }, ref) {
+    const ctx = useFilterSelectRoot();
+    const slot = useSlot({
+        props: [
+            {
+                onClick: ctx.reset,
+            },
+            props,
+        ],
+        ref: ref,
+        slot: as ?? _jsx("button", { children: "Reset" }),
+        state: {
+            onReset: ctx.reset,
+        },
+    });
+    return slot;
+}
+export const Reset = forwardRef(ResetImpl);

package/dist/filter-selects/root.d.ts

@@ -0,0 +1,13 @@
+import type { Dispatch, PropsWithChildren, SetStateAction } from "react";
+import type { FilterSelectFlat } from "./use-filter-select";
+export interface RootProps {
+    readonly root: {
+        readonly defaultFilter: FilterSelectFlat;
+        readonly filters: FilterSelectFlat[];
+        readonly setFilters: Dispatch<SetStateAction<FilterSelectFlat[]>>;
+        readonly apply: () => void;
+        readonly reset: () => void;
+        readonly maxCount: number;
+    };
+}
+export declare function Root({ root, children }: PropsWithChildren<RootProps>): import("react/jsx-runtime").JSX.Element;

package/dist/filter-selects/root.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { context } from "./context.js";
+export function Root({ root, children }) {
+    return _jsx(context.Provider, { value: root, children: children });
+}

package/dist/filter-selects/to-filter-item.d.ts

@@ -0,0 +1,3 @@
+import type { FilterCombination } from "../+types";
+import type { FilterSelectFlatDate, FilterSelectFlatNumber, FilterSelectFlatString } from "./use-filter-select";
+export declare function toFilterItem(f: FilterSelectFlatDate | FilterSelectFlatNumber | FilterSelectFlatString): FilterCombination["filters"][number];

package/dist/filter-selects/to-filter-item.js

@@ -0,0 +1,7 @@
+export function toFilterItem(f) {
+    if (f.kind === "number")
+        return { kind: "number", operator: f.operator, value: f.value };
+    if (f.kind === "date")
+        return { kind: "date", value: f.value, operator: f.operator };
+    return { kind: "string", value: f.value, operator: f.operator };
+}

package/dist/filter-selects/use-filter-select.d.ts

@@ -0,0 +1,37 @@
+import type { Column, FilterDateOperator, FilterNumberOperator, FilterStringOperator, Grid } from "../+types";
+export interface UseFilterSelectParams<T> {
+    readonly grid: Grid<T>;
+    readonly column: Column<T>;
+    readonly maxCount?: number;
+}
+export type FilterSelectFlatFunc = {
+    kind: "function";
+    func: any;
+};
+export type FilterSelectFlatNumber = {
+    kind: "number";
+    operator?: FilterNumberOperator;
+    value?: string | number | null;
+    nextExtender?: null | "AND" | "OR";
+};
+export type FilterSelectFlatString = {
+    kind: "string";
+    operator?: FilterStringOperator;
+    value?: string | number | null;
+    nextExtender?: null | "AND" | "OR";
+};
+export type FilterSelectFlatDate = {
+    kind: "date";
+    operator?: FilterDateOperator;
+    value?: string | number | null;
+    nextExtender?: null | "AND" | "OR";
+};
+export type FilterSelectFlat = FilterSelectFlatFunc | FilterSelectFlatNumber | FilterSelectFlatString | FilterSelectFlatDate;
+export declare const useFilterSelect: <T>({ grid, column, maxCount }: UseFilterSelectParams<T>) => {
+    reset: () => void;
+    apply: () => void;
+    defaultFilter: FilterSelectFlat;
+    filters: FilterSelectFlat[];
+    setFilters: (v: FilterSelectFlat[] | ((v: FilterSelectFlat[]) => FilterSelectFlat[])) => void;
+    maxCount: number;
+};

package/dist/filter-selects/use-filter-select.js

@@ -0,0 +1,158 @@
+import { useCallback, useMemo } from "react";
+import { useTwoFlowState } from "@1771technologies/lytenyte-core/yinternal";
+import { isCompleteFilter } from "./is-complete-filter.js";
+import { toFilterItem } from "./to-filter-item.js";
+export const useFilterSelect = ({ grid, column, maxCount = 2 }) => {
+    const model = grid.state.filterModel.useValue();
+    const filterOnModel = model[column.id];
+    const defaultFilter = useMemo(() => {
+        if (column.type === "date" || column.type === "datetime")
+            return { kind: "date", operator: "equals" };
+        if (column.type === "number")
+            return { kind: "number", operator: "equals" };
+        return { kind: "string", operator: "equals" };
+    }, [column.type]);
+    const filterValue = useMemo(() => {
+        if (filterOnModel) {
+            if (filterOnModel.kind === "func")
+                return [{ kind: "function", func: filterOnModel.func }];
+            if (filterOnModel.kind === "number")
+                return [{ kind: "number", value: filterOnModel.value, operator: filterOnModel.operator }];
+            if (filterOnModel.kind === "string")
+                return [{ kind: "string", value: filterOnModel.value, operator: filterOnModel.operator }];
+            if (filterOnModel.kind === "date")
+                return [{ kind: "date", value: filterOnModel.value, operator: filterOnModel.operator }];
+            if (filterOnModel.kind === "combination") {
+                const filters = [];
+                const stack = [...filterOnModel.filters.map((c) => [filterOnModel.operator, c])];
+                while (stack.length) {
+                    const [nextExtender, f] = stack.shift();
+                    if (f.kind === "combination") {
+                        stack.push(...f.filters.map((c) => [f.operator, c]));
+                    }
+                    else if (f.kind === "string") {
+                        filters.push({ kind: "string", operator: f.operator, value: f.value, nextExtender });
+                    }
+                    else if (f.kind === "number") {
+                        filters.push({ kind: "number", operator: f.operator, value: f.value, nextExtender });
+                    }
+                    else if (f.kind === "date") {
+                        filters.push({ kind: "date", operator: f.operator, value: f.value, nextExtender });
+                    }
+                }
+                console.log(filters);
+                return filters;
+            }
+            return [];
+        }
+        return [defaultFilter];
+    }, [filterOnModel, defaultFilter]);
+    const [filters, setFilters] = useTwoFlowState(filterValue);
+    const finalFilters = useMemo(() => {
+        const last = filters.at(-1);
+        if (last.kind === "function" || filters.length >= maxCount)
+            return filters;
+        if (last.operator == undefined || last.value == null)
+            return filters;
+        return [...filters, defaultFilter];
+    }, [defaultFilter, filters, maxCount]);
+    const reset = useCallback(() => {
+        return setFilters([defaultFilter]);
+    }, [defaultFilter, setFilters]);
+    const apply = useCallback(() => {
+        const fn = finalFilters.find((c) => c.kind === "function");
+        if (fn) {
+            grid.state.filterModel.set((prev) => {
+                const next = { ...prev };
+                next[column.id] = { kind: "func", func: fn.func };
+                return prev;
+            });
+            return;
+        }
+        const filters = finalFilters.filter((c) => isCompleteFilter(c));
+        if (filters.length === 1) {
+            const filter = filters[0];
+            if (!isCompleteFilter(filter)) {
+                grid.state.filterModel.set((prev) => {
+                    const filters = { ...prev };
+                    delete filters[column.id];
+                    return filters;
+                });
+                return;
+            }
+            let next = null;
+            if (filter.kind === "date")
+                next = { kind: "date", value: filter.value, operator: filter.operator };
+            else if (filter.kind === "number")
+                next = { kind: "number", value: filter.value, operator: filter.operator };
+            else if (filter.kind === "string")
+                next = { kind: "string", value: filter.value, operator: filter.operator };
+            if (next) {
+                console.log(next);
+                grid.state.filterModel.set((prev) => {
+                    const filters = { ...prev };
+                    filters[column.id] = next;
+                    return filters;
+                });
+            }
+            return;
+        }
+        const combinedFilters = [];
+        let i = 0;
+        while (i < filters.length) {
+            const filter = filters[i];
+            if ((filter.nextExtender ?? "AND") === "AND") {
+                const ors = [filter];
+                while (i + 1 < filters.length) {
+                    const next = filters[i + 1];
+                    ors.push(next);
+                    i++;
+                    if ((next.nextExtender ?? "AND") !== "AND" || i + 1 >= filters.length)
+                        break;
+                }
+                if (ors.length > 1) {
+                    combinedFilters.push({
+                        kind: "combination",
+                        filters: ors.map(toFilterItem),
+                        operator: "AND",
+                    });
+                }
+                else {
+                    combinedFilters.push(toFilterItem(ors[0]));
+                }
+            }
+            else {
+                combinedFilters.push(toFilterItem(filter));
+            }
+            i++;
+        }
+        grid.state.filterModel.set((prev) => {
+            if (combinedFilters.length === 0) {
+                const filters = { ...prev };
+                delete filters[column.id];
+                return filters;
+            }
+            if (combinedFilters.length === 1) {
+                const filters = { ...prev };
+                filters[column.id] = combinedFilters[0];
+                return filters;
+            }
+            const filters = { ...prev };
+            filters[column.id] = { kind: "combination", filters: combinedFilters, operator: "OR" };
+            return filters;
+        });
+        return;
+    }, [column.id, finalFilters, grid.state.filterModel]);
+    const setF = useCallback((v) => {
+        const next = typeof v === "function" ? v(finalFilters) : v;
+        setFilters(next);
+    }, [finalFilters, setFilters]);
+    return useMemo(() => ({
+        reset,
+        apply,
+        defaultFilter,
+        filters: finalFilters,
+        setFilters: setF,
+        maxCount,
+    }), [apply, defaultFilter, finalFilters, maxCount, reset, setF]);
+};

package/dist/filter-selects/value-input.d.ts

@@ -0,0 +1,12 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
+export interface ValueInputSlotProps {
+    readonly value: string | number | null | undefined;
+    readonly onValueChange: (v: string | number | null) => void;
+    readonly disabled: boolean;
+    readonly isNumberInput: boolean;
+    readonly filterNeedsValue: boolean;
+}
+export interface ValueInputProps {
+    readonly as?: SlotComponent<ValueInputSlotProps>;
+}
+export declare const ValueInput: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLInputElement> & import("react").InputHTMLAttributes<HTMLInputElement> & ValueInputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;

package/dist/filter-selects/value-input.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
+import { forwardRef } from "react";
+import { useFilterRow } from "./filter-row-context.js";
+function ValueInputImpl({ as, ...props }, ref) {
+    const ctx = useFilterRow();
+    const slot = useSlot({
+        slot: as ?? (_jsx(_Fragment, { children: !ctx.filterHasNoValue && (_jsx("input", { type: ctx.filter.kind === "number" || ctx.isNumberInput
+                    ? "number"
+                    : ctx.filter.kind === "date"
+                        ? "date"
+                        : "text", value: ctx.value ?? "", onChange: (e) => {
+                    ctx.onValueChange(e.target.value);
+                } })) })),
+        props: [props],
+        ref,
+        state: {
+            disabled: ctx.valueDisabled,
+            filterNeedsValue: ctx.filterHasNoValue,
+            isNumberInput: ctx.isNumberInput,
+            onValueChange: ctx.onValueChange,
+            value: ctx.value,
+        },
+    });
+    return slot;
+}
+export const ValueInput = forwardRef(ValueInputImpl);

package/dist/filter-tree/branch.d.ts

@@ -1,6 +1,6 @@
 import type { TreeVirtualBranch } from "../tree-view/virtualized/make-virtual-tree";
 import type { FilterInFilterItem } from "../+types";
-import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
 export interface FilterTreeBranch {
     readonly item: TreeVirtualBranch<FilterInFilterItem>;
     readonly label: SlotComponent;

package/dist/filter-tree/branch.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
 import { TreeBranch } from "../tree-view/branch/branch.js";
-import { useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { FilterTreeItemContext } from "./context.js";
 import { useTreeItem } from "./hooks/use-tree-item.js";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
 export const Branch = forwardRef(function Branch({ item, labelWrap, label, ...props }, forwarded) {
     const value = useTreeItem(item);
     const labelSlot = useSlot({

package/dist/filter-tree/hooks/use-filter-tree.js

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from "react";
 import { useVirtualizedTree } from "../../tree-view/virtualized/use-virtualized-tree.js";
-import { useEvent } from "@1771technologies/lytenyte-react-hooks";
+import { useEvent } from "@1771technologies/lytenyte-core/yinternal";
 export function useFilterTree({ grid, column, treeItemHeight = 24, pivotMode, applyChangesImmediately = false, query, }) {
     const [items, setItems] = useState([]);
     const [expansions, onExpansionChange] = useState({});