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

package/dist/filter-tree/label.js

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

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

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

package/dist/filter-tree/leaf.js

@@ -4,19 +4,9 @@ import { TreeLeaf } from "../tree-view/leaf";
 import { FilterTreeItemContext } from "./context";
 import { useTreeItem } from "./hooks/use-tree-item";
 export const Leaf = forwardRef(function Leaf({ item, ...props }, forwarded) {
-  const value = useTreeItem(item);
-  return _jsx(FilterTreeItemContext.Provider, {
-    value: value,
-    children: _jsx(TreeLeaf, {
-      ...props,
-      itemId: item.leaf.data.id,
-      ref: forwarded,
-      ...item.attrs,
-      style: { ...props.style, ...item.attrs.style },
-      onClick: () => value.onCheckChange(),
-      onKeyDown: (ev) => {
-        if (ev.key === " ") value.onCheckChange();
-      },
-    }),
-  });
+    const value = useTreeItem(item);
+    return (_jsx(FilterTreeItemContext.Provider, { value: value, children: _jsx(TreeLeaf, { ...props, itemId: item.leaf.data.id, ref: forwarded, ...item.attrs, style: { ...props.style, ...item.attrs.style }, onClick: () => value.onCheckChange(), onKeyDown: (ev) => {
+                if (ev.key === " ")
+                    value.onCheckChange();
+            } }) }));
 });

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

@@ -3,27 +3,11 @@ import type { Grid } from "../+types";
 import type { UseTreeFilterReturn } from "./hooks/use-filter-tree";
 import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
 export type FilterTreeRootProps<T> = UseTreeFilterReturn<T>["rootProps"] & {
-  readonly grid: Grid<T>;
-  readonly slotLoading?: SlotComponent;
-  readonly slotError?: SlotComponent<{
-    error: any;
-    refetch: () => void;
-  }>;
+    readonly grid: Grid<T>;
+    readonly slotLoading?: SlotComponent;
+    readonly slotError?: SlotComponent<{
+        error: any;
+        refetch: () => void;
+    }>;
 };
-export declare function Root<T>({
-  grid,
-  treeRef,
-  filterIn,
-  pivotMode,
-  columnId,
-  children,
-  error,
-  loading,
-  slotError,
-  slotLoading,
-  fetchItems,
-  items,
-  applyChangesImmediately,
-  filterInChange,
-  ...rootProps
-}: PropsWithChildren<FilterTreeRootProps<T>>): import("react/jsx-runtime").JSX.Element;
+export declare function Root<T>({ grid, treeRef, filterIn, pivotMode, columnId, children, error, loading, slotError, slotLoading, fetchItems, items, applyChangesImmediately, filterInChange, ...rootProps }: PropsWithChildren<FilterTreeRootProps<T>>): import("react/jsx-runtime").JSX.Element;

package/dist/filter-tree/root.js

@@ -4,55 +4,27 @@ import { GridProvider } from "../grid-provider/provider";
 import { TreeRoot } from "../tree-view/root";
 import { FilterTreeContext } from "./context";
 import { useSlot } from "@1771technologies/lytenyte-react-hooks";
-export function Root({
-  grid,
-  treeRef,
-  filterIn,
-  pivotMode,
-  columnId,
-  children,
-  error,
-  loading,
-  slotError,
-  slotLoading,
-  fetchItems,
-  items,
-  applyChangesImmediately,
-  filterInChange,
-  ...rootProps
-}) {
-  const value = useMemo(() => {
-    return {
-      filter: filterIn,
-      filterChange: filterInChange,
-      pivotMode,
-      columnId,
-      items,
-      applyChangesImmediately,
-    };
-  }, [applyChangesImmediately, columnId, filterIn, filterInChange, items, pivotMode]);
-  const loadingSlot = useSlot({
-    slot: slotLoading ?? _jsx("div", { children: "Loading..." }),
-  });
-  const errorSlot = useSlot({
-    slot: slotError ?? _jsx("div", { children: "Error Occurred Fetching" }),
-    state: { error, refetch: fetchItems },
-  });
-  if (loading) return loadingSlot;
-  if (error) return errorSlot;
-  return _jsx(GridProvider, {
-    value: grid,
-    children: _jsx(FilterTreeContext.Provider, {
-      value: value,
-      children: _jsx(TreeRoot, {
-        selectMode: "none",
-        transitionEnter: 200,
-        transitionExit: 200,
-        expansionDefault: true,
-        ref: treeRef,
-        ...rootProps,
-        children: children,
-      }),
-    }),
-  });
+export function Root({ grid, treeRef, filterIn, pivotMode, columnId, children, error, loading, slotError, slotLoading, fetchItems, items, applyChangesImmediately, filterInChange, ...rootProps }) {
+    const value = useMemo(() => {
+        return {
+            filter: filterIn,
+            filterChange: filterInChange,
+            pivotMode,
+            columnId,
+            items,
+            applyChangesImmediately,
+        };
+    }, [applyChangesImmediately, columnId, filterIn, filterInChange, items, pivotMode]);
+    const loadingSlot = useSlot({
+        slot: slotLoading ?? _jsx("div", { children: "Loading..." }),
+    });
+    const errorSlot = useSlot({
+        slot: slotError ?? _jsx("div", { children: "Error Occurred Fetching" }),
+        state: { error, refetch: fetchItems },
+    });
+    if (loading)
+        return loadingSlot;
+    if (error)
+        return errorSlot;
+    return (_jsx(GridProvider, { value: grid, children: _jsx(FilterTreeContext.Provider, { value: value, children: _jsx(TreeRoot, { selectMode: "none", transitionEnter: 200, transitionExit: 200, expansionDefault: true, ref: treeRef, ...rootProps, children: children }) }) }));
 }

package/dist/grid-box/+types.d.ts

@@ -1,13 +1,13 @@
 import type { ReactNode } from "react";
 import type { DropEventParams } from "../+types.js";
 export interface GridBoxItem<T = any> {
-  readonly id: string;
-  readonly label: string;
-  readonly data: T;
-  readonly dragData: Record<string, any>;
-  readonly draggable: boolean;
-  readonly dragPlaceholder?: () => ReactNode;
-  readonly onDrop: (p: DropEventParams) => void;
-  readonly onAction: () => void;
-  readonly onDelete: () => void;
+    readonly id: string;
+    readonly label: string;
+    readonly data: T;
+    readonly dragData: Record<string, any>;
+    readonly draggable: boolean;
+    readonly dragPlaceholder?: () => ReactNode;
+    readonly onDrop: (p: DropEventParams) => void;
+    readonly onAction: () => void;
+    readonly onDelete: () => void;
 }

package/dist/grid-box/context.d.ts

@@ -1,8 +1,8 @@
 import type { DropEventParams } from "../+types.js";
 interface GridBoxContextValue {
-  readonly accepted: string[];
-  readonly orientation: "horizontal" | "vertical";
-  readonly onRootDrop: (p: DropEventParams) => void;
+    readonly accepted: string[];
+    readonly orientation: "horizontal" | "vertical";
+    readonly onRootDrop: (p: DropEventParams) => void;
 }
 export declare const GridBoxContext: import("react").Context<GridBoxContextValue>;
 export declare const useGridBoxContext: () => GridBoxContextValue;

package/dist/grid-box/grid-box.d.ts

@@ -3,30 +3,10 @@ import { useAggregationBoxItems } from "./use-aggregation-box-items";
 import { useColumnBoxItems } from "./use-column-box-items";
 import { useRowGroupBoxItems } from "./use-row-group-box-items";
 export declare const GridBox: {
-  Root: typeof GridBoxRoot;
-  Panel: import("react").ForwardRefExoticComponent<
-    Omit<
-      Omit<
-        import("react").DetailedHTMLProps<
-          import("react").HTMLAttributes<HTMLDivElement>,
-          HTMLDivElement
-        >,
-        "onDrop"
-      >,
-      "ref"
-    > &
-      import("react").RefAttributes<HTMLDivElement>
-  >;
-  Item: import("react").ForwardRefExoticComponent<
-    Omit<
-      import("react").ClassAttributes<HTMLDivElement> &
-        import("react").HTMLAttributes<HTMLDivElement> &
-        import("./item").GridBoxItemProps,
-      "ref"
-    > &
-      import("react").RefAttributes<HTMLDivElement>
-  >;
-  useColumnBoxItems: typeof useColumnBoxItems;
-  useRowGroupBoxItems: typeof useRowGroupBoxItems;
-  useAggregationBoxItems: typeof useAggregationBoxItems;
+    Root: typeof GridBoxRoot;
+    Panel: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "onDrop">, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    Item: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & import("./item").GridBoxItemProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+    useColumnBoxItems: typeof useColumnBoxItems;
+    useRowGroupBoxItems: typeof useRowGroupBoxItems;
+    useAggregationBoxItems: typeof useAggregationBoxItems;
 };

package/dist/grid-box/grid-box.js

@@ -5,10 +5,10 @@ import { useAggregationBoxItems } from "./use-aggregation-box-items";
 import { useColumnBoxItems } from "./use-column-box-items";
 import { useRowGroupBoxItems } from "./use-row-group-box-items";
 export const GridBox = {
-  Root: GridBoxRoot,
-  Panel: GridBoxPanel,
-  Item: BoxItem,
-  useColumnBoxItems,
-  useRowGroupBoxItems,
-  useAggregationBoxItems,
+    Root: GridBoxRoot,
+    Panel: GridBoxPanel,
+    Item: BoxItem,
+    useColumnBoxItems,
+    useRowGroupBoxItems,
+    useAggregationBoxItems,
 };

package/dist/grid-box/item.d.ts

@@ -1,15 +1,7 @@
 import type { GridBoxItem } from "./+types";
 import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
 export interface GridBoxItemProps {
-  readonly item: GridBoxItem;
-  readonly itemWrap?: SlotComponent;
+    readonly item: GridBoxItem;
+    readonly itemWrap?: SlotComponent;
 }
-export declare const BoxItem: import("react").ForwardRefExoticComponent<
-  Omit<
-    import("react").ClassAttributes<HTMLDivElement> &
-      import("react").HTMLAttributes<HTMLDivElement> &
-      GridBoxItemProps,
-    "ref"
-  > &
-    import("react").RefAttributes<HTMLDivElement>
->;
+export declare const BoxItem: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & GridBoxItemProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/grid-box/item.js

@@ -2,35 +2,32 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
 import { Item } from "../listbox/item";
 import { DropWrap, useDraggable } from "@1771technologies/lytenyte-dragon";
-import { useCombinedRefs, useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { useCombinedRefs, useSlot, } from "@1771technologies/lytenyte-react-hooks";
 import { useGridBoxContext } from "./context";
 export const BoxItem = forwardRef(function BoxItem({ item, itemWrap, ...props }, forwarded) {
-  const { accepted } = useGridBoxContext();
-  const { dragProps } = useDraggable({
-    getItems: () => {
-      return {
-        siteLocalData: item.dragData,
-      };
-    },
-    placeholder: item.dragPlaceholder,
-  });
-  const ref = useCombinedRefs(forwarded, dragProps.ref);
-  const extraProps = item.draggable ? { ...dragProps, ref } : { ref: forwarded };
-  const renderer = useSlot({
-    props: [
-      {
-        children: _jsx(Item, {
-          ...props,
-          ...extraProps,
-          onKeyDown: (ev) => {
-            if (ev.key === " ") item.onAction?.();
-            if (ev.key === "Backspace" || ev.key === "Delete") item.onDelete?.();
-          },
-          onClick: () => item.onAction(),
-        }),
-      },
-    ],
-    slot: itemWrap ?? _jsx("div", {}),
-  });
-  return _jsx(DropWrap, { accepted: accepted, onDrop: item.onDrop, as: renderer });
+    const { accepted } = useGridBoxContext();
+    const { dragProps } = useDraggable({
+        getItems: () => {
+            return {
+                siteLocalData: item.dragData,
+            };
+        },
+        placeholder: item.dragPlaceholder,
+    });
+    const ref = useCombinedRefs(forwarded, dragProps.ref);
+    const extraProps = item.draggable ? { ...dragProps, ref } : { ref: forwarded };
+    const renderer = useSlot({
+        props: [
+            {
+                children: (_jsx(Item, { ...props, ...extraProps, onKeyDown: (ev) => {
+                        if (ev.key === " ")
+                            item.onAction?.();
+                        if (ev.key === "Backspace" || ev.key === "Delete")
+                            item.onDelete?.();
+                    }, onClick: () => item.onAction() })),
+            },
+        ],
+        slot: itemWrap ?? _jsx("div", {}),
+    });
+    return _jsx(DropWrap, { accepted: accepted, onDrop: item.onDrop, as: renderer });
 });

package/dist/grid-box/panel.d.ts

@@ -1,13 +1 @@
-export declare const GridBoxPanel: import("react").ForwardRefExoticComponent<
-  Omit<
-    Omit<
-      import("react").DetailedHTMLProps<
-        import("react").HTMLAttributes<HTMLDivElement>,
-        HTMLDivElement
-      >,
-      "onDrop"
-    >,
-    "ref"
-  > &
-    import("react").RefAttributes<HTMLDivElement>
->;
+export declare const GridBoxPanel: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "onDrop">, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/grid-box/panel.js

@@ -4,13 +4,6 @@ import { Panel } from "../listbox/panel";
 import { DropWrap } from "@1771technologies/lytenyte-dragon";
 import { useGridBoxContext } from "./context";
 export const GridBoxPanel = forwardRef(function GridBoxPanel(props, forwarded) {
-  const ctx = useGridBoxContext();
-  return _jsx(DropWrap, {
-    ...props,
-    accepted: ctx.accepted,
-    "data-ln-orientation": ctx.orientation,
-    onDrop: ctx.onRootDrop,
-    ref: forwarded,
-    as: _jsx(Panel, {}),
-  });
+    const ctx = useGridBoxContext();
+    return (_jsx(DropWrap, { ...props, accepted: ctx.accepted, "data-ln-orientation": ctx.orientation, onDrop: ctx.onRootDrop, ref: forwarded, as: _jsx(Panel, {}) }));
 });

package/dist/grid-box/root.d.ts

@@ -1,15 +1,9 @@
 import { type PropsWithChildren } from "react";
 import type { DropEventParams, Grid } from "../+types";
 export interface GridBoxRootProps<T> {
-  readonly orientation?: "vertical" | "horizontal";
-  readonly onRootDrop: (p: DropEventParams) => void;
-  readonly accepted: string[];
-  readonly grid: Grid<T>;
+    readonly orientation?: "vertical" | "horizontal";
+    readonly onRootDrop: (p: DropEventParams) => void;
+    readonly accepted: string[];
+    readonly grid: Grid<T>;
 }
-export declare function GridBoxRoot<T>({
-  grid,
-  orientation,
-  accepted,
-  onRootDrop,
-  children,
-}: PropsWithChildren<GridBoxRootProps<T>>): import("react/jsx-runtime").JSX.Element;
+export declare function GridBoxRoot<T>({ grid, orientation, accepted, onRootDrop, children, }: PropsWithChildren<GridBoxRootProps<T>>): import("react/jsx-runtime").JSX.Element;

package/dist/grid-box/root.js

@@ -3,15 +3,6 @@ import { useMemo } from "react";
 import { Root } from "../listbox/root";
 import { GridProvider } from "../grid-provider/provider";
 import { GridBoxContext } from "./context";
-export function GridBoxRoot({ grid, orientation = "vertical", accepted, onRootDrop, children }) {
-  return _jsx(GridProvider, {
-    value: grid,
-    children: _jsx(GridBoxContext.Provider, {
-      value: useMemo(
-        () => ({ accepted, orientation, onRootDrop }),
-        [accepted, onRootDrop, orientation],
-      ),
-      children: _jsx(Root, { orientation: orientation, children: children }),
-    }),
-  });
+export function GridBoxRoot({ grid, orientation = "vertical", accepted, onRootDrop, children, }) {
+    return (_jsx(GridProvider, { value: grid, children: _jsx(GridBoxContext.Provider, { value: useMemo(() => ({ accepted, orientation, onRootDrop }), [accepted, onRootDrop, orientation]), children: _jsx(Root, { orientation: orientation, children: children }) }) }));
 }

package/dist/grid-box/use-aggregation-box-items.d.ts

@@ -1,21 +1,18 @@
 import type { AggModelFn, DropEventParams, Grid } from "../+types.js";
 import type { GridBoxItem } from "./+types.js";
 export interface UseAggregationBoxItemsProps<T> {
-  readonly grid: Grid<T>;
-  readonly orientation?: "horizontal" | "vertical";
+    readonly grid: Grid<T>;
+    readonly orientation?: "horizontal" | "vertical";
 }
-export declare function useAggregationBoxItems<T>({
-  grid,
-  orientation,
-}: UseAggregationBoxItemsProps<T>): {
-  rootProps: {
-    accepted: string[];
-    onRootDrop: (p: DropEventParams) => void;
-    orientation: "horizontal" | "vertical" | undefined;
-    grid: Grid<T>;
-  };
-  items: GridBoxItem<{
-    id: string;
-    agg: AggModelFn<T>;
-  }>[];
+export declare function useAggregationBoxItems<T>({ grid, orientation }: UseAggregationBoxItemsProps<T>): {
+    rootProps: {
+        accepted: string[];
+        onRootDrop: (p: DropEventParams) => void;
+        orientation: "horizontal" | "vertical" | undefined;
+        grid: Grid<T>;
+    };
+    items: GridBoxItem<{
+        id: string;
+        agg: AggModelFn<T>;
+    }>[];
 };

package/dist/grid-box/use-aggregation-box-items.js

@@ -1,59 +1,60 @@
 import { useMemo } from "react";
 import { useEvent } from "@1771technologies/lytenyte-react-hooks";
 export function useAggregationBoxItems({ grid, orientation }) {
-  const model = grid.state.aggModel.useValue();
-  const gridId = grid.state.gridId.useValue();
-  const items = useMemo(() => {
-    const items = Object.entries(model).map(([id, agg]) => {
-      const column = grid.api.columnById(id);
-      const name = column?.name ?? column?.id ?? id;
-      const fn = typeof agg.fn === "string" ? agg.fn : "Fn(x)";
-      return {
-        draggable: false,
-        id,
-        data: { id, agg },
-        dragData: {},
-        label: `${name} ${fn}`,
-        onAction: () => {},
-        onDelete: () => {
-          grid.state.aggModel.set((prev) => {
-            const next = { ...prev };
-            delete next[id];
-            return next;
-          });
-        },
-        onDrop: () => {},
-        dragPlaceholder: undefined,
-      };
+    const model = grid.state.aggModel.useValue();
+    const gridId = grid.state.gridId.useValue();
+    const items = useMemo(() => {
+        const items = Object.entries(model).map(([id, agg]) => {
+            const column = grid.api.columnById(id);
+            const name = column?.name ?? column?.id ?? id;
+            const fn = typeof agg.fn === "string" ? agg.fn : "Fn(x)";
+            return {
+                draggable: false,
+                id,
+                data: { id, agg },
+                dragData: {},
+                label: `${name} ${fn}`,
+                onAction: () => { },
+                onDelete: () => {
+                    grid.state.aggModel.set((prev) => {
+                        const next = { ...prev };
+                        delete next[id];
+                        return next;
+                    });
+                },
+                onDrop: () => { },
+                dragPlaceholder: undefined,
+            };
+        });
+        return items;
+    }, [model, grid.api, grid.state.aggModel]);
+    const onRootDrop = useEvent((p) => {
+        const aggId = `${gridId}-agg`;
+        const c = p.state.siteLocalData?.[aggId];
+        if (!c)
+            return;
+        const current = model[c.id];
+        if (!current) {
+            const base = grid.state.columnBase.get();
+            const agg = c.uiHints?.aggDefault ??
+                c.uiHints?.aggsAllowed?.[0] ??
+                base.uiHints?.aggDefault ??
+                base.uiHints?.aggsAllowed?.[0];
+            if (!agg)
+                return;
+            const next = { fn: agg };
+            grid.state.aggModel.set((prev) => ({ ...prev, [c.id]: next }));
+        }
     });
-    return items;
-  }, [model, grid.api, grid.state.aggModel]);
-  const onRootDrop = useEvent((p) => {
-    const aggId = `${gridId}-agg`;
-    const c = p.state.siteLocalData?.[aggId];
-    if (!c) return;
-    const current = model[c.id];
-    if (!current) {
-      const base = grid.state.columnBase.get();
-      const agg =
-        c.uiHints?.aggDefault ??
-        c.uiHints?.aggsAllowed?.[0] ??
-        base.uiHints?.aggDefault ??
-        base.uiHints?.aggsAllowed?.[0];
-      if (!agg) return;
-      const next = { fn: agg };
-      grid.state.aggModel.set((prev) => ({ ...prev, [c.id]: next }));
-    }
-  });
-  return useMemo(() => {
-    return {
-      rootProps: {
-        accepted: [`${gridId}-agg`],
-        onRootDrop,
-        orientation,
-        grid,
-      },
-      items,
-    };
-  }, [grid, gridId, items, onRootDrop, orientation]);
+    return useMemo(() => {
+        return {
+            rootProps: {
+                accepted: [`${gridId}-agg`],
+                onRootDrop,
+                orientation,
+                grid,
+            },
+            items,
+        };
+    }, [grid, gridId, items, onRootDrop, orientation]);
 }

package/dist/grid-box/use-column-box-items.d.ts

@@ -2,40 +2,30 @@ import { type ReactNode } from "react";
 import type { Column, DropEventParams, Grid } from "../+types.js";
 import type { GridBoxItem } from "./+types.js";
 export interface OnDropParams<T> {
-  readonly target: Column<T>;
-  readonly src: Column<T>;
-  readonly isBefore: boolean;
+    readonly target: Column<T>;
+    readonly src: Column<T>;
+    readonly isBefore: boolean;
 }
 export interface OnRootDropParams<T> {
-  readonly column: Column<T>;
+    readonly column: Column<T>;
 }
 export interface UseColumnBoxItemArgs<T> {
-  readonly grid: Grid<T>;
-  readonly orientation?: "horizontal" | "vertical";
-  readonly draggable?: boolean;
-  readonly itemFilter?: (c: Column<T>) => boolean;
-  readonly onRootDrop?: (p: OnRootDropParams<T>) => void;
-  readonly onDrop?: (p: OnDropParams<T>) => void;
-  readonly onAction?: (c: Column<T>) => void;
-  readonly onDelete?: (c: Column<T>) => void;
-  readonly dragPlaceholder?: (c: Column<T>) => ReactNode;
+    readonly grid: Grid<T>;
+    readonly orientation?: "horizontal" | "vertical";
+    readonly draggable?: boolean;
+    readonly itemFilter?: (c: Column<T>) => boolean;
+    readonly onRootDrop?: (p: OnRootDropParams<T>) => void;
+    readonly onDrop?: (p: OnDropParams<T>) => void;
+    readonly onAction?: (c: Column<T>) => void;
+    readonly onDelete?: (c: Column<T>) => void;
+    readonly dragPlaceholder?: (c: Column<T>) => ReactNode;
 }
-export declare function useColumnBoxItems<T>({
-  grid,
-  onRootDrop,
-  onDrop,
-  onDelete,
-  onAction,
-  orientation,
-  draggable,
-  dragPlaceholder,
-  itemFilter,
-}: UseColumnBoxItemArgs<T>): {
-  rootProps: {
-    accepted: string[];
-    orientation: "horizontal" | "vertical" | undefined;
-    onRootDrop: (p: DropEventParams) => void;
-    grid: Grid<T>;
-  };
-  items: GridBoxItem<Column<T>>[];
+export declare function useColumnBoxItems<T>({ grid, onRootDrop, onDrop, onDelete, onAction, orientation, draggable, dragPlaceholder, itemFilter, }: UseColumnBoxItemArgs<T>): {
+    rootProps: {
+        accepted: string[];
+        orientation: "horizontal" | "vertical" | undefined;
+        onRootDrop: (p: DropEventParams) => void;
+        grid: Grid<T>;
+    };
+    items: GridBoxItem<Column<T>>[];
 };