@1771technologies/lytenyte-pro 1.0.0-beta.10 → 1.0.0-beta.11

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

@@ -3,53 +3,12 @@ import { InclusionCheckbox } from "./inclusion-checkbox.js";
 import { Root } from "./root.js";
 import { useFilterTree } from "./hooks/use-filter-tree.js";
 export declare const FilterTree: {
-  Root: typeof Root;
-  Panel: import("react").ForwardRefExoticComponent<
-    Omit<
-      import("react").DetailedHTMLProps<
-        import("react").HTMLAttributes<HTMLUListElement>,
-        HTMLUListElement
-      >,
-      "ref"
-    > &
-      import("react").RefAttributes<HTMLUListElement>
-  >;
-  PassiveScroll: typeof ForceSyncScrolling;
-  Leaf: import("react").ForwardRefExoticComponent<
-    Omit<
-      import("./leaf.js").FilterTreeLeafProps &
-        import("react").ClassAttributes<HTMLLIElement> &
-        import("react").LiHTMLAttributes<HTMLLIElement>,
-      "ref"
-    > &
-      import("react").RefAttributes<HTMLLIElement>
-  >;
-  Branch: import("react").ForwardRefExoticComponent<
-    Omit<
-      import("./branch.js").FilterTreeBranch &
-        import("react").ClassAttributes<HTMLLIElement> &
-        import("react").LiHTMLAttributes<HTMLLIElement>,
-      "ref"
-    > &
-      import("react").RefAttributes<HTMLLIElement>
-  >;
-  Label: import("react").ForwardRefExoticComponent<
-    Omit<
-      import("react").ClassAttributes<HTMLDivElement> &
-        import("react").HTMLAttributes<HTMLDivElement> &
-        import("./label.js").LabelProps,
-      "ref"
-    > &
-      import("react").RefAttributes<HTMLDivElement>
-  >;
-  Checkbox: import("react").ForwardRefExoticComponent<
-    Omit<
-      import("react").ClassAttributes<HTMLDivElement> &
-        import("react").HTMLAttributes<HTMLDivElement> &
-        InclusionCheckbox,
-      "ref"
-    > &
-      import("react").RefAttributes<HTMLDivElement>
-  >;
-  useFilterTree: typeof useFilterTree;
+    Root: typeof Root;
+    Panel: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & import("react").RefAttributes<HTMLUListElement>>;
+    PassiveScroll: typeof ForceSyncScrolling;
+    Leaf: import("react").ForwardRefExoticComponent<Omit<import("./leaf.js").FilterTreeLeafProps & import("react").ClassAttributes<HTMLLIElement> & import("react").LiHTMLAttributes<HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+    Branch: import("react").ForwardRefExoticComponent<Omit<import("./branch.js").FilterTreeBranch & import("react").ClassAttributes<HTMLLIElement> & import("react").LiHTMLAttributes<HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+    Label: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & import("./label.js").LabelProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Checkbox: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & InclusionCheckbox, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    useFilterTree: typeof useFilterTree;
 };

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

@@ -7,12 +7,12 @@ import { Leaf } from "./leaf.js";
 import { Root } from "./root.js";
 import { useFilterTree } from "./hooks/use-filter-tree.js";
 export const FilterTree = {
-  Root,
-  Panel: TreePanel,
-  PassiveScroll: ForceSyncScrolling,
-  Leaf: Leaf,
-  Branch: Branch,
-  Label: Label,
-  Checkbox: InclusionCheckbox,
-  useFilterTree,
+    Root,
+    Panel: TreePanel,
+    PassiveScroll: ForceSyncScrolling,
+    Leaf: Leaf,
+    Branch: Branch,
+    Label: Label,
+    Checkbox: InclusionCheckbox,
+    useFilterTree,
 };

package/dist/filter-tree/hooks/use-filter-tree.d.ts

@@ -3,41 +3,35 @@ import type { Column, FilterIn, FilterInFilterItem, Grid } from "../../+types";
 import type { PathRoot } from "@1771technologies/lytenyte-shared";
 import type { TreeVirtualItem } from "../../tree-view/virtualized/make-virtual-tree";
 export interface UseTreeFilterReturn<T> {
-  readonly rootProps: {
-    readonly fetchItems: () => void;
-    readonly loading: boolean;
-    readonly error: any;
-    readonly pivotMode: boolean;
-    readonly grid: Grid<T>;
-    readonly expansions: Record<string, boolean>;
-    readonly onExpansionChange: Dispatch<SetStateAction<Record<string, boolean>>>;
-    readonly treeRef: (el: HTMLElement | null) => void;
-    readonly getAllIds: () => Set<string>;
-    readonly getIdsBetweenNodes: (left: HTMLElement, right: HTMLElement) => string[];
-    readonly onFocusChange: (el: HTMLElement | null) => void;
-    readonly root: PathRoot<FilterInFilterItem>;
-    readonly columnId: string;
-    readonly items: FilterInFilterItem[];
-    readonly applyChangesImmediately: boolean;
-    readonly filterIn: FilterIn;
-    readonly filterInChange: Dispatch<SetStateAction<FilterIn>>;
-  };
-  readonly tree: TreeVirtualItem<FilterInFilterItem>[];
-  readonly spacer: JSX.Element;
-  readonly apply: () => void;
-  readonly reset: () => void;
+    readonly rootProps: {
+        readonly fetchItems: () => void;
+        readonly loading: boolean;
+        readonly error: any;
+        readonly pivotMode: boolean;
+        readonly grid: Grid<T>;
+        readonly expansions: Record<string, boolean>;
+        readonly onExpansionChange: Dispatch<SetStateAction<Record<string, boolean>>>;
+        readonly treeRef: (el: HTMLElement | null) => void;
+        readonly getAllIds: () => Set<string>;
+        readonly getIdsBetweenNodes: (left: HTMLElement, right: HTMLElement) => string[];
+        readonly onFocusChange: (el: HTMLElement | null) => void;
+        readonly root: PathRoot<FilterInFilterItem>;
+        readonly columnId: string;
+        readonly items: FilterInFilterItem[];
+        readonly applyChangesImmediately: boolean;
+        readonly filterIn: FilterIn;
+        readonly filterInChange: Dispatch<SetStateAction<FilterIn>>;
+    };
+    readonly tree: TreeVirtualItem<FilterInFilterItem>[];
+    readonly spacer: JSX.Element;
+    readonly apply: () => void;
+    readonly reset: () => void;
 }
 export interface UseFilterTreeArgs<T> {
-  grid: Grid<T>;
-  column: Column<T>;
-  treeItemHeight?: number;
-  pivotMode?: boolean;
-  applyChangesImmediately?: boolean;
+    grid: Grid<T>;
+    column: Column<T>;
+    treeItemHeight?: number;
+    pivotMode?: boolean;
+    applyChangesImmediately?: boolean;
 }
-export declare function useFilterTree<T>({
-  grid,
-  column,
-  treeItemHeight,
-  pivotMode,
-  applyChangesImmediately,
-}: UseFilterTreeArgs<T>): UseTreeFilterReturn<T>;
+export declare function useFilterTree<T>({ grid, column, treeItemHeight, pivotMode, applyChangesImmediately, }: UseFilterTreeArgs<T>): UseTreeFilterReturn<T>;

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

@@ -1,98 +1,96 @@
 import { useEffect, useMemo, useState } from "react";
 import { useVirtualizedTree } from "../../tree-view/virtualized/use-virtualized-tree";
 import { useEvent } from "@1771technologies/lytenyte-react-hooks";
-export function useFilterTree({
-  grid,
-  column,
-  treeItemHeight = 24,
-  pivotMode,
-  applyChangesImmediately = false,
-}) {
-  const [items, setItems] = useState([]);
-  const [expansions, onExpansionChange] = useState({});
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState();
-  const rds = grid.state.rowDataSource.useValue();
-  const filterModel = grid.state.filterInModel.useValue();
-  const pivotModel = grid.state.columnPivotModel.useValue().filtersIn;
-  const currentPivotMode = grid.state.columnPivotMode.useValue();
-  const model = (pivotMode ?? currentPivotMode) ? pivotModel : filterModel;
-  const existingFilter = useMemo(() => {
-    const filter = model[column.id];
-    return filter ?? { kind: "in", operator: "not_in", value: new Set() };
-  }, [column.id, model]);
-  const [changes, setChanges] = useState(() => existingFilter);
-  // Keep in sync with any external changes.
-  useEffect(() => {
-    setChanges(existingFilter);
-  }, [existingFilter]);
-  const fetchItems = useEvent(() => {
-    const items = rds.inFilterItems(column);
-    if ("then" in items) {
-      setLoading(true);
-      items
-        .then((res) => {
-          setItems(res);
-          setError(null);
-        })
-        .catch((error) => setError(error))
-        .finally(() => setLoading(false));
-    } else {
-      setItems(items);
-      setError(null);
-      setLoading(false);
-    }
-  });
-  useEffect(() => {
-    fetchItems();
-  }, [column, fetchItems, rds]);
-  const itemsWithSelectAll = useMemo(() => {
-    return [{ id: "__LNG__SELECT_ALL", label: "(Select All)", value: "" }, ...items];
-  }, [items]);
-  const virt = useVirtualizedTree({
-    itemHeight: treeItemHeight,
-    paths: itemsWithSelectAll,
-    expansions,
-    expansionDefault: true,
-    nonAdjacentPathTrees: false,
-  });
-  const apply = useEvent(() => {
-    if (applyChangesImmediately) return;
-    if (pivotMode) {
-      grid.state.columnPivotModel.set((prev) => {
-        return {
-          ...prev,
-          filtersIn: { ...prev.filtersIn, [column.id]: changes },
-        };
-      });
-    } else {
-      grid.state.filterInModel.set((prev) => ({ ...prev, [column.id]: changes }));
-    }
-  });
-  const reset = useEvent(() => {
-    if (applyChangesImmediately) return;
-    setChanges(existingFilter);
-  });
-  return {
-    rootProps: {
-      fetchItems,
-      items,
-      grid,
-      columnId: column.id,
-      expansions,
-      pivotMode: pivotMode ?? currentPivotMode,
-      onExpansionChange,
-      treeRef: virt.ref,
-      loading,
-      error,
-      filterIn: changes,
-      filterInChange: setChanges,
-      applyChangesImmediately,
-      ...virt.rootProps,
-    },
-    spacer: virt.spacer,
-    tree: virt.virtualTree,
-    apply,
-    reset,
-  };
+export function useFilterTree({ grid, column, treeItemHeight = 24, pivotMode, applyChangesImmediately = false, }) {
+    const [items, setItems] = useState([]);
+    const [expansions, onExpansionChange] = useState({});
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState();
+    const rds = grid.state.rowDataSource.useValue();
+    const filterModel = grid.state.filterInModel.useValue();
+    const pivotModel = grid.state.columnPivotModel.useValue().filtersIn;
+    const currentPivotMode = grid.state.columnPivotMode.useValue();
+    const model = (pivotMode ?? currentPivotMode) ? pivotModel : filterModel;
+    const existingFilter = useMemo(() => {
+        const filter = model[column.id];
+        return filter ?? { kind: "in", operator: "not_in", value: new Set() };
+    }, [column.id, model]);
+    const [changes, setChanges] = useState(() => existingFilter);
+    // Keep in sync with any external changes.
+    useEffect(() => {
+        setChanges(existingFilter);
+    }, [existingFilter]);
+    const fetchItems = useEvent(() => {
+        const items = rds.inFilterItems(column);
+        if ("then" in items) {
+            setLoading(true);
+            items
+                .then((res) => {
+                setItems(res);
+                setError(null);
+            })
+                .catch((error) => setError(error))
+                .finally(() => setLoading(false));
+        }
+        else {
+            setItems(items);
+            setError(null);
+            setLoading(false);
+        }
+    });
+    useEffect(() => {
+        fetchItems();
+    }, [column, fetchItems, rds]);
+    const itemsWithSelectAll = useMemo(() => {
+        return [{ id: "__LNG__SELECT_ALL", label: "(Select All)", value: "" }, ...items];
+    }, [items]);
+    const virt = useVirtualizedTree({
+        itemHeight: treeItemHeight,
+        paths: itemsWithSelectAll,
+        expansions,
+        expansionDefault: true,
+        nonAdjacentPathTrees: false,
+    });
+    const apply = useEvent(() => {
+        if (applyChangesImmediately)
+            return;
+        if (pivotMode) {
+            grid.state.columnPivotModel.set((prev) => {
+                return {
+                    ...prev,
+                    filtersIn: { ...prev.filtersIn, [column.id]: changes },
+                };
+            });
+        }
+        else {
+            grid.state.filterInModel.set((prev) => ({ ...prev, [column.id]: changes }));
+        }
+    });
+    const reset = useEvent(() => {
+        if (applyChangesImmediately)
+            return;
+        setChanges(existingFilter);
+    });
+    return {
+        rootProps: {
+            fetchItems,
+            items,
+            grid,
+            columnId: column.id,
+            expansions,
+            pivotMode: pivotMode ?? currentPivotMode,
+            onExpansionChange,
+            treeRef: virt.ref,
+            loading,
+            error,
+            filterIn: changes,
+            filterInChange: setChanges,
+            applyChangesImmediately,
+            ...virt.rootProps,
+        },
+        spacer: virt.spacer,
+        tree: virt.virtualTree,
+        apply,
+        reset,
+    };
 }

package/dist/filter-tree/hooks/use-tree-item.d.ts

@@ -1,8 +1,8 @@
 import type { FilterInFilterItem } from "../../+types.js";
 import type { TreeVirtualItem } from "../../tree-view/virtualized/make-virtual-tree.js";
 export declare function useTreeItem(item: TreeVirtualItem<FilterInFilterItem>): {
-  onCheckChange: (b?: boolean) => void;
-  isChecked: boolean;
-  isIndeterminate: boolean;
-  item: TreeVirtualItem<FilterInFilterItem>;
+    onCheckChange: (b?: boolean) => void;
+    isChecked: boolean;
+    isIndeterminate: boolean;
+    item: TreeVirtualItem<FilterInFilterItem>;
 };

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

@@ -2,108 +2,115 @@ import { useCallback, useMemo } from "react";
 import { useGrid } from "../../grid-provider/use-grid.js";
 import { useTreeContext } from "../context.js";
 function isSelectAll(item) {
-  return item.kind === "leaf" && item.leaf.data.id === "__LNG__SELECT_ALL";
+    return item.kind === "leaf" && item.leaf.data.id === "__LNG__SELECT_ALL";
 }
 export function useTreeItem(item) {
-  const { filter, filterChange, pivotMode, columnId, items, applyChangesImmediately } =
-    useTreeContext();
-  const grid = useGrid();
-  const itemValues = useMemo(() => {
-    if (item.kind === "leaf") return [item.leaf.data.value];
-    const leafItems = [];
-    const stack = [...item.children.values()];
-    while (stack.length) {
-      const c = stack.pop();
-      if (c.kind === "leaf") leafItems.push(c.leaf.data.value);
-      else stack.push(...c.children.values());
-    }
-    return leafItems;
-  }, [item]);
-  const isChecked = useMemo(() => {
-    if (filter.operator === "in") {
-      if (isSelectAll(item)) {
-        return items.every((c) => filter.value.has(c.value));
-      }
-      return itemValues.every((c) => filter.value.has(c));
-    } else {
-      if (isSelectAll(item)) {
-        return filter.value.size === 0;
-      }
-      return itemValues.every((c) => !filter.value.has(c));
-    }
-  }, [filter.operator, filter.value, item, itemValues, items]);
-  const isIndeterminate = useMemo(() => {
-    if (filter.operator === "in") {
-      if (isSelectAll(item)) {
-        return !isChecked && items.some((c) => filter.value.has(c));
-      }
-      return !isChecked && itemValues.some((c) => filter.value.has(c));
-    } else {
-      if (isSelectAll(item)) {
-        return !isChecked && filter.value.size > 0 && items.some((c) => !filter.value.has(c));
-      }
-      return !isChecked && itemValues.some((c) => !filter.value.has(c));
-    }
-  }, [item, isChecked, itemValues, filter, items]);
-  const onCheckChange = useCallback(
-    (b) => {
-      const checked = b ?? !isChecked;
-      let nextValue;
-      const operator = filter.operator;
-      if (isSelectAll(item)) {
-        if (operator === "in") {
-          nextValue = checked ? new Set(items.map((c) => c.value)) : new Set();
-        } else {
-          nextValue = checked ? new Set() : new Set(items.map((c) => c.value));
+    const { filter, filterChange, pivotMode, columnId, items, applyChangesImmediately } = useTreeContext();
+    const grid = useGrid();
+    const itemValues = useMemo(() => {
+        if (item.kind === "leaf")
+            return [item.leaf.data.value];
+        const leafItems = [];
+        const stack = [...item.children.values()];
+        while (stack.length) {
+            const c = stack.pop();
+            if (c.kind === "leaf")
+                leafItems.push(c.leaf.data.value);
+            else
+                stack.push(...c.children.values());
         }
-      } else {
-        nextValue = new Set(filter.value);
-        if (operator === "in") {
-          if (checked) itemValues.forEach((c) => nextValue.add(c));
-          else itemValues.forEach((c) => nextValue.delete(c));
-        } else {
-          if (checked) itemValues.forEach((c) => nextValue.delete(c));
-          else itemValues.forEach((c) => nextValue.add(c));
+        return leafItems;
+    }, [item]);
+    const isChecked = useMemo(() => {
+        if (filter.operator === "in") {
+            if (isSelectAll(item)) {
+                return items.every((c) => filter.value.has(c.value));
+            }
+            return itemValues.every((c) => filter.value.has(c));
         }
-      }
-      if (!applyChangesImmediately) {
-        filterChange({ kind: "in", operator, value: nextValue });
-      } else {
-        if (pivotMode) {
-          grid.state.columnPivotModel.set((prev) => {
-            return {
-              ...prev,
-              filtersIn: {
-                ...prev.filtersIn,
-                [columnId]: { kind: "in", operator, value: nextValue },
-              },
-            };
-          });
-        } else {
-          grid.state.filterInModel.set((prev) => ({
-            ...prev,
-            [columnId]: { kind: "in", operator, value: nextValue },
-          }));
+        else {
+            if (isSelectAll(item)) {
+                return filter.value.size === 0;
+            }
+            return itemValues.every((c) => !filter.value.has(c));
         }
-      }
-    },
-    [
-      isChecked,
-      item,
-      itemValues,
-      filter.operator,
-      filter.value,
-      applyChangesImmediately,
-      items,
-      filterChange,
-      pivotMode,
-      grid.state.columnPivotModel,
-      grid.state.filterInModel,
-      columnId,
-    ],
-  );
-  return useMemo(
-    () => ({ onCheckChange, isChecked, isIndeterminate, item }),
-    [isChecked, isIndeterminate, item, onCheckChange],
-  );
+    }, [filter.operator, filter.value, item, itemValues, items]);
+    const isIndeterminate = useMemo(() => {
+        if (filter.operator === "in") {
+            if (isSelectAll(item)) {
+                return !isChecked && items.some((c) => filter.value.has(c));
+            }
+            return !isChecked && itemValues.some((c) => filter.value.has(c));
+        }
+        else {
+            if (isSelectAll(item)) {
+                return (!isChecked && filter.value.size > 0 && items.some((c) => !filter.value.has(c)));
+            }
+            return !isChecked && itemValues.some((c) => !filter.value.has(c));
+        }
+    }, [item, isChecked, itemValues, filter, items]);
+    const onCheckChange = useCallback((b) => {
+        const checked = b ?? !isChecked;
+        let nextValue;
+        const operator = filter.operator;
+        if (isSelectAll(item)) {
+            if (operator === "in") {
+                nextValue = checked ? new Set(items.map((c) => c.value)) : new Set();
+            }
+            else {
+                nextValue = checked ? new Set() : new Set(items.map((c) => c.value));
+            }
+        }
+        else {
+            nextValue = new Set(filter.value);
+            if (operator === "in") {
+                if (checked)
+                    itemValues.forEach((c) => nextValue.add(c));
+                else
+                    itemValues.forEach((c) => nextValue.delete(c));
+            }
+            else {
+                if (checked)
+                    itemValues.forEach((c) => nextValue.delete(c));
+                else
+                    itemValues.forEach((c) => nextValue.add(c));
+            }
+        }
+        if (!applyChangesImmediately) {
+            filterChange({ kind: "in", operator, value: nextValue });
+        }
+        else {
+            if (pivotMode) {
+                grid.state.columnPivotModel.set((prev) => {
+                    return {
+                        ...prev,
+                        filtersIn: {
+                            ...prev.filtersIn,
+                            [columnId]: { kind: "in", operator, value: nextValue },
+                        },
+                    };
+                });
+            }
+            else {
+                grid.state.filterInModel.set((prev) => ({
+                    ...prev,
+                    [columnId]: { kind: "in", operator, value: nextValue },
+                }));
+            }
+        }
+    }, [
+        isChecked,
+        item,
+        itemValues,
+        filter.operator,
+        filter.value,
+        applyChangesImmediately,
+        items,
+        filterChange,
+        pivotMode,
+        grid.state.columnPivotModel,
+        grid.state.filterInModel,
+        columnId,
+    ]);
+    return useMemo(() => ({ onCheckChange, isChecked, isIndeterminate, item }), [isChecked, isIndeterminate, item, onCheckChange]);
 }

package/dist/filter-tree/inclusion-checkbox.d.ts

@@ -1,17 +1,9 @@
 import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
 export interface InclusionCheckbox {
-  readonly slot?: SlotComponent<{
-    checked: boolean;
-    indeterminate: boolean;
-    toggle: (s?: boolean) => void;
-  }>;
+    readonly slot?: SlotComponent<{
+        checked: boolean;
+        indeterminate: boolean;
+        toggle: (s?: boolean) => void;
+    }>;
 }
-export declare const InclusionCheckbox: import("react").ForwardRefExoticComponent<
-  Omit<
-    import("react").ClassAttributes<HTMLDivElement> &
-      import("react").HTMLAttributes<HTMLDivElement> &
-      InclusionCheckbox,
-    "ref"
-  > &
-    import("react").RefAttributes<HTMLDivElement>
->;
+export declare const InclusionCheckbox: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & InclusionCheckbox, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/filter-tree/inclusion-checkbox.js

@@ -2,23 +2,13 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { forwardRef } from "react";
 import { useTreeItemContext } from "./context";
-export const InclusionCheckbox = forwardRef(function InclusionCheckbox(
-  { slot, ...props },
-  forwarded,
-) {
-  const { isChecked, onCheckChange, isIndeterminate } = useTreeItemContext();
-  const rendered = useSlot({
-    props: [props],
-    ref: forwarded,
-    state: { checked: isChecked, toggle: onCheckChange, indeterminate: isIndeterminate },
-    slot:
-      slot ??
-      _jsx("input", {
-        type: "checkbox",
-        checked: isChecked,
-        "aria-label": "visibility toggle",
-        onChange: () => onCheckChange(),
-      }),
-  });
-  return rendered;
+export const InclusionCheckbox = forwardRef(function InclusionCheckbox({ slot, ...props }, forwarded) {
+    const { isChecked, onCheckChange, isIndeterminate } = useTreeItemContext();
+    const rendered = useSlot({
+        props: [props],
+        ref: forwarded,
+        state: { checked: isChecked, toggle: onCheckChange, indeterminate: isIndeterminate },
+        slot: slot ?? (_jsx("input", { type: "checkbox", checked: isChecked, "aria-label": "visibility toggle", onChange: () => onCheckChange() })),
+    });
+    return rendered;
 });

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

@@ -1,13 +1,5 @@
 import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
 export interface LabelProps {
-  readonly slot?: SlotComponent;
+    readonly slot?: SlotComponent;
 }
-export declare const Label: import("react").ForwardRefExoticComponent<
-  Omit<
-    import("react").ClassAttributes<HTMLDivElement> &
-      import("react").HTMLAttributes<HTMLDivElement> &
-      LabelProps,
-    "ref"
-  > &
-    import("react").RefAttributes<HTMLDivElement>
->;
+export declare const Label: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & LabelProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;