@1771technologies/lytenyte-pro 1.0.0-beta.36 → 1.0.0-beta.37

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

@@ -1,13 +1,5 @@
 import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
 export interface LabelProps {
-  readonly as?: SlotComponent;
+    readonly as?: 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>>;

package/dist/column-manager/label.js

@@ -3,15 +3,16 @@ import { useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { forwardRef, useMemo } from "react";
 import { useColumnItemContext } from "./context";
 export const Label = forwardRef(function Label({ as, ...props }, forwarded) {
-  const { item } = useColumnItemContext();
-  const label = useMemo(() => {
-    if (item.kind == "branch") return item.id.split("#").at(-2);
-    return item.data.name ?? item.data.id;
-  }, [item]);
-  const rendered = useSlot({
-    props: [{ children: label }, props],
-    ref: forwarded,
-    slot: as ?? _jsx("div", {}),
-  });
-  return rendered;
+    const { item } = useColumnItemContext();
+    const label = useMemo(() => {
+        if (item.kind == "branch")
+            return item.id.split("#").at(-2);
+        return item.data.name ?? item.data.id;
+    }, [item]);
+    const rendered = useSlot({
+        props: [{ children: label }, props],
+        ref: forwarded,
+        slot: as ?? _jsx("div", {}),
+    });
+    return rendered;
 });

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

@@ -1,14 +1,6 @@
 import type { Column } from "../+types";
 import type { PathLeaf } from "@1771technologies/lytenyte-shared";
 export interface ColumnManagerLeafProps {
-  readonly item: PathLeaf<Column<any>>;
+    readonly item: PathLeaf<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

@@ -6,65 +6,53 @@ 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`;
-  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.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;
-        // Flipped since our source is the one moving
-        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.data.id,
-        ref: forwarded,
-        onKeyDown: (ev) => {
-          props.onKeyDown?.(ev);
-          if (ev.key === " ") {
-            toggle();
-            ev.preventDefault();
-          }
-        },
-        "data-ln-column-manager-leaf": true,
-        "data-ln-column-id": item.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.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;
+                // Flipped since our source is the one moving
+                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.data.id, ref: forwarded, onKeyDown: (ev) => {
+                    props.onKeyDown?.(ev);
+                    if (ev.key === " ") {
+                        toggle();
+                        ev.preventDefault();
+                    }
+                }, "data-ln-column-manager-leaf": true, "data-ln-column-id": item.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 { PathBranch, PathLeaf } from "@1771technologies/lytenyte-shared";
 export interface MoveHandleProps {
-  readonly as?: SlotComponent;
-  readonly placeholder?: (p: {
-    columns: Column<any>[];
-    item: PathBranch<Column<any>> | PathLeaf<Column<any>>;
-  }) => ReactNode;
+    readonly as?: SlotComponent;
+    readonly placeholder?: (p: {
+        columns: Column<any>[];
+        item: PathBranch<Column<any>> | PathLeaf<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,60 +1,56 @@
 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(
-  { 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,
+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.data.joinPath.at(-1) : (item.data.name ?? item.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;
+        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.data.joinPath.at(-1) : (item.data.name ?? item.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/panel.d.ts

@@ -1,10 +1 @@
-export declare const Panel: import("react").ForwardRefExoticComponent<
-  Omit<
-    import("react").DetailedHTMLProps<
-      import("react").HTMLAttributes<HTMLUListElement>,
-      HTMLUListElement
-    >,
-    "ref"
-  > &
-    import("react").RefAttributes<HTMLUListElement>
->;
+export declare const Panel: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & import("react").RefAttributes<HTMLUListElement>>;

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

@@ -2,11 +2,7 @@ import type { PropsWithChildren } from "react";
 import type { Column, Grid } from "../+types";
 import type { PathBranch } from "@1771technologies/lytenyte-shared";
 export interface ColumnManagerRootProps<T> {
-  readonly grid: Grid<T>;
-  readonly lookup: Record<string, PathBranch<Column<any>>>;
+    readonly grid: Grid<T>;
+    readonly lookup: Record<string, PathBranch<Column<any>>>;
 }
-export declare function Root<T>({
-  grid,
-  lookup,
-  children,
-}: PropsWithChildren<ColumnManagerRootProps<T>>): import("react/jsx-runtime").JSX.Element;
+export declare function Root<T>({ grid, lookup, children }: PropsWithChildren<ColumnManagerRootProps<T>>): import("react/jsx-runtime").JSX.Element;

package/dist/column-manager/root.js

@@ -3,8 +3,5 @@ import { GridProvider } from "../grid-provider/provider";
 import { TreeRoot } from "../tree-view/root";
 import { branchLookupContext } from "./branch-lookup-context";
 export function Root({ grid, lookup, children }) {
-  return _jsx(branchLookupContext.Provider, {
-    value: lookup,
-    children: _jsx(GridProvider, { value: grid, children: _jsx(TreeRoot, { children: children }) }),
-  });
+    return (_jsx(branchLookupContext.Provider, { value: lookup, children: _jsx(GridProvider, { value: grid, children: _jsx(TreeRoot, { children: children }) }) }));
 }

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

@@ -1,12 +1,10 @@
 import type { Column, Grid } from "../+types";
 import type { PathBranch } from "@1771technologies/lytenyte-shared";
 export interface UseColumnManagerProps<T> {
-  readonly grid: Grid<T>;
+    readonly grid: Grid<T>;
+    readonly query?: string;
 }
-export declare function useColumnManager<T>({ grid }: UseColumnManagerProps<T>): {
-  items: (
-    | PathBranch<Column<T>>
-    | import("@1771technologies/lytenyte-shared").PathLeaf<Column<T>>
-  )[];
-  lookup: Record<string, PathBranch<Column<any>>>;
+export declare function useColumnManager<T>({ grid, query }: UseColumnManagerProps<T>): {
+    items: (PathBranch<Column<T>> | import("@1771technologies/lytenyte-shared").PathLeaf<Column<T>>)[];
+    lookup: Record<string, PathBranch<Column<any>>>;
 };

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

@@ -1,18 +1,24 @@
 import { useMemo } from "react";
 import { useTreeViewPaths } from "../tree-view/hooks/use-tree-view-paths";
-export function useColumnManager({ grid }) {
-  const columns = grid.state.columns.useValue();
-  const items = useTreeViewPaths(columns, true);
-  const branchLookup = useMemo(() => {
-    const stack = [...items];
-    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;
-  }, [items]);
-  return { items, lookup: branchLookup };
+export function useColumnManager({ grid, query }) {
+    const columns = grid.state.columns.useValue();
+    const filteredColumns = useMemo(() => {
+        if (!query)
+            return columns;
+        return columns.filter((c) => (c.name ?? c.id).toLowerCase().includes(query));
+    }, [columns, query]);
+    const items = useTreeViewPaths(filteredColumns, true);
+    const branchLookup = useMemo(() => {
+        const stack = [...items];
+        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;
+    }, [items]);
+    return { items, lookup: branchLookup };
 }

package/dist/column-manager/use-columns-from-context.d.ts

@@ -1,5 +1,3 @@
 import type { Column } from "../+types.js";
 import type { PathBranch, PathLeaf } from "@1771technologies/lytenyte-shared";
-export declare function useColumnsFromContext<T>(
-  item: PathBranch<Column<T>> | PathLeaf<Column<T>>,
-): Column<any>[] | Column<T>[];
+export declare function useColumnsFromContext<T>(item: PathBranch<Column<T>> | PathLeaf<Column<T>>): Column<any>[] | Column<T>[];

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.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.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.data];
-  }, [item, lookup]);
-  return columns;
+        return [item.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 as?: 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(
-  { 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;
+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,20 +2,12 @@ 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<{
-    expanded: boolean;
-    toggle: () => void;
-  }>;
+    readonly item: TreeVirtualBranch<FilterInFilterItem>;
+    readonly label: SlotComponent;
+    readonly labelWrap?: SlotComponent;
+    readonly expander?: SlotComponent<{
+        expanded: boolean;
+        toggle: () => void;
+    }>;
 }
-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>>;