@gtkx/components 0.21.0 → 1.0.0-rc.1

package/src/types.ts

@@ -1,227 +1,76 @@
-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 { ComponentPropsWithRef, ElementType } 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 & {
+    component: C;
+} & Omit<ComponentPropsWithRef<C>, keyof Placement>;
+
+/** 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 & {
+    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>[];
-      };
+export type ItemNode<T = unknown> = {
+    /** Stable identifier used to track the item across updates and selection. */
+    id: string;
+    value: T;
+    children?: ItemNode<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. */
+export type SectionNode<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>[];
+};
+
+/** Props passed to a renderItem callback when rendering one cell. */
+export type RenderItemProps<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;
+};
 
-type ListViewSharedProps = {
+export type CollectionItemSizeProps = {
     estimatedItemHeight?: number | undefined;
     estimatedItemWidth?: number | undefined;
 };
 
-type ListViewControlledSelectionProps = {
-    selected?: string[] | null | undefined;
+export type ControlledSelectionProps = {
+    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;
-};
-
-/**
- * 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;
-          }
-    );
-
-/**
- * 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;
-    id: string;
-    sortable?: boolean | undefined;
-    visible?: boolean | undefined;
-    renderCell: (item: T) => ReactNode;
-    headerMenu?: ReactNode;
+export type ControlledExpansionProps = {
+    expandedIds?: string[] | null | undefined;
+    onExpandedChange?: ((ids: string[]) => void) | null | undefined;
 };
 
-/**
- * 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;
-      };
-
-/**
- * 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.
- */
+/** 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;
 };
-
-/**
- * The declarative menu-model surface added by the {@link Menu} component on top
- * of the raw `GMenu` element.
- */
-export type MenuItemsProps = {
-    items?: MenuEntry[] | null | undefined;
-};
-
-/**
- * Props for a `<ConstraintLayout.Constraint>` declaring a single relation
- * between a target attribute and a source attribute within a
- * {@link ConstraintLayout}.
- */
-export type ConstraintProps = {
-    target?: string;
-    targetAttribute: Gtk.ConstraintAttribute;
-    relation?: Gtk.ConstraintRelation;
-    source?: string;
-    sourceAttribute?: Gtk.ConstraintAttribute;
-    multiplier?: number;
-    constant?: number;
-    strength?: number;
-};
-
-/**
- * Props for a `<ConstraintLayout.Guide>` declaring an invisible layout guide
- * that other constraints can reference by `id` within a {@link ConstraintLayout}.
- */
-export type ConstraintGuideProps = {
-    id: string;
-    minWidth?: number;
-    minHeight?: number;
-    natWidth?: number;
-    natHeight?: number;
-    maxWidth?: number;
-    maxHeight?: number;
-    strength?: Gtk.ConstraintStrength;
-};
-
-/**
- * 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;
-};

package/src/utils/{realized-slot-store.ts → cell-container-store.ts}

@@ -1,19 +1,17 @@
 import type * as GObject from "@gtkx/gi/gobject";
 import type * as Gtk from "@gtkx/gi/gtk";
 
-export interface SlotEntry {
-    container: GObject.Object;
+export type CellEntry = {
     position: number;
     treeRow: Gtk.TreeListRow | null;
-    item: GObject.Object | null;
-}
+};
 
 let nextKey = 0;
 
-export class RealizedSlotStore {
-    private entries = new Map<GObject.Object, SlotEntry>();
+export class CellContainerStore {
+    private entries = new Map<GObject.Object, CellEntry>();
 
-    private published = new Map<GObject.Object, SlotEntry>();
+    private published = new Map<GObject.Object, CellEntry>();
 
     private setListeners = new Set<() => void>();
 
@@ -32,7 +30,7 @@ export class RealizedSlotStore {
         };
     };
 
-    getSlotsSnapshot = (): GObject.Object[] => this.snapshot;
+    getContainersSnapshot = (): GObject.Object[] => this.snapshot;
 
     subscribePosition = (container: GObject.Object, onChange: () => void): (() => void) => {
         let listeners = this.positionListeners.get(container);
@@ -49,10 +47,10 @@ export class RealizedSlotStore {
         };
     };
 
-    getPosition = (container: GObject.Object): SlotEntry => {
+    getPosition = (container: GObject.Object): CellEntry => {
         let entry = this.published.get(container);
         if (entry === undefined) {
-            entry = { container, position: -1, treeRow: null, item: null };
+            entry = { position: -1, treeRow: null };
             this.published.set(container, entry);
         }
         return entry;
@@ -61,35 +59,25 @@ export class RealizedSlotStore {
     keyFor = (container: GObject.Object): string => {
         const existing = this.keys.get(container);
         if (existing !== undefined) return existing;
-        const key = `slot-${nextKey++}`;
+        const key = `cell-${nextKey++}`;
         this.keys.set(container, key);
         return key;
     };
 
     addContainer = (container: GObject.Object): void => {
         if (this.entries.has(container)) return;
-        this.entries.set(container, { container, position: -1, treeRow: null, item: null });
+        this.entries.set(container, { position: -1, treeRow: null });
         this.notifySet();
     };
 
-    bind = (
-        container: GObject.Object,
-        position: number,
-        treeRow: Gtk.TreeListRow | null,
-        item: GObject.Object | null,
-    ): void => {
-        if (!this.entries.has(container)) {
-            this.entries.set(container, { container, position, treeRow, item });
-            this.notifySet();
-            return;
-        }
-        this.entries.set(container, { container, position, treeRow, item });
+    bind = (container: GObject.Object, position: number, treeRow: Gtk.TreeListRow | null): void => {
+        this.entries.set(container, { position, treeRow });
         this.notifyPosition(container);
     };
 
     unbind = (container: GObject.Object): void => {
         if (!this.entries.has(container)) return;
-        this.entries.set(container, { container, position: -1, treeRow: null, item: null });
+        this.entries.set(container, { position: -1, treeRow: null });
         this.notifyPosition(container);
     };
 

package/src/utils/{position-only-model.ts → item-models.ts}

@@ -1,25 +1,24 @@
 import * as Gio from "@gtkx/gi/gio";
 import type * as GObject from "@gtkx/gi/gobject";
 import * as Gtk from "@gtkx/gi/gtk";
-import type { ListItem } from "../types.js";
+import type { ItemNode, SectionNode } from "../types.js";
 import type { RowValue } from "./item-resolver.js";
-import { treeItemMetadata } from "./list-item-flatten.js";
+import { countDescendants, treeItemMetadata } from "./list-item-flatten.js";
 
 const emptyStrings = (count: number): string[] => new Array<string>(Math.max(0, count)).fill("");
 
-export const retagRows = <T, S>(
-    items: ListItem<T, S>[],
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+export const retagRows = <T>(
+    items: ItemNode<T>[],
+    rowValues: WeakMap<GObject.Object, RowValue<T>>,
     placeholdersById: Map<string, GObject.Object>,
 ): void => {
-    const walk = (list: ListItem<T, S>[]): void => {
+    const walk = (list: ItemNode<T>[]): void => {
         for (const item of list) {
             const placeholder = placeholdersById.get(item.id);
             if (placeholder !== undefined) {
                 rowValues.set(placeholder, {
                     id: item.id,
                     value: item.value,
-                    isHeader: item.section === true,
                     metadata: treeItemMetadata(item),
                 });
             }
@@ -42,9 +41,9 @@ export const resizeFlatModel = (model: Gtk.StringList, count: number): void => {
     model.splice(target, current - target, null);
 };
 
-const createTaggedRow = <T, S>(
-    row: RowValue<T, S>,
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+const createTaggedRow = <T>(
+    row: RowValue<T>,
+    rowValues: WeakMap<GObject.Object, RowValue<T>>,
     placeholdersById?: Map<string, GObject.Object>,
 ): GObject.Object => {
     const placeholder = Gtk.StringObject.new("");
@@ -53,16 +52,16 @@ const createTaggedRow = <T, S>(
     return placeholder;
 };
 
-const childModelOf = <T, S>(
-    children: ListItem<T, S>[],
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+const childModelOf = <T>(
+    children: ItemNode<T>[],
+    rowValues: WeakMap<GObject.Object, RowValue<T>>,
     placeholdersById: Map<string, GObject.Object>,
 ): Gio.ListStore => {
-    const store = Gio.ListStore.new(Gtk.StringObject.prototype.__gtype__);
+    const store = Gio.ListStore.new(Gtk.StringObject.prototype.__type__);
     for (const child of children) {
         store.append(
             createTaggedRow(
-                { id: child.id, value: child.value, isHeader: false, metadata: treeItemMetadata(child) },
+                { id: child.id, value: child.value, metadata: treeItemMetadata(child) },
                 rowValues,
                 placeholdersById,
             ),
@@ -71,17 +70,16 @@ const childModelOf = <T, S>(
     return store;
 };
 
-export const createTreeModel = <T, S>(
-    items: ListItem<T, S>[],
-    autoexpand: boolean,
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+export const createTreeModel = <T>(
+    items: ItemNode<T>[],
+    rowValues: WeakMap<GObject.Object, RowValue<T>>,
     placeholdersById: Map<string, GObject.Object>,
 ): Gtk.TreeListModel => {
-    const childrenByRow = new WeakMap<GObject.Object, ListItem<T, S>[]>();
-    const root = Gio.ListStore.new(Gtk.StringObject.prototype.__gtype__);
+    const childrenByRow = new WeakMap<GObject.Object, ItemNode<T>[]>();
+    const root = Gio.ListStore.new(Gtk.StringObject.prototype.__type__);
     for (const item of items) {
         const placeholder = createTaggedRow(
-            { id: item.id, value: item.value, isHeader: item.section === true, metadata: treeItemMetadata(item) },
+            { id: item.id, value: item.value, metadata: treeItemMetadata(item) },
             rowValues,
             placeholdersById,
         );
@@ -103,13 +101,13 @@ export const createTreeModel = <T, S>(
         }
         return store;
     };
-    return Gtk.TreeListModel.new(root, false, autoexpand, createFunc);
+    return Gtk.TreeListModel.new(root, false, false, createFunc);
 };
 
-export const createSectionModel = <T, S>(items: ListItem<T, S>[]): Gtk.FlattenListModel => {
-    const sections = Gio.ListStore.new(Gtk.StringList.prototype.__gtype__);
-    for (const section of items) {
-        sections.append(Gtk.StringList.new(emptyStrings(section.children?.length ?? 0)));
+export const createSectionModel = <S, T>(sections: SectionNode<S, T>[]): Gtk.FlattenListModel => {
+    const store = Gio.ListStore.new(Gtk.StringList.prototype.__type__);
+    for (const section of sections) {
+        store.append(Gtk.StringList.new(emptyStrings(countDescendants(section.data))));
     }
-    return Gtk.FlattenListModel.new(sections);
+    return Gtk.FlattenListModel.new(store);
 };

package/src/utils/item-resolver.ts

@@ -1,8 +1,7 @@
-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 { ListItem } from "../types.js";
-import { flattenListItems, type TreeItemMetadata } from "./list-item-flatten.js";
+import type { ItemNode, SectionNode } from "../types.js";
+import { countDescendants, flattenListItems, type TreeItemMetadata } from "./list-item-flatten.js";
 
 const NO_TREE_METADATA: TreeItemMetadata = { hideExpander: false, indentForDepth: true, indentForIcon: true };
 
@@ -16,44 +15,48 @@ const treeRowItem = (treeRow: Gtk.TreeListRow): GObject.Object | null => {
     return item;
 };
 
-export interface Resolved<T = unknown, S = unknown> {
+export type Resolved<T = unknown, S = unknown> = {
     value: T | S | undefined;
     present: boolean;
     isHeader: boolean;
-    treeRow: Gtk.TreeListRow | null;
     metadata: TreeItemMetadata;
-}
+};
 
-export interface ItemResolver<T = unknown, S = unknown> {
-    resolve(position: number, treeRow: Gtk.TreeListRow | null, boundItem: GObject.Object | null): Resolved<T, S>;
-    positionOf(id: string): number;
+export type ItemResolver<T = unknown, S = unknown> = {
+    resolve(position: number, treeRow: Gtk.TreeListRow | null): Resolved<T, S>;
+    positionOfId(id: string): number;
     idOf(position: number): string | undefined;
-    count: number;
-}
+};
 
-export interface RowValue<T = unknown, S = unknown> {
+export type RowValue<T = unknown> = {
     id: string;
-    value: T | S;
-    isHeader: boolean;
+    value: T;
     metadata: TreeItemMetadata;
-}
+};
 
-export const createControlledResolver = <T, S>(
-    items: ListItem<T, S>[] | undefined,
+export const rowIdOf = <T>(
+    rowValues: WeakMap<GObject.Object, RowValue<T>>,
+    row: Gtk.TreeListRow,
+): string | undefined => {
+    const item = row.getItem();
+    return item === null ? undefined : rowValues.get(item)?.id;
+};
+
+export const createItemResolver = <T, S>(
+    items: ItemNode<T>[] | undefined,
     flattenTreeChildren: boolean,
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
+    rowValues: WeakMap<GObject.Object, RowValue<T>>,
 ): ItemResolver<T, S> => {
     const flattened = flattenListItems(items, flattenTreeChildren);
     return {
-        count: flattened.records.length,
-        positionOf(id: string): number {
+        positionOfId(id: string): number {
             const position = flattened.idToPosition.get(id);
             return position === undefined ? -1 : position;
         },
         idOf(position: number): string | undefined {
             return flattened.positionToId.get(position);
         },
-        resolve(position: number, treeRow: Gtk.TreeListRow | null, _boundItem: GObject.Object | null): Resolved<T, S> {
+        resolve(position: number, treeRow: Gtk.TreeListRow | null): Resolved<T, S> {
             if (treeRow !== null && !flattenTreeChildren) {
                 const rowItem = treeRowItem(treeRow);
                 if (rowItem !== null) {
@@ -62,8 +65,7 @@ export const createControlledResolver = <T, S>(
                         return {
                             value: tagged.value,
                             present: true,
-                            isHeader: tagged.isHeader,
-                            treeRow,
+                            isHeader: false,
                             metadata: tagged.metadata,
                         };
                     }
@@ -75,69 +77,62 @@ export const createControlledResolver = <T, S>(
                     value: undefined,
                     present: false,
                     isHeader: false,
-                    treeRow,
                     metadata: NO_TREE_METADATA,
                 };
             }
             return {
                 value: record.value,
                 present: true,
-                isHeader: record.isHeader,
-                treeRow,
-                metadata: record.metadata,
-            };
-        },
-    };
-};
-
-export const createModelResolver = <T, S>(model: Gio.ListModel): ItemResolver<T, S> => {
-    return {
-        get count(): number {
-            return model.getNItems();
-        },
-        positionOf(id: string): number {
-            const numeric = Number(id);
-            return Number.isInteger(numeric) ? numeric : -1;
-        },
-        idOf(position: number): string {
-            return String(position);
-        },
-        resolve(position: number, treeRow: Gtk.TreeListRow | null, boundItem: GObject.Object | null): Resolved<T, S> {
-            const item = boundItem ?? model.getItem(position);
-            return {
-                value: (item ?? undefined) as T | undefined,
-                present: item !== null,
                 isHeader: false,
-                treeRow,
-                metadata: NO_TREE_METADATA,
+                metadata: record.metadata,
             };
         },
     };
 };
 
-export const createSectionHeaderResolver = <T, S>(items: ListItem<T, S>[] | undefined): ItemResolver<T, S> => {
+export const createSectionHeaderResolver = <T, S>(sections: SectionNode<S, T>[] | undefined): ItemResolver<T, S> => {
     const valueByStart = new Map<number, S>();
     let start = 0;
-    for (const section of items ?? []) {
-        if (section.section !== true) continue;
+    for (const section of sections ?? []) {
         valueByStart.set(start, section.value);
-        start += section.children?.length ?? 0;
+        start += countDescendants(section.data);
     }
     return {
-        count: valueByStart.size,
-        positionOf: () => -1,
+        positionOfId: () => -1,
         idOf: () => undefined,
         resolve(position: number): Resolved<T, S> {
             if (!valueByStart.has(position)) {
-                return { value: undefined, present: false, isHeader: true, treeRow: null, metadata: NO_TREE_METADATA };
+                return { value: undefined, present: false, isHeader: true, metadata: NO_TREE_METADATA };
             }
             return {
                 value: valueByStart.get(position),
                 present: true,
                 isHeader: true,
-                treeRow: null,
                 metadata: NO_TREE_METADATA,
             };
         },
     };
 };
+
+export const createTreeResolver = <T, S>(
+    items: ItemNode<T>[] | undefined,
+    rowValues: WeakMap<GObject.Object, RowValue<T>>,
+    model: Gtk.TreeListModel,
+): ItemResolver<T, S> => {
+    const base = createItemResolver<T, S>(items, false, rowValues);
+    return {
+        resolve: base.resolve,
+        idOf: (position: number): string | undefined => {
+            const row = model.getRow(position);
+            return row === null ? undefined : rowIdOf(rowValues, row);
+        },
+        positionOfId: (id: string): number => {
+            const count = model.getNItems();
+            for (let position = 0; position < count; position++) {
+                const row = model.getRow(position);
+                if (row !== null && rowIdOf(rowValues, row) === id) return position;
+            }
+            return -1;
+        },
+    };
+};