@gtkx/components 1.0.0-rc.1 → 1.0.0-rc.2

package/src/list-view.tsx

@@ -1,148 +1,52 @@
-import type * as Gtk from "@gtkx/gi/gtk";
-import { GtkListView, type GtkListViewProps } from "@gtkx/jsx/gtk";
-import type { ReactNode, Ref } from "react";
-import {
-    type CellRenderer,
-    CellRenderHost,
-    createTreeRenderContext,
-    HeaderRenderHost,
-    itemRenderer,
-    type TreeRenderContext,
-} from "./cell.js";
-import { makeFactoryInstaller, useCellContainers } from "./hooks/use-cell-containers.js";
-import { useCollectionWidget } from "./hooks/use-collection-widget.js";
-import type {
-    CollectionItemSizeProps,
-    ControlledExpansionProps,
-    ControlledSelectionProps,
-    ItemNode,
-    RenderItemProps,
-    SectionNode,
-} from "./types.js";
-import type { CellContainerStore } from "./utils/cell-container-store.js";
-import type { ItemResolver } from "./utils/item-resolver.js";
-
-const factoryInstaller = makeFactoryInstaller<Gtk.ListView>((widget, factory) => widget.setFactory(factory));
-
-const headerFactoryInstaller = makeFactoryInstaller<Gtk.ListView>((widget, factory) =>
-    widget.setHeaderFactory(factory),
-);
-
-export type ListViewDeclarativeProps<T = unknown, S = unknown> = CollectionItemSizeProps &
-    ControlledSelectionProps &
-    ControlledExpansionProps & {
-        items?: ItemNode<T>[] | undefined;
-        sections?: SectionNode<S, T>[] | undefined;
-        renderItem: (props: RenderItemProps<T>) => ReactNode;
-        renderHeader?: ((info: { section: S }) => ReactNode) | null | undefined;
-    };
+import type { ReactNode } from "react";
+import { GtkListView, GtkSignalListItemFactory } from "@gtkx/jsx/gtk";
+import { omit } from "@gtkx/utils";
+import type { ListViewProps } from "./types.js";
+import { HeaderPortals, ItemPortals, useHeaderCells, useItemCells } from "./internal/cells.js";
+import { useCollection } from "./internal/use-collection.js";
+
+const LIST_VIEW_PROPS = [
+    "items",
+    "sections",
+    "renderItem",
+    "renderHeader",
+    "selectedIds",
+    "onSelectionChanged",
+    "selectionMode",
+    "expandedIds",
+    "onExpandedChange",
+    "estimatedItemHeight",
+    "estimatedItemWidth",
+] as const satisfies (keyof ListViewProps)[];
 
 /**
- * Props for {@link ListView}. Combines the underlying Gtk.ListView props with
- * declarative collection props: flat items or grouped sections, a per-row renderItem,
- * an optional section header renderer, controlled selection and expansion, and
- * estimated item sizing.
+ * Renders a Gtk.ListView from declarative items or sections, with per-row rendering,
+ * controlled selection, controlled tree expansion, and estimated item sizing.
  */
-export type ListViewProps<T = unknown, S = unknown> = Omit<
-    GtkListViewProps,
-    "model" | "factory" | "headerFactory" | keyof ListViewDeclarativeProps<T, S>
-> &
-    ListViewDeclarativeProps<T, S>;
-
-interface ListViewWiring<T, S> {
-    setRef: (value: Gtk.ListView | null) => void;
-    resolver: ItemResolver<T, S>;
-    headerResolver: ItemResolver<T, S>;
-    itemStore: CellContainerStore;
-    headerStore: CellContainerStore;
-    useHeader: boolean;
-    rowId: (row: Gtk.TreeListRow) => string | undefined;
-}
-
-const useListViewWiring = <T, S>(props: NormalizedListViewProps<T, S>): ListViewWiring<T, S> => {
-    const { widgetRef, setRef, collection } = useCollectionWidget<Gtk.ListView, T, S>(props);
-
-    const useHeader = collection.useHeader;
-
-    const itemStore = useCellContainers<Gtk.ListView>({
-        object: widgetRef,
-        installer: factoryInstaller,
-        estimatedHeight: props.estimatedItemHeight,
-        estimatedWidth: props.estimatedItemWidth,
-    });
-    const headerStore = useCellContainers<Gtk.ListView>({
-        object: useHeader ? widgetRef : null,
-        installer: headerFactoryInstaller,
-        estimatedHeight: props.estimatedItemHeight,
-        estimatedWidth: props.estimatedItemWidth,
-    });
-
-    return {
-        setRef,
-        resolver: collection.resolver,
-        headerResolver: collection.headerResolver,
-        itemStore,
-        headerStore,
-        useHeader,
-        rowId: collection.rowId,
-    };
-};
-
-type NormalizedListViewProps<T, S> = ListViewDeclarativeProps<T, S> & {
-    ref?: Ref<Gtk.ListView | null>;
-    estimatedItemHeight?: number;
-    estimatedItemWidth?: number;
-    [key: string]: unknown;
-};
-
-/**
- * Renders a Gtk.ListView: a scrollable, single-column list backed by a collection
- * model, with each row drawn by renderItem and optional section headers.
- */
-export const ListView = <T = unknown, S = unknown>(props: ListViewProps<T, S>): ReactNode => {
-    const {
-        ref,
-        items,
-        sections,
-        renderItem,
-        renderHeader,
-        selectedIds,
-        selectionMode,
-        onSelectionChanged,
-        expandedIds,
-        onExpandedChange,
-        estimatedItemHeight,
-        estimatedItemWidth,
-        ...intrinsicProps
-    } = props as NormalizedListViewProps<T, S>;
-
-    const wiring = useListViewWiring<T, S>({
-        ref,
-        items,
-        sections,
-        renderHeader,
-        selectedIds,
-        selectionMode,
-        onSelectionChanged,
-        expandedIds,
-        onExpandedChange,
-        estimatedItemHeight,
-        estimatedItemWidth,
-    } as NormalizedListViewProps<T, S>);
-
-    const treeContext: TreeRenderContext = createTreeRenderContext(expandedIds, wiring.rowId);
-    const cellRenderer: CellRenderer<T, S> = itemRenderer<T, S>(renderItem, treeContext);
+function ListView<T = unknown, S = unknown>(props: ListViewProps<T, S>): ReactNode {
+    const { renderItem, renderHeader, expandedIds, estimatedItemHeight, estimatedItemWidth } = props;
+    const rest = omit(props, LIST_VIEW_PROPS);
+    const size = { width: estimatedItemWidth ?? -1, height: estimatedItemHeight ?? -1 };
+    const { collection, selection } = useCollection(props);
+    const itemCells = useItemCells(size);
+    const headerCells = useHeaderCells(size);
 
     return (
         <>
-            <GtkListView {...intrinsicProps} ref={wiring.setRef} />
-            <CellRenderHost store={wiring.itemStore} resolver={wiring.resolver} render={cellRenderer} />
-            <HeaderRenderHost
-                useHeader={wiring.useHeader}
-                store={wiring.headerStore}
-                resolver={wiring.headerResolver}
-                renderHeader={renderHeader}
+            <GtkListView
+                model={selection}
+                factory={<GtkSignalListItemFactory {...itemCells.handlers} />}
+                {...(renderHeader != null && {
+                    headerFactory: <GtkSignalListItemFactory {...headerCells.handlers} />,
+                })}
+                {...rest}
             />
+            <ItemPortals store={itemCells} render={renderItem} collection={collection} expandedIds={expandedIds} />
+            {renderHeader != null && (
+                <HeaderPortals store={headerCells} render={renderHeader} collection={collection} />
+            )}
         </>
     );
-};
+}
+
+export { ListView };

package/src/size-group.tsx

@@ -1,96 +1,77 @@
 import type * as Gtk from "@gtkx/gi/gtk";
+import type { ElementType, ReactNode, Ref, RefCallback } from "react";
 import { GtkSizeGroup } from "@gtkx/jsx/gtk";
-import { useMergeRefs } from "@gtkx/react/internal";
-import {
-    createContext,
-    type ElementType,
-    type ReactNode,
-    type Ref,
-    type RefCallback,
-    useCallback,
-    useContext,
-    useRef,
-} from "react";
-import type { ChildProps } from "./types.js";
-
-type SizeGroupRegistry = {
-    addWidget: (widget: Gtk.Widget) => void;
-    removeWidget: (widget: Gtk.Widget) => void;
-    setGroup: (group: Gtk.SizeGroup | null) => void;
-};
+import { useMergedRef } from "@gtkx/react/internal";
+import { createContext, useCallback, useContext, useState } from "react";
+import type { SizeGroupChildProps, SizeGroupProps } from "./types.js";
+
+type Register = RefCallback<Gtk.Widget | null>;
 
-const SizeGroupContext = createContext<SizeGroupRegistry | null>(null);
+type SizeGroupChildRuntimeProps = {
+    component: ElementType;
+    ref?: Ref<Gtk.Widget | null> | undefined;
+} & Record<string, unknown>;
 
-const useSizeGroupRegistry = (): SizeGroupRegistry => {
-    const registry = useContext(SizeGroupContext);
-    if (!registry) throw new Error("<SizeGroup.Child> must be a child of <SizeGroup>");
-    return registry;
+type SizeGroupComponent = ((props: SizeGroupProps) => ReactNode) & {
+    Child: <C extends ElementType>(props: SizeGroupChildProps<C>) => ReactNode;
 };
 
-/** Props for {@link SizeGroup}. */
-export type SizeGroupProps = {
-    /** How the group equalizes sizes: horizontal, vertical, or both. */
-    mode?: Gtk.SizeGroupMode | null | undefined;
-    ref?: Ref<Gtk.SizeGroup | null>;
-    children?: ReactNode;
+const SizeGroupContext = createContext<Register | null>(null);
+const SizeGroupChild = SizeGroupChildImpl as <C extends ElementType>(props: SizeGroupChildProps<C>) => ReactNode;
+/**
+ * Creates a Gtk.SizeGroup that keeps widgets joined through `SizeGroup.Child`
+ * at a common size in the given mode, without contributing a widget of its own.
+ */
+const SizeGroup: SizeGroupComponent = Object.assign(SizeGroupRoot, { Child: SizeGroupChild });
+
+const useRegister = (): Register => {
+    const register = useContext(SizeGroupContext);
+
+    if (register === null) {
+        throw new Error("<SizeGroup.Child> must be a child of <SizeGroup>");
+    }
+
+    return register;
 };
 
-/** Adds a single widget, rendered by the given component, to the enclosing {@link SizeGroup}. */
-export type SizeGroupChildProps<C extends ElementType> = ChildProps<C>;
+function SizeGroupChildImpl(props: SizeGroupChildRuntimeProps): ReactNode {
+    const { component: Component, ref, ...rest } = props;
+    const refCallback = useMergedRef<Gtk.Widget | null>(ref, useRegister());
+
+    return <Component {...rest} ref={refCallback} />;
+}
+
+const addWidget = (widgets: Gtk.Widget[], widget: Gtk.Widget): Gtk.Widget[] =>
+    widgets.includes(widget) ? widgets : [...widgets, widget];
+
+const removeWidget = (widgets: Gtk.Widget[], widget: Gtk.Widget): Gtk.Widget[] =>
+    widgets.filter((entry) => entry !== widget);
+
+function SizeGroupRoot(props: SizeGroupProps): ReactNode {
+    const { mode, ref, children } = props;
+    const [widgets, setWidgets] = useState<Gtk.Widget[]>([]);
 
-const SizeGroupChild = <C extends ElementType>({ component, ref, ...rest }: SizeGroupChildProps<C>): ReactNode => {
-    const registry = useSizeGroupRegistry();
-    const joinGroup = useCallback<RefCallback<Gtk.Widget>>(
+    const register = useCallback<Register>(
         (widget) => {
-            if (widget === null) return;
-            registry.addWidget(widget);
-            return () => registry.removeWidget(widget);
+            if (widget === null) {
+                return;
+            }
+
+            setWidgets((previous) => addWidget(previous, widget));
+
+            return () => {
+                setWidgets((previous) => removeWidget(previous, widget));
+            };
         },
-        [registry],
+        [setWidgets],
     );
-    const Component: ElementType = component;
-    const setWidget = useMergeRefs<Gtk.Widget>(ref, joinGroup);
-    return <Component {...rest} ref={setWidget} />;
-};
 
-const createRegistry = (): SizeGroupRegistry => {
-    const members = new Set<Gtk.Widget>();
-    let group: Gtk.SizeGroup | null = null;
-    return {
-        addWidget: (widget) => {
-            members.add(widget);
-            group?.addWidget(widget);
-        },
-        removeWidget: (widget) => {
-            members.delete(widget);
-            group?.removeWidget(widget);
-        },
-        setGroup: (next) => {
-            group = next;
-            if (next) for (const member of members) next.addWidget(member);
-        },
-    };
-};
+    return (
+        <>
+            <GtkSizeGroup ref={ref} mode={mode} widgets={widgets} />
+            <SizeGroupContext.Provider value={register}>{children}</SizeGroupContext.Provider>
+        </>
+    );
+}
 
-/**
- * Creates a Gtk.SizeGroup that keeps its member widgets at a common size. Members join the group
- * through {@link SizeGroup.Child}.
- */
-export const SizeGroup: ((props: SizeGroupProps) => ReactNode) & {
-    Child: <C extends ElementType>(props: SizeGroupChildProps<C>) => ReactNode;
-} = Object.assign(
-    ({ mode, ref, children }: SizeGroupProps): ReactNode => {
-        const registryRef = useRef<SizeGroupRegistry | null>(null);
-        if (registryRef.current === null) registryRef.current = createRegistry();
-        const registry = registryRef.current;
-        const setGroup = useCallback<RefCallback<Gtk.SizeGroup>>((group) => registry.setGroup(group), [registry]);
-        const mergedRef = useMergeRefs<Gtk.SizeGroup>(ref, setGroup);
-        return (
-            <>
-                <GtkSizeGroup ref={mergedRef} mode={mode} />
-                <SizeGroupContext.Provider value={registry}>{children}</SizeGroupContext.Provider>
-            </>
-        );
-    },
-    { Child: SizeGroupChild },
-);
+export { SizeGroup };

package/src/types.ts

@@ -1,13 +1,20 @@
 import type * as Gtk from "@gtkx/gi/gtk";
-import type { ComponentPropsWithRef, ElementType } from "react";
+import type {
+    GtkColumnViewColumnProps,
+    GtkColumnViewProps,
+    GtkDropDown,
+    GtkGridViewProps,
+    GtkListViewProps,
+} from "@gtkx/jsx/gtk";
+import type { ComponentPropsWithRef, ElementType, ReactNode, Ref } from "react";
 
-/** Props of a container's Child component: the widget to render, its own props, and any placement props. */
-export type ChildProps<C extends ElementType, Placement = unknown> = Placement & {
+/** Props of a container's Child component: the widget to render and its own props. */
+type ChildProps<C extends ElementType> = {
     component: C;
-} & Omit<ComponentPropsWithRef<C>, keyof Placement>;
+} & ComponentPropsWithRef<C>;
 
 /** Props of a component whose backing widget defaults to one type but can be swapped through `component`. */
-export type WidgetProps<C extends ElementType, Own = unknown, ExtraOmit extends string = never> = Own & {
+type WidgetProps<C extends ElementType, Own = unknown, ExtraOmit extends string = never> = Own & {
     component?: C;
 } & Omit<ComponentPropsWithRef<C>, ExtraOmit | keyof Own>;
 
@@ -15,11 +22,11 @@ export type WidgetProps<C extends ElementType, Own = unknown, ExtraOmit extends
  * A single item in a collection model, identified by a stable id and holding an
  * arbitrary value. Nested items form a tree.
  */
-export type ItemNode<T = unknown> = {
+type Item<T = unknown> = {
     /** Stable identifier used to track the item across updates and selection. */
     id: string;
     value: T;
-    children?: ItemNode<T>[] | undefined;
+    children?: Item<T>[] | undefined;
     /** Hides the tree expander arrow even when the item has children. */
     hideExpander?: boolean | undefined;
     /** Adds indentation matching the item's depth in the tree. */
@@ -29,16 +36,16 @@ export type ItemNode<T = unknown> = {
 };
 
 /** A group of items rendered under a shared section header. */
-export type SectionNode<S = unknown, T = unknown> = {
+type Section<S = unknown, T = unknown> = {
     /** Stable identifier used to track the section across updates. */
     id: string;
     value: S;
     /** Items belonging to this section. */
-    data: ItemNode<T>[];
+    data: Item<T>[];
 };
 
-/** Props passed to a renderItem callback when rendering one cell. */
-export type RenderItemProps<T> = {
+/** Arguments passed to an {@link ItemRenderer} when rendering one cell. */
+type RenderItemArgs<T> = {
     item: T;
     index: number;
     /** Depth of the item within a tree, starting at zero for top-level items. */
@@ -47,30 +54,154 @@ export type RenderItemProps<T> = {
     isExpanded?: boolean | undefined;
 };
 
-export type CollectionItemSizeProps = {
+/** Arguments passed to a {@link HeaderRenderer} when rendering one section header. */
+type RenderHeaderArgs<S> = {
+    section: S;
+};
+
+/** Renders the contents of one cell of a collection view. */
+type ItemRenderer<T> = (args: RenderItemArgs<T>) => ReactNode;
+/** Renders the contents of one section header of a collection view. */
+type HeaderRenderer<S> = (args: RenderHeaderArgs<S>) => ReactNode;
+
+type ItemSizeProps = {
     estimatedItemHeight?: number | undefined;
     estimatedItemWidth?: number | undefined;
 };
 
-export type ControlledSelectionProps = {
+type SelectionProps = {
     selectedIds?: string[] | null | undefined;
     onSelectionChanged?: ((ids: string[]) => void) | null | undefined;
     selectionMode?: Gtk.SelectionMode | null | undefined;
 };
 
-export type ControlledExpansionProps = {
+type ExpansionProps = {
     expandedIds?: string[] | null | undefined;
     onExpandedChange?: ((ids: string[]) => void) | null | undefined;
 };
 
-/** Declarative description of a single menu item, optionally nesting a submenu or section. */
-export type MenuEntry = {
-    /** Text shown for the item. */
-    label?: string | undefined;
-    /** Action name activated when the item is chosen, for example "app.quit". */
-    action?: string | undefined;
-    /** Nested entries shown as a submenu opened from this item. */
-    submenu?: MenuEntry[] | undefined;
-    /** Nested entries grouped as a visually separated section. */
-    section?: MenuEntry[] | undefined;
+type SourceProps<T, S> = {
+    items?: Item<T>[] | undefined;
+    sections?: Section<S, T>[] | undefined;
+};
+
+/** One column of a {@link ColumnView}, pairing Gtk.ColumnViewColumn props with a cell renderer. */
+type Column<T = unknown> = Omit<GtkColumnViewColumnProps, "factory" | "sorter" | "id" | "title"> & {
+    /** Stable identifier, also used to address the column through sorting props. */
+    id: string;
+    title: string;
+    renderCell: ItemRenderer<T>;
+    /** Whether clicking the column header sorts by it. */
+    sortable?: boolean | undefined;
+    headerMenu?: ReactNode;
+};
+
+type ColumnViewOwnProps<T, S> = SelectionProps &
+    ExpansionProps &
+    SourceProps<T, S> &
+    Omit<ItemSizeProps, "estimatedItemWidth"> & {
+        columns: Column<T>[];
+        renderHeader?: HeaderRenderer<S> | null | undefined;
+        /** Id of the column the view is sorted by, making sorting controlled. */
+        sortColumn?: string | null | undefined;
+        sortOrder?: Gtk.SortType | null | undefined;
+        onSortChanged?: ((column: string | null, order: Gtk.SortType) => void) | null | undefined;
+    };
+
+/**
+ * Props for {@link ColumnView}. Combines the underlying Gtk.ColumnView props with
+ * declarative collection props: flat items or grouped sections, controlled selection
+ * and expansion, sorting (sortColumn, sortOrder, onSortChanged), an optional section
+ * header renderer, and the columns to render.
+ */
+type ColumnViewProps<T = unknown, S = unknown> = Omit<
+    GtkColumnViewProps,
+    "columns" | "model" | "headerFactory" | keyof ColumnViewOwnProps<T, S>
+> &
+ColumnViewOwnProps<T, S>;
+
+type DropDownOwnProps<T, S> = SourceProps<T, S> & {
+    /** Id of the currently selected item, making the selection controlled. */
+    selectedId?: string | null | undefined;
+    onSelectionChanged?: ((id: string) => void) | null | undefined;
+    renderItem?: ItemRenderer<T> | null | undefined;
+    /** Renderer for items in the open popup list, falling back to renderItem when omitted. */
+    renderListItem?: ItemRenderer<T> | null | undefined;
+    /** Renderer for section headers in the popup list. */
+    renderHeader?: HeaderRenderer<S> | null | undefined;
+};
+
+/**
+ * Props for {@link DropDown}. The backing widget is chosen through the `component` prop, defaulting to
+ * GtkDropDown, and its own props combine with the declarative collection props.
+ */
+type DropDownProps<T = unknown, S = unknown, C extends ElementType = typeof GtkDropDown> = WidgetProps<
+    C,
+    DropDownOwnProps<T, S>,
+    "model" | "factory" | "listFactory" | "headerFactory"
+>;
+
+type GridViewOwnProps<T> = ItemSizeProps &
+    SelectionProps & {
+        items?: Item<T>[] | undefined;
+        renderItem: ItemRenderer<T>;
+    };
+
+/**
+ * Props for {@link GridView}. Combines the underlying Gtk.GridView props with
+ * declarative collection props: items, a per-cell renderItem, controlled selection,
+ * and estimated item sizing.
+ */
+type GridViewProps<T = unknown> = Omit<GtkGridViewProps, "model" | "factory" | keyof GridViewOwnProps<T>> &
+    GridViewOwnProps<T>;
+
+type ListViewOwnProps<T, S> = ItemSizeProps &
+    SelectionProps &
+    ExpansionProps &
+    SourceProps<T, S> & {
+        renderItem: ItemRenderer<T>;
+        renderHeader?: HeaderRenderer<S> | null | undefined;
+    };
+
+/**
+ * Props for {@link ListView}. Combines the underlying Gtk.ListView props with
+ * declarative collection props: flat items or grouped sections, a per-row renderItem,
+ * an optional section header renderer, controlled selection and expansion, and
+ * estimated item sizing.
+ */
+type ListViewProps<T = unknown, S = unknown> = Omit<
+    GtkListViewProps,
+    "model" | "factory" | "headerFactory" | keyof ListViewOwnProps<T, S>
+> &
+ListViewOwnProps<T, S>;
+
+/** Props for {@link SizeGroup}. */
+type SizeGroupProps = {
+    /** How the group equalizes sizes: horizontal, vertical, or both. */
+    mode?: Gtk.SizeGroupMode | null | undefined;
+    ref?: Ref<Gtk.SizeGroup | null>;
+    children?: ReactNode;
+};
+
+/** Adds a single widget, rendered by the given component, to the enclosing {@link SizeGroup}. */
+type SizeGroupChildProps<C extends ElementType> = ChildProps<C>;
+
+export {
+    type SelectionProps,
+    type ExpansionProps,
+    type ChildProps,
+    type WidgetProps,
+    type Item,
+    type Section,
+    type RenderItemArgs,
+    type RenderHeaderArgs,
+    type ItemRenderer,
+    type HeaderRenderer,
+    type Column,
+    type ColumnViewProps,
+    type DropDownProps,
+    type GridViewProps,
+    type ListViewProps,
+    type SizeGroupProps,
+    type SizeGroupChildProps,
 };

package/dist/cell.d.ts

@@ -1,30 +0,0 @@
-import type * as Gtk from "@gtkx/gi/gtk";
-import { type ReactNode } from "react";
-import type { RenderItemProps } from "./types.js";
-import type { CellContainerStore } from "./utils/cell-container-store.js";
-import type { ItemResolver } from "./utils/item-resolver.js";
-export type CellRenderer<T, S> = (value: T | S | undefined, treeRow: Gtk.TreeListRow | null, position: number) => ReactNode;
-interface CellRenderHostProps<T, S> {
-    store: CellContainerStore;
-    resolver: ItemResolver<T, S>;
-    render: CellRenderer<T, S>;
-}
-export declare const CellRenderHost: <T, S>({ store, resolver, render }: CellRenderHostProps<T, S>) => ReactNode;
-export type TreeRenderContext = {
-    controlled: boolean;
-    expandedIds: Set<string>;
-    rowId: (row: Gtk.TreeListRow) => string | undefined;
-};
-export declare const createTreeRenderContext: (expandedIds: string[] | null | undefined, rowId: (row: Gtk.TreeListRow) => string | undefined) => TreeRenderContext;
-export declare const itemRenderer: <T, S>(render: (props: RenderItemProps<T>) => ReactNode, context?: TreeRenderContext) => CellRenderer<T, S>;
-interface HeaderRenderHostProps<T, S> {
-    useHeader: boolean;
-    store: CellContainerStore;
-    resolver: ItemResolver<T, S>;
-    renderHeader: ((info: {
-        section: S;
-    }) => ReactNode) | null | undefined;
-}
-export declare const HeaderRenderHost: <T, S>({ useHeader, store, resolver, renderHeader, }: HeaderRenderHostProps<T, S>) => ReactNode;
-export {};
-//# sourceMappingURL=cell.d.ts.map

package/dist/cell.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cell.d.ts","sourceRoot":"","sources":["../src/cell.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,GAAG,MAAM,cAAc,CAAC;AAGzC,OAAO,EAAkB,KAAK,SAAS,EAAqC,MAAM,OAAO,CAAC;AAC1F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAa,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,CAAC,IAAI,CAC7B,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,EACxB,OAAO,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,EAC/B,QAAQ,EAAE,MAAM,KACf,SAAS,CAAC;AASf,UAAU,mBAAmB,CAAC,CAAC,EAAE,CAAC;IAC9B,KAAK,EAAE,kBAAkB,CAAC;IAC1B,QAAQ,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7B,MAAM,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC9B;AA4CD,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,+BAA+B,mBAAmB,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,SAmB7F,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC5B,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,WAAW,KAAK,MAAM,GAAG,SAAS,CAAC;CACvD,CAAC;AAEF,eAAO,MAAM,uBAAuB,gBACnB,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,SACjC,CAAC,GAAG,EAAE,GAAG,CAAC,WAAW,KAAK,MAAM,GAAG,SAAS,KACpD,iBAID,CAAC;AAeH,eAAO,MAAM,YAAY,GACpB,CAAC,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,SAAS,YAAY,iBAAiB,KAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAEtB,CAAC;AAOvF,UAAU,qBAAqB,CAAC,CAAC,EAAE,CAAC;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,QAAQ,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7B,YAAY,EAAE,CAAC,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,CAAC,CAAA;KAAE,KAAK,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;CAC1E;AAED,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,iDAKlC,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,SACsF,CAAC"}

package/dist/cell.js

@@ -1,45 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { GtkTreeExpander } from "@gtkx/jsx/gtk";
-import { createPortal } from "@gtkx/react";
-import { Fragment, memo, useCallback, useSyncExternalStore } from "react";
-const TreeExpanderCell = ({ treeRow, metadata, children }) => (_jsx(GtkTreeExpander, { ref: (expander) => {
-        if (expander !== null)
-            expander.setListRow(treeRow);
-    }, hideExpander: metadata.hideExpander, indentForDepth: metadata.indentForDepth, indentForIcon: metadata.indentForIcon, children: children }));
-const Cell = memo(({ container, store, resolver, render }) => {
-    const subscribe = useCallback((onChange) => store.subscribePosition(container, onChange), [store, container]);
-    const getSnapshot = useCallback(() => store.getPosition(container), [store, container]);
-    const entry = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-    if (entry.position < 0)
-        return null;
-    const resolved = resolver.resolve(entry.position, entry.treeRow);
-    if (!resolved.present)
-        return null;
-    const content = render(resolved.value, entry.treeRow, entry.position);
-    const portalled = entry.treeRow !== null && !resolved.isHeader ? (_jsx(TreeExpanderCell, { treeRow: entry.treeRow, metadata: resolved.metadata, children: content })) : (content);
-    return createPortal(portalled, container, store.keyFor(container));
-});
-export const CellRenderHost = ({ store, resolver, render }) => {
-    const containers = useSyncExternalStore(store.subscribeSet, store.getContainersSnapshot, store.getContainersSnapshot);
-    return (_jsx(Fragment, { children: containers.map((container) => (_jsx(Cell, { container: container, store: store, resolver: resolver, render: render }, store.keyFor(container)))) }));
-};
-export const createTreeRenderContext = (expandedIds, rowId) => ({
-    controlled: expandedIds !== undefined && expandedIds !== null,
-    expandedIds: new Set(expandedIds ?? []),
-    rowId,
-});
-const treeFields = (treeRow, context) => {
-    if (treeRow === null)
-        return {};
-    const depth = treeRow.getDepth();
-    if (context === undefined || !treeRow.isExpandable())
-        return { depth };
-    const isExpanded = context.controlled
-        ? context.expandedIds.has(context.rowId(treeRow) ?? "")
-        : treeRow.getExpanded();
-    return { depth, isExpanded };
-};
-export const itemRenderer = (render, context) => (value, treeRow, position) => render({ item: value, index: position, ...treeFields(treeRow, context) });
-const headerRenderer = (renderHeader) => (value) => renderHeader ? renderHeader({ section: value }) : null;
-export const HeaderRenderHost = ({ useHeader, store, resolver, renderHeader, }) => useHeader ? _jsx(CellRenderHost, { store: store, resolver: resolver, render: headerRenderer(renderHeader) }) : null;
-//# sourceMappingURL=cell.js.map