@1771technologies/lytenyte-pro 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/column-manager/leaf.d.ts

@@ -1,14 +1,6 @@
 import type { TreeVirtualLeaf } from "../tree-view/virtualized/make-virtual-tree";
 import type { Column } from "../+types";
 export interface ColumnManagerLeafProps {
-  readonly item: TreeVirtualLeaf<Column<any>>;
+    readonly item: TreeVirtualLeaf<Column<any>>;
 }
-export declare const Leaf: import("react").ForwardRefExoticComponent<
-  Omit<
-    ColumnManagerLeafProps &
-      import("react").ClassAttributes<HTMLLIElement> &
-      import("react").LiHTMLAttributes<HTMLLIElement>,
-    "ref"
-  > &
-    import("react").RefAttributes<HTMLLIElement>
->;
+export declare const Leaf: import("react").ForwardRefExoticComponent<Omit<ColumnManagerLeafProps & import("react").ClassAttributes<HTMLLIElement> & import("react").LiHTMLAttributes<HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;

package/dist/column-manager/leaf.js

@@ -1,50 +1,56 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { forwardRef, useMemo } from "react";
+import { forwardRef, useCallback, useMemo } from "react";
 import { ColumnItemContext } from "./context";
 import { TreeLeaf } from "../tree-view/leaf";
 import { dragState, DropWrap } from "@1771technologies/lytenyte-dragon";
 import { useGrid } from "../grid-provider/use-grid";
+import { useColumnsFromContext } from "./use-columns-from-context";
 export const Leaf = forwardRef(function ColumnManagerLeaf({ item, ...props }, forwarded) {
-  const context = useMemo(() => {
-    return { item: item };
-  }, [item]);
-  const grid = useGrid();
-  const id = grid.state.gridId.useValue();
-  const accepted = `${id}/columns`;
-  return _jsx(ColumnItemContext.Provider, {
-    value: context,
-    children: _jsx(DropWrap, {
-      accepted: [accepted],
-      onEnter: (el) => {
-        const data = dragState.data.get()?.siteLocalData?.[accepted]?.at(-1);
-        if (!data) return;
-        const columns = [item.leaf.data];
-        const move = data.id;
-        if (columns.some((c) => c.id === move)) return;
-        const allColumns = grid.state.columns.get();
-        const moveIndex = allColumns.findIndex((c) => c.id === move);
-        if (moveIndex === -1) return;
-        const thisIndex = allColumns.findIndex((c) => c.id === columns[0].id);
-        const isBefore = thisIndex > moveIndex;
-        if (isBefore) {
-          el.setAttribute("data-ln-is-before", "true");
-        } else {
-          el.setAttribute("data-ln-is-after", "true");
-        }
-      },
-      onLeave: (el) => {
-        el.removeAttribute("data-ln-is-before");
-        el.removeAttribute("data-ln-is-after");
-      },
-      as: _jsx(TreeLeaf, {
-        ...props,
-        itemId: item.leaf.data.id,
-        ref: forwarded,
-        ...item.attrs,
-        style: { ...props.style, ...item.attrs.style },
-        "data-ln-column-manager-leaf": true,
-        "data-ln-column-id": item.leaf.data.id,
-      }),
-    }),
-  });
+    const context = useMemo(() => {
+        return { item: item };
+    }, [item]);
+    const grid = useGrid();
+    const id = grid.state.gridId.useValue();
+    const accepted = `${id}/columns`;
+    const base = grid.state.columnBase.useValue();
+    const columns = useColumnsFromContext(item);
+    const isVisible = useMemo(() => {
+        const allVisible = columns.every((c) => !(c.hide ?? base.hide));
+        return allVisible;
+    }, [base.hide, columns]);
+    const toggle = useCallback((s) => {
+        const next = s ?? isVisible;
+        grid.api.columnUpdate(Object.fromEntries(columns.map((c) => [c.id, { hide: next }])));
+    }, [columns, grid.api, isVisible]);
+    return (_jsx(ColumnItemContext.Provider, { value: context, children: _jsx(DropWrap, { accepted: [accepted], onEnter: (el) => {
+                const data = dragState.data
+                    .get()
+                    ?.siteLocalData?.[accepted]?.at(-1);
+                if (!data)
+                    return;
+                const columns = [item.leaf.data];
+                const move = data.id;
+                if (columns.some((c) => c.id === move))
+                    return;
+                const allColumns = grid.state.columns.get();
+                const moveIndex = allColumns.findIndex((c) => c.id === move);
+                if (moveIndex === -1)
+                    return;
+                const thisIndex = allColumns.findIndex((c) => c.id === columns[0].id);
+                const isBefore = thisIndex > moveIndex;
+                if (isBefore) {
+                    el.setAttribute("data-ln-is-before", "true");
+                }
+                else {
+                    el.setAttribute("data-ln-is-after", "true");
+                }
+            }, onLeave: (el) => {
+                el.removeAttribute("data-ln-is-before");
+                el.removeAttribute("data-ln-is-after");
+            }, as: _jsx(TreeLeaf, { ...props, itemId: item.leaf.data.id, ref: forwarded, ...item.attrs, style: { ...props.style, ...item.attrs.style }, onKeyDown: (ev) => {
+                    props.onKeyDown?.(ev);
+                    if (ev.key === " ") {
+                        toggle();
+                    }
+                }, "data-ln-column-manager-leaf": true, "data-ln-column-id": item.leaf.data.id }) }) }));
 });

package/dist/column-manager/move-handle.d.ts

@@ -3,18 +3,10 @@ import { type ReactNode } from "react";
 import type { Column } from "../+types";
 import type { TreeVirtualItem } from "../tree-view/virtualized/make-virtual-tree";
 export interface MoveHandleProps {
-  readonly slot?: SlotComponent;
-  readonly placeholder?: (p: {
-    columns: Column<any>[];
-    item: TreeVirtualItem<Column<any>>;
-  }) => ReactNode;
+    readonly as?: SlotComponent;
+    readonly placeholder?: (p: {
+        columns: Column<any>[];
+        item: TreeVirtualItem<Column<any>>;
+    }) => ReactNode;
 }
-export declare const MoveHandle: import("react").ForwardRefExoticComponent<
-  Omit<
-    import("react").ClassAttributes<HTMLDivElement> &
-      import("react").HTMLAttributes<HTMLDivElement> &
-      MoveHandleProps,
-    "ref"
-  > &
-    import("react").RefAttributes<HTMLDivElement>
->;
+export declare const MoveHandle: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & MoveHandleProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/column-manager/move-handle.js

@@ -1,62 +1,58 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useDraggable } from "@1771technologies/lytenyte-dragon";
-import { useCombinedRefs, useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { useCombinedRefs, useSlot, } from "@1771technologies/lytenyte-react-hooks";
 import { forwardRef, useMemo } from "react";
 import { useColumnItemContext } from "./context";
 import { useColumnsFromContext } from "./use-columns-from-context";
 import { useGrid } from "../grid-provider/use-grid";
-export const MoveHandle = forwardRef(function MoveHandle(
-  { slot, placeholder: Placeholder, ...props },
-  forwarded,
-) {
-  const item = useColumnItemContext().item;
-  const grid = useGrid();
-  const columns = useColumnsFromContext(item);
-  const base = grid.state.columnBase.useValue();
-  const isMovable = useMemo(() => {
-    return columns.every((c) => c.uiHints?.movable ?? base.uiHints?.movable);
-  }, [base.uiHints?.movable, columns]);
-  const {
-    dragProps: { ref, ...otherProps },
-  } = useDraggable({
-    getItems: () => {
-      return {
-        siteLocalData: {
-          [`${grid.state.gridId.get()}/columns`]: columns,
+export const MoveHandle = forwardRef(function MoveHandle({ as, placeholder: Placeholder, ...props }, forwarded) {
+    const item = useColumnItemContext().item;
+    const grid = useGrid();
+    const columns = useColumnsFromContext(item);
+    const base = grid.state.columnBase.useValue();
+    const isMovable = useMemo(() => {
+        return columns.every((c) => c.uiHints?.movable ?? base.uiHints?.movable);
+    }, [base.uiHints?.movable, columns]);
+    const { dragProps: { ref, ...otherProps }, } = useDraggable({
+        getItems: () => {
+            return {
+                siteLocalData: {
+                    [`${grid.state.gridId.get()}/columns`]: columns,
+                },
+            };
         },
-      };
-    },
-    onDrop: (p) => {
-      const move = p.dropElement.getAttribute("data-ln-column-id");
-      if (!move) return null;
-      if (columns.some((c) => c.id === move)) return;
-      const allColumns = grid.state.columns.get();
-      const moveIndex = allColumns.findIndex((c) => c.id === move);
-      if (moveIndex === -1) return;
-      const thisIndex = allColumns.findIndex((c) => c.id === columns[0].id);
-      const isBefore = thisIndex > moveIndex;
-      grid.api.columnMove({
-        moveColumns: columns,
-        moveTarget: move,
-        before: isBefore,
-      });
-    },
-    placeholder: () => {
-      if (Placeholder) return _jsx(Placeholder, { columns: columns, item: item });
-      return _jsx("div", {
-        children:
-          item.kind === "branch"
-            ? item.branch.data.joinPath.at(-1)
-            : (item.leaf.data.name ?? item.leaf.data.id),
-      });
-    },
-  });
-  const combined = useCombinedRefs(ref, forwarded);
-  const additionalProps = isMovable ? otherProps : {};
-  const renderer = useSlot({
-    props: [{ "aria-label": "Drag to move column" }, additionalProps, props],
-    ref: isMovable ? combined : forwarded,
-    slot: slot ?? _jsx("div", {}),
-  });
-  return renderer;
+        onDrop: (p) => {
+            const move = p.dropElement.getAttribute("data-ln-column-id");
+            if (!move)
+                return null;
+            if (columns.some((c) => c.id === move))
+                return;
+            const allColumns = grid.state.columns.get();
+            const moveIndex = allColumns.findIndex((c) => c.id === move);
+            if (moveIndex === -1)
+                return;
+            const thisIndex = allColumns.findIndex((c) => c.id === columns[0].id);
+            const isBefore = thisIndex > moveIndex;
+            grid.api.columnMove({
+                moveColumns: columns,
+                moveTarget: move,
+                before: isBefore,
+            });
+        },
+        placeholder: () => {
+            if (Placeholder)
+                return _jsx(Placeholder, { columns: columns, item: item });
+            return (_jsx("div", { children: item.kind === "branch"
+                    ? item.branch.data.joinPath.at(-1)
+                    : (item.leaf.data.name ?? item.leaf.data.id) }));
+        },
+    });
+    const combined = useCombinedRefs(ref, forwarded);
+    const additionalProps = isMovable ? otherProps : {};
+    const renderer = useSlot({
+        props: [{ "aria-label": "Drag to move column" }, additionalProps, props],
+        ref: isMovable ? combined : forwarded,
+        slot: as ?? _jsx("div", {}),
+    });
+    return renderer;
 });

package/dist/column-manager/root.d.ts

@@ -3,13 +3,7 @@ import type { Column, Grid } from "../+types";
 import type { UseColumnManagerReturn } from "./use-column-manager";
 import type { PathRoot } from "@1771technologies/lytenyte-shared";
 export type ColumnManagerRootProps<T> = UseColumnManagerReturn<T>["rootProps"] & {
-  readonly grid: Grid<T>;
-  readonly root: PathRoot<Column<any>>;
+    readonly grid: Grid<T>;
+    readonly root: PathRoot<Column<any>>;
 };
-export declare function Root<T>({
-  grid,
-  children,
-  treeRef,
-  root,
-  ...rootProps
-}: PropsWithChildren<ColumnManagerRootProps<T>>): import("react/jsx-runtime").JSX.Element;
+export declare function Root<T>({ grid, children, treeRef, root, ...rootProps }: PropsWithChildren<ColumnManagerRootProps<T>>): import("react/jsx-runtime").JSX.Element;

package/dist/column-manager/root.js

@@ -4,30 +4,17 @@ import { GridProvider } from "../grid-provider/provider";
 import { TreeRoot } from "../tree-view/root";
 import { branchLookupContext } from "./branch-lookup-context";
 export function Root({ grid, children, treeRef, root, ...rootProps }) {
-  const branchLookup = useMemo(() => {
-    const stack = [...root.children.values()];
-    const lookup = {};
-    while (stack.length) {
-      const item = stack.pop();
-      if (item.kind === "leaf") continue;
-      lookup[item.data.idOccurrence] = item;
-      stack.push(...item.children.values());
-    }
-    return lookup;
-  }, [root.children]);
-  return _jsx(branchLookupContext.Provider, {
-    value: branchLookup,
-    children: _jsx(GridProvider, {
-      value: grid,
-      children: _jsx(TreeRoot, {
-        selectMode: "multiple",
-        transitionEnter: 200,
-        transitionExit: 200,
-        expansionDefault: true,
-        ref: treeRef,
-        ...rootProps,
-        children: children,
-      }),
-    }),
-  });
+    const branchLookup = useMemo(() => {
+        const stack = [...root.children.values()];
+        const lookup = {};
+        while (stack.length) {
+            const item = stack.pop();
+            if (item.kind === "leaf")
+                continue;
+            lookup[item.data.idOccurrence] = item;
+            stack.push(...item.children.values());
+        }
+        return lookup;
+    }, [root.children]);
+    return (_jsx(branchLookupContext.Provider, { value: branchLookup, children: _jsx(GridProvider, { value: grid, children: _jsx(TreeRoot, { selectMode: "none", transitionEnter: 200, transitionExit: 200, expansionDefault: true, ref: treeRef, ...rootProps, children: children }) }) }));
 }

package/dist/column-manager/use-column-manager.d.ts

@@ -3,17 +3,21 @@ import type { Column, Grid } from "../+types.js";
 import type { TreeVirtualItem } from "../tree-view/virtualized/make-virtual-tree.js";
 import type { PathRoot } from "@1771technologies/lytenyte-shared";
 export interface UseColumnManagerReturn<T> {
-  readonly rootProps: {
+    readonly rootProps: {
+        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<Column<T>>;
+    };
+    readonly tree: TreeVirtualItem<Column<T>>[];
+    readonly spacer: JSX.Element;
+}
+export interface UseColumnManagerArgs<T> {
     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<Column<T>>;
-  };
-  readonly tree: TreeVirtualItem<Column<T>>[];
-  readonly spacer: JSX.Element;
+    readonly itemHeight?: number;
 }
-export declare function useColumnManager<T>(grid: Grid<T>): UseColumnManagerReturn<T>;
+export declare function useColumnManager<T>({ grid, itemHeight, }: UseColumnManagerArgs<T>): UseColumnManagerReturn<T>;

package/dist/column-manager/use-column-manager.js

@@ -1,24 +1,24 @@
 import { useState } from "react";
 import { useVirtualizedTree } from "../tree-view/virtualized/use-virtualized-tree.js";
-export function useColumnManager(grid) {
-  const [expansions, onExpansionChange] = useState({});
-  const columns = grid.state.columns.useValue();
-  const virt = useVirtualizedTree({
-    paths: columns,
-    expansions,
-    itemHeight: 24,
-    expansionDefault: true,
-    nonAdjacentPathTrees: true,
-  });
-  return {
-    rootProps: {
-      grid,
-      expansions,
-      onExpansionChange,
-      treeRef: virt.ref,
-      ...virt.rootProps,
-    },
-    spacer: virt.spacer,
-    tree: virt.virtualTree,
-  };
+export function useColumnManager({ grid, itemHeight = 24, }) {
+    const [expansions, onExpansionChange] = useState({});
+    const columns = grid.state.columns.useValue();
+    const virt = useVirtualizedTree({
+        paths: columns,
+        expansions,
+        itemHeight,
+        expansionDefault: true,
+        nonAdjacentPathTrees: true,
+    });
+    return {
+        rootProps: {
+            grid,
+            expansions,
+            onExpansionChange,
+            treeRef: virt.ref,
+            ...virt.rootProps,
+        },
+        spacer: virt.spacer,
+        tree: virt.virtualTree,
+    };
 }

package/dist/column-manager/use-columns-from-context.js

@@ -1,23 +1,23 @@
 import { useMemo } from "react";
 import { useBranchLookup } from "./branch-lookup-context.js";
 export function useColumnsFromContext(item) {
-  const lookup = useBranchLookup();
-  const columns = useMemo(() => {
-    if (item.kind === "branch") {
-      const allChildren = [];
-      const branch = lookup[item.branch.data.idOccurrence];
-      const stack = [...branch.children.values()];
-      while (stack.length) {
-        const p = stack.pop();
-        if (p.kind === "branch") {
-          stack.push(...p.children.values());
-          continue;
+    const lookup = useBranchLookup();
+    const columns = useMemo(() => {
+        if (item.kind === "branch") {
+            const allChildren = [];
+            const branch = lookup[item.branch.data.idOccurrence];
+            const stack = [...branch.children.values()];
+            while (stack.length) {
+                const p = stack.pop();
+                if (p.kind === "branch") {
+                    stack.push(...p.children.values());
+                    continue;
+                }
+                allChildren.push(p.data);
+            }
+            return allChildren;
         }
-        allChildren.push(p.data);
-      }
-      return allChildren;
-    }
-    return [item.leaf.data];
-  }, [item, lookup]);
-  return columns;
+        return [item.leaf.data];
+    }, [item, lookup]);
+    return columns;
 }

package/dist/column-manager/visibility-checkbox.d.ts

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

package/dist/column-manager/visibility-checkbox.js

@@ -4,40 +4,27 @@ import { useColumnItemContext } from "./context";
 import { forwardRef, useCallback, useMemo } from "react";
 import { useGrid } from "../grid-provider/use-grid";
 import { useColumnsFromContext } from "./use-columns-from-context";
-export const VisibilityCheckbox = forwardRef(function VisibilityCheckbox(
-  { slot, ...props },
-  forwarded,
-) {
-  const { item } = useColumnItemContext();
-  const grid = useGrid();
-  const base = grid.state.columnBase.useValue();
-  const columns = useColumnsFromContext(item);
-  const [isVisible, isIndeterminate] = useMemo(() => {
-    const allVisible = columns.every((c) => !(c.hide ?? base.hide));
-    const someVisible = columns.some((c) => !(c.hide ?? base.hide));
-    return [allVisible, !allVisible && someVisible];
-  }, [base.hide, columns]);
-  const toggle = useCallback(
-    (s) => {
-      const next = s ?? isVisible;
-      grid.api.columnUpdate(Object.fromEntries(columns.map((c) => [c.id, { hide: next }])));
-    },
-    [columns, grid.api, isVisible],
-  );
-  const rendered = useSlot({
-    props: [props],
-    ref: forwarded,
-    slot:
-      slot ??
-      _jsx("input", {
-        type: "checkbox",
-        checked: isVisible,
-        "aria-label": "visibility toggle",
-        onChange: () => {
-          toggle();
-        },
-      }),
-    state: { visible: isVisible, indeterminate: isIndeterminate, toggle },
-  });
-  return rendered;
+export const VisibilityCheckbox = forwardRef(function VisibilityCheckbox({ as, ...props }, forwarded) {
+    const { item } = useColumnItemContext();
+    const grid = useGrid();
+    const base = grid.state.columnBase.useValue();
+    const columns = useColumnsFromContext(item);
+    const [isVisible, isIndeterminate] = useMemo(() => {
+        const allVisible = columns.every((c) => !(c.hide ?? base.hide));
+        const someVisible = columns.some((c) => !(c.hide ?? base.hide));
+        return [allVisible, !allVisible && someVisible];
+    }, [base.hide, columns]);
+    const toggle = useCallback((s) => {
+        const next = s ?? isVisible;
+        grid.api.columnUpdate(Object.fromEntries(columns.map((c) => [c.id, { hide: next }])));
+    }, [columns, grid.api, isVisible]);
+    const rendered = useSlot({
+        props: [props],
+        ref: forwarded,
+        slot: as ?? (_jsx("input", { type: "checkbox", checked: isVisible, "aria-label": "visibility toggle", onChange: () => {
+                toggle();
+            } })),
+        state: { visible: isVisible, indeterminate: isIndeterminate, toggle },
+    });
+    return rendered;
 });

package/dist/context.d.ts

@@ -1,10 +1,10 @@
 import type { Grid } from "./+types";
 import type { InternalAtoms } from "./state/+types";
 export interface GridRootContext {
-  readonly ref: (el: HTMLElement | SVGElement | null) => void;
-  readonly grid: Grid<any> & {
-    internal: InternalAtoms;
-  };
+    readonly ref: (el: HTMLElement | SVGElement | null) => void;
+    readonly grid: Grid<any> & {
+        internal: InternalAtoms;
+    };
 }
 export declare const RootProvider: import("react").Provider<GridRootContext>;
 export declare const useGridRoot: () => GridRootContext;

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

@@ -2,17 +2,9 @@ import type { TreeVirtualBranch } from "../tree-view/virtualized/make-virtual-tr
 import type { FilterInFilterItem } from "../+types";
 import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
 export interface FilterTreeBranch {
-  readonly item: TreeVirtualBranch<FilterInFilterItem>;
-  readonly label: SlotComponent;
-  readonly labelWrap?: SlotComponent;
-  readonly expander?: SlotComponent;
+    readonly item: TreeVirtualBranch<FilterInFilterItem>;
+    readonly label: SlotComponent;
+    readonly labelWrap?: SlotComponent;
+    readonly expander?: SlotComponent;
 }
-export declare const Branch: import("react").ForwardRefExoticComponent<
-  Omit<
-    FilterTreeBranch &
-      import("react").ClassAttributes<HTMLLIElement> &
-      import("react").LiHTMLAttributes<HTMLLIElement>,
-    "ref"
-  > &
-    import("react").RefAttributes<HTMLLIElement>
->;
+export declare const Branch: import("react").ForwardRefExoticComponent<Omit<FilterTreeBranch & import("react").ClassAttributes<HTMLLIElement> & import("react").LiHTMLAttributes<HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;

package/dist/filter-tree/branch.js

@@ -5,27 +5,17 @@ import { useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { FilterTreeItemContext } from "./context";
 import { useTreeItem } from "./hooks/use-tree-item";
 export const Branch = forwardRef(function Branch({ item, labelWrap, label, ...props }, forwarded) {
-  const value = useTreeItem(item);
-  const labelSlot = useSlot({
-    slot: labelWrap ?? _jsx("div", {}),
-    props: [
-      {
-        onClick: () => value.onCheckChange(),
-      },
-    ],
-  });
-  return _jsx(FilterTreeItemContext.Provider, {
-    value: value,
-    children: _jsx(TreeBranch, {
-      ...props,
-      itemId: item.branch.data.idOccurrence,
-      ref: forwarded,
-      ...item.attrs,
-      onKeyDown: (ev) => {
-        if (ev.key === " ") value.onCheckChange();
-      },
-      label: label,
-      labelWrap: labelSlot,
-    }),
-  });
+    const value = useTreeItem(item);
+    const labelSlot = useSlot({
+        slot: labelWrap ?? _jsx("div", {}),
+        props: [
+            {
+                onClick: () => value.onCheckChange(),
+            },
+        ],
+    });
+    return (_jsx(FilterTreeItemContext.Provider, { value: value, children: _jsx(TreeBranch, { ...props, itemId: item.branch.data.idOccurrence, ref: forwarded, ...item.attrs, onKeyDown: (ev) => {
+                if (ev.key === " ")
+                    value.onCheckChange();
+            }, label: label, labelWrap: labelSlot }) }));
 });