@gtkx/components 0.21.0 → 1.0.0-rc.2

package/src/list-view.tsx

@@ -1,85 +1,52 @@
-import type * as Gio from "@gtkx/gi/gio";
-import type * as Gtk from "@gtkx/gi/gtk";
-import { GtkListView, type GtkListViewProps } from "@gtkx/jsx/gtk";
-import type { ReactNode, Ref } from "react";
-import { CollectionView, type ModelBinding } from "./collection-view.js";
-import type { SlotRenderer } from "./list-slot.js";
+import type { ReactNode } from "react";
+import { GtkListView, GtkSignalListItemFactory } from "@gtkx/jsx/gtk";
+import { omit } from "@gtkx/utils";
 import type { ListViewProps } from "./types.js";
-
-const factoryBinding = {
-    install: (widget: Gtk.ListView, factory: Gtk.SignalListItemFactory) => widget.setFactory(factory),
-    uninstall: (widget: Gtk.ListView) => widget.setFactory(null),
-};
-
-const headerFactoryBinding = {
-    install: (widget: Gtk.ListView, factory: Gtk.SignalListItemFactory) => widget.setHeaderFactory(factory),
-    uninstall: (widget: Gtk.ListView) => widget.setHeaderFactory(null),
-};
-
-const modelBinding: ModelBinding<Gtk.ListView> = {
-    install: (widget, model) => widget.setModel(model as Gtk.SelectionModel),
-};
+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 the {@link ListView} component: the raw `GtkListView` element
- * surface with its factory/model wiring replaced by the declarative
- * {@link ListViewProps} API.
+ * Renders a Gtk.ListView from declarative items or sections, with per-row rendering,
+ * controlled selection, controlled tree expansion, and estimated item sizing.
  */
-export type ListViewComponentProps<T = unknown, S = unknown> = Omit<GtkListViewProps, keyof ListViewProps<T, S>> &
-    ListViewProps<T, S>;
-
-/**
- * A `GtkListView` driven by a declarative `items`/`renderItem` API with
- * optional controlled selection, section headers, and tree autoexpansion.
- * Supplying an external `model` switches to the uncontrolled form.
- */
-export const ListView = <T = unknown, S = unknown>(props: ListViewComponentProps<T, S>): ReactNode => {
-    const {
-        ref,
-        items,
-        model,
-        renderItem,
-        autoexpand,
-        renderHeader,
-        selected,
-        selectionMode,
-        onSelectionChanged,
-        estimatedItemHeight,
-        estimatedItemWidth,
-        ...intrinsicProps
-    } = props as ListViewProps<T, S> & {
-        ref?: Ref<Gtk.ListView | null>;
-        estimatedItemHeight?: number;
-        estimatedItemWidth?: number;
-        [key: string]: unknown;
-    };
-
-    const renderItemFn = renderItem as (item: T, row?: Gtk.TreeListRow | null) => ReactNode;
-    const slotRenderer: SlotRenderer<T, S> = (value, treeRow, isHeader) => {
-        if (isHeader) return null;
-        return treeRow === null ? renderItemFn(value as T) : renderItemFn(value as T, treeRow);
-    };
-
-    const useHeader = model === undefined && typeof renderHeader === "function";
+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 (
-        <CollectionView<T, S, Gtk.ListView>
-            element={GtkListView}
-            intrinsicProps={intrinsicProps}
-            ref={ref}
-            items={model === undefined ? items : undefined}
-            model={model as Gio.ListModel | undefined}
-            renderItem={slotRenderer}
-            autoexpand={autoexpand}
-            renderHeader={useHeader ? (value) => renderHeader?.(value as S) ?? null : undefined}
-            estimatedHeight={estimatedItemHeight}
-            estimatedWidth={estimatedItemWidth}
-            selected={selected}
-            selectionMode={selectionMode}
-            onSelectionChanged={onSelectionChanged}
-            factoryBinding={factoryBinding}
-            headerFactoryBinding={useHeader ? headerFactoryBinding : undefined}
-            modelBinding={modelBinding}
-        />
+        <>
+            <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

@@ -0,0 +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 { 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>;
+
+type SizeGroupChildRuntimeProps = {
+    component: ElementType;
+    ref?: Ref<Gtk.Widget | null> | undefined;
+} & Record<string, unknown>;
+
+type SizeGroupComponent = ((props: SizeGroupProps) => ReactNode) & {
+    Child: <C extends ElementType>(props: SizeGroupChildProps<C>) => 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;
+};
+
+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 register = useCallback<Register>(
+        (widget) => {
+            if (widget === null) {
+                return;
+            }
+
+            setWidgets((previous) => addWidget(previous, widget));
+
+            return () => {
+                setWidgets((previous) => removeWidget(previous, widget));
+            };
+        },
+        [setWidgets],
+    );
+
+    return (
+        <>
+            <GtkSizeGroup ref={ref} mode={mode} widgets={widgets} />
+            <SizeGroupContext.Provider value={register}>{children}</SizeGroupContext.Provider>
+        </>
+    );
+}
+
+export { SizeGroup };

package/src/types.ts

@@ -1,227 +1,207 @@
-import type * as Gio from "@gtkx/gi/gio";
-import type * as GObject from "@gtkx/gi/gobject";
 import type * as Gtk from "@gtkx/gi/gtk";
-import type { ReactNode } 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 and its own props. */
+type ChildProps<C extends ElementType> = {
+    component: C;
+} & ComponentPropsWithRef<C>;
+
+/** Props of a component whose backing widget defaults to one type but can be swapped through `component`. */
+type WidgetProps<C extends ElementType, Own = unknown, ExtraOmit extends string = never> = Own & {
+    component?: C;
+} & Omit<ComponentPropsWithRef<C>, ExtraOmit | keyof Own>;
 
 /**
- * A declarative item rendered by the {@link ListView}, {@link GridView},
- * {@link ColumnView}, and {@link DropDown} components.
- *
- * A non-section item carries an arbitrary value of type `T` and may declare
- * tree `children`. A section item carries a value of type `S` and groups a list
- * of child items underneath a header.
+ * A single item in a collection model, identified by a stable id and holding an
+ * arbitrary value. Nested items form a tree.
  */
-export type ListItem<T = unknown, S = unknown> =
-    | {
-          id: string;
-          value: T;
-          section?: false | undefined;
-          children?: ListItem<T, S>[] | undefined;
-          hideExpander?: boolean | undefined;
-          indentForDepth?: boolean | undefined;
-          indentForIcon?: boolean | undefined;
-      }
-    | {
-          id: string;
-          value: S;
-          section: true;
-          children: ListItem<T, S>[];
-      };
-
-type ListViewSharedProps = {
+type Item<T = unknown> = {
+    /** Stable identifier used to track the item across updates and selection. */
+    id: string;
+    value: T;
+    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. */
+    indentForDepth?: boolean | undefined;
+    /** Reserves indentation space for an expander icon. */
+    indentForIcon?: boolean | undefined;
+};
+
+/** A group of items rendered under a shared section header. */
+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: Item<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. */
+    depth?: number | undefined;
+    /** Whether the item is currently expanded in a tree view. */
+    isExpanded?: boolean | undefined;
+};
+
+/** 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;
 };
 
-type ListViewControlledSelectionProps = {
-    selected?: string[] | null | undefined;
+type SelectionProps = {
+    selectedIds?: string[] | null | undefined;
     onSelectionChanged?: ((ids: string[]) => void) | null | undefined;
     selectionMode?: Gtk.SelectionMode | null | undefined;
 };
 
-type UncontrolledItemType<T> = [T] extends [GObject.Object] ? T : GObject.Object;
-
-/**
- * Props for the {@link ListView} component, replacing the raw `GtkListView`
- * factory/model surface with a declarative `items`/`renderItem` API, optional
- * controlled selection, section headers, and tree autoexpansion. Supplying an
- * external `model` switches to the uncontrolled form.
- */
-export type ListViewProps<T = unknown, S = unknown> = ListViewSharedProps &
-    (
-        | (ListViewControlledSelectionProps & {
-              items?: ListItem<T, S>[] | undefined;
-              renderItem: (item: T, row?: Gtk.TreeListRow | null) => ReactNode;
-              autoexpand?: boolean | undefined;
-              renderHeader?: ((item: S) => ReactNode) | null | undefined;
-              model?: never;
-          })
-        | {
-              model: Gio.ListModel;
-              renderItem: (item: UncontrolledItemType<T>) => ReactNode;
-              items?: never;
-              autoexpand?: never;
-              renderHeader?: never;
-              selected?: never;
-              onSelectionChanged?: never;
-              selectionMode?: never;
-          }
-    );
-
-/**
- * Props for the {@link GridView} component, replacing the raw `GtkGridView`
- * factory/model surface with a declarative `items`/`renderItem` API and
- * optional controlled selection. Supplying an external `model` switches to the
- * uncontrolled form.
- */
-export type GridViewProps<T = unknown> = ListViewSharedProps &
-    (
-        | (ListViewControlledSelectionProps & {
-              items?: ListItem<T>[] | undefined;
-              renderItem: (item: T) => ReactNode;
-              model?: never;
-          })
-        | {
-              model: Gio.ListModel;
-              renderItem: (item: UncontrolledItemType<T>) => ReactNode;
-              items?: never;
-              selected?: never;
-              onSelectionChanged?: never;
-              selectionMode?: never;
-          }
-    );
-
-type ColumnViewSortProps = {
-    sortColumn?: string | null | undefined;
-    sortOrder?: Gtk.SortType | null | undefined;
-    onSortChanged?: ((column: string | null, order: Gtk.SortType) => void) | null | undefined;
-    estimatedRowHeight?: number | null | undefined;
+type ExpansionProps = {
+    expandedIds?: string[] | null | undefined;
+    onExpandedChange?: ((ids: string[]) => void) | null | undefined;
 };
 
-/**
- * Props for the {@link ColumnView} component, replacing the raw `GtkColumnView`
- * surface with a declarative `items` model, optional controlled selection,
- * controlled sorting, and section headers. Columns are declared as
- * {@link ColumnViewColumn} children. Supplying an external `model` switches to
- * the uncontrolled form.
- */
-export type ColumnViewProps<T = unknown, S = unknown> = ColumnViewSortProps &
-    (
-        | (ListViewControlledSelectionProps & {
-              items?: ListItem<T, S>[] | undefined;
-              renderHeader?: ((item: S) => ReactNode) | null | undefined;
-              model?: never;
-          })
-        | {
-              model: Gio.ListModel;
-              items?: never;
-              renderHeader?: never;
-              selected?: never;
-              onSelectionChanged?: never;
-              selectionMode?: never;
-          }
-    );
+type SourceProps<T, S> = {
+    items?: Item<T>[] | undefined;
+    sections?: Section<S, T>[] | undefined;
+};
 
-/**
- * Props for a single {@link ColumnViewColumn} of a {@link ColumnView},
- * replacing the raw `GtkColumnViewColumn` factory/sorter surface with a
- * declarative `renderCell` callback and an optional header context menu.
- */
-export type ColumnViewColumnProps<T = unknown> = {
-    title: string;
-    expand?: boolean | undefined;
-    resizable?: boolean | undefined;
-    fixedWidth?: number | 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;
-    visible?: boolean | undefined;
-    renderCell: (item: T) => ReactNode;
     headerMenu?: ReactNode;
 };
 
-/**
- * Props shared by the {@link DropDown} and {@link ComboRow} components,
- * replacing the raw factory/model surface with declarative `items`, controlled
- * `selectedId`, and per-slot renderers for the selected face, the popup list,
- * and section headers. Supplying an external `model` switches to the
- * uncontrolled form.
- */
-export type DropDownProps<T = unknown, S = unknown> =
-    | {
-          items?: ListItem<T, S>[] | undefined;
-          selectedId?: string | null | undefined;
-          onSelectionChanged?: ((id: string) => void) | null | undefined;
-          renderItem?: ((item: T) => ReactNode) | null | undefined;
-          renderListItem?: ((item: T) => ReactNode) | null | undefined;
-          renderHeader?: ((item: S) => ReactNode) | null | undefined;
-          model?: never;
-      }
-    | {
-          model: Gio.ListModel;
-          renderItem?: ((item: UncontrolledItemType<T>) => ReactNode) | null | undefined;
-          renderListItem?: ((item: UncontrolledItemType<T>) => ReactNode) | null | undefined;
-          items?: never;
-          selectedId?: never;
-          onSelectionChanged?: never;
-          renderHeader?: never;
-      };
+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;
+    };
 
 /**
- * A single declarative entry in a {@link Menu} model. An entry is a plain item
- * (`label` plus `action`), a `submenu`, or a `section` of nested entries.
+ * 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.
  */
-export type MenuEntry = {
-    label?: string | undefined;
-    action?: string | undefined;
-    submenu?: MenuEntry[] | undefined;
-    section?: MenuEntry[] | undefined;
+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;
 };
 
 /**
- * The declarative menu-model surface added by the {@link Menu} component on top
- * of the raw `GMenu` element.
+ * 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.
  */
-export type MenuItemsProps = {
-    items?: MenuEntry[] | null | undefined;
-};
+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 a `<ConstraintLayout.Constraint>` declaring a single relation
- * between a target attribute and a source attribute within a
- * {@link ConstraintLayout}.
+ * 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.
  */
-export type ConstraintProps = {
-    target?: string;
-    targetAttribute: Gtk.ConstraintAttribute;
-    relation?: Gtk.ConstraintRelation;
-    source?: string;
-    sourceAttribute?: Gtk.ConstraintAttribute;
-    multiplier?: number;
-    constant?: number;
-    strength?: number;
-};
+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 a `<ConstraintLayout.Guide>` declaring an invisible layout guide
- * that other constraints can reference by `id` within a {@link ConstraintLayout}.
+ * 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.
  */
-export type ConstraintGuideProps = {
-    id: string;
-    minWidth?: number;
-    minHeight?: number;
-    natWidth?: number;
-    natHeight?: number;
-    maxWidth?: number;
-    maxHeight?: number;
-    strength?: Gtk.ConstraintStrength;
+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;
 };
 
-/**
- * Props for a `<ConstraintLayout.Vfl>` declaring constraints through the GTK
- * Visual Format Language within a {@link ConstraintLayout}.
- */
-export type ConstraintVflProps = {
-    lines: string[];
-    hspacing?: number;
-    vspacing?: number;
+/** 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/collection-view.d.ts

@@ -1,30 +0,0 @@
-import type * as Gio from "@gtkx/gi/gio";
-import type * as Gtk from "@gtkx/gi/gtk";
-import { type ElementType, type ReactNode, type Ref } from "react";
-import { type FactoryBinding } from "./hooks/use-realized-slots.js";
-import type { SlotRenderer } from "./list-slot.js";
-import type { ListItem } from "./types.js";
-export interface ModelBinding<W extends Gtk.Widget> {
-    install(widget: W, model: Gio.ListModel): void;
-}
-export interface CollectionViewProps<T, S, W extends Gtk.Widget> {
-    element: ElementType;
-    intrinsicProps: Record<string, unknown>;
-    ref: Ref<W | null> | undefined;
-    items: ListItem<T, S>[] | undefined;
-    model: Gio.ListModel | undefined;
-    renderItem: SlotRenderer<T, S>;
-    autoexpand: boolean | undefined;
-    renderHeader: ((value: S | undefined) => ReactNode) | undefined;
-    estimatedHeight: number | undefined;
-    estimatedWidth: number | undefined;
-    selected: string[] | null | undefined;
-    selectionMode: Gtk.SelectionMode | null | undefined;
-    onSelectionChanged: ((ids: string[]) => void) | null | undefined;
-    factoryBinding: FactoryBinding<W>;
-    headerFactoryBinding: FactoryBinding<W> | undefined;
-    modelBinding: ModelBinding<W>;
-    children?: ReactNode;
-}
-export declare const CollectionView: <T, S, W extends Gtk.Widget>(props: CollectionViewProps<T, S, W>) => ReactNode;
-//# sourceMappingURL=collection-view.d.ts.map

package/dist/collection-view.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"collection-view.d.ts","sourceRoot":"","sources":["../src/collection-view.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,KAAK,GAAG,MAAM,cAAc,CAAC;AAEzC,OAAO,EAEH,KAAK,WAAW,EAEhB,KAAK,SAAS,EACd,KAAK,GAAG,EAGX,MAAM,OAAO,CAAC;AAGf,OAAO,EAAE,KAAK,cAAc,EAAoB,MAAM,+BAA+B,CAAC;AAGtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI3C,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM;IAC9C,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC;CAClD;AAED,MAAM,WAAW,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,GAAG,CAAC,MAAM;IAC3D,OAAO,EAAE,WAAW,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,GAAG,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IAC/B,KAAK,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC;IACpC,KAAK,EAAE,GAAG,CAAC,SAAS,GAAG,SAAS,CAAC;IACjC,UAAU,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/B,UAAU,EAAE,OAAO,GAAG,SAAS,CAAC;IAChC,YAAY,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,SAAS,KAAK,SAAS,CAAC,GAAG,SAAS,CAAC;IAChE,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IACtC,aAAa,EAAE,GAAG,CAAC,aAAa,GAAG,IAAI,GAAG,SAAS,CAAC;IACpD,kBAAkB,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IACjE,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IAClC,oBAAoB,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACpD,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAC9B,QAAQ,CAAC,EAAE,SAAS,CAAC;CACxB;AA8DD,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,GAAG,CAAC,MAAM,EAAE,OAAO,mBAAmB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,SAkBhG,CAAC"}