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

package/src/column-view-column.tsx

@@ -1,82 +0,0 @@
-import type * as Gtk from "@gtkx/gi/gtk";
-import { GtkColumnViewColumn, type GtkColumnViewColumnProps } from "@gtkx/jsx/gtk";
-import { useMergeRefs } from "@gtkx/react/internal";
-import { type ReactNode, useLayoutEffect, useRef, useState } from "react";
-import { type CellRenderer, CellRenderHost, itemRenderer, type TreeRenderContext } from "./cell.js";
-import { makeFactoryInstaller, useCellContainers } from "./hooks/use-cell-containers.js";
-import { useHeaderMenu } from "./hooks/use-header-menu.js";
-import type { RenderItemProps } from "./types.js";
-import type { ItemResolver } from "./utils/item-resolver.js";
-
-const factoryInstaller = makeFactoryInstaller<Gtk.ColumnViewColumn>((column, factory) => column.setFactory(factory));
-
-export type ColumnDefDeclarativeProps<T = unknown> = {
-    title: string;
-    expand?: boolean | undefined;
-    resizable?: boolean | undefined;
-    fixedWidth?: number | undefined;
-    id: string;
-    sortable?: boolean | undefined;
-    visible?: boolean | undefined;
-    renderCell: (props: RenderItemProps<T>) => ReactNode;
-    headerMenu?: ReactNode;
-};
-
-export type ColumnDef<T = unknown> = Omit<GtkColumnViewColumnProps, "factory" | "sorter"> &
-    ColumnDefDeclarativeProps<T>;
-
-type ColumnViewColumnProps<T = unknown> = ColumnDef<T> & {
-    resolver: ItemResolver<unknown, unknown>;
-    tree: TreeRenderContext;
-    estimatedItemHeight?: number | undefined;
-    onInstance: (id: string, column: Gtk.ColumnViewColumn | null) => void;
-};
-
-export const ColumnViewColumn = <T = unknown>(props: ColumnViewColumnProps<T>): ReactNode => {
-    const {
-        id,
-        title,
-        sortable,
-        renderCell,
-        headerMenu,
-        resolver,
-        tree,
-        estimatedItemHeight,
-        onInstance,
-        ref,
-        ...intrinsicProps
-    } = props as ColumnViewColumnProps<T> & { [key: string]: unknown };
-    const [column, setColumn] = useState<Gtk.ColumnViewColumn | null>(null);
-
-    const captureColumn = useMergeRefs<Gtk.ColumnViewColumn>(ref, setColumn);
-
-    const store = useCellContainers<Gtk.ColumnViewColumn>({
-        object: column,
-        installer: factoryInstaller,
-        estimatedHeight: estimatedItemHeight,
-    });
-
-    const onInstanceRef = useRef(onInstance);
-    onInstanceRef.current = onInstance;
-
-    useLayoutEffect(() => {
-        if (column === null) return;
-        onInstanceRef.current(id, column);
-        return () => onInstanceRef.current(id, null);
-    }, [column, id]);
-
-    const headerMenuPortal = useHeaderMenu(column, headerMenu);
-
-    const cellRenderer: CellRenderer<unknown, unknown> = itemRenderer<unknown, unknown>(
-        (cellProps) => renderCell({ ...cellProps, item: cellProps.item as T }),
-        tree,
-    );
-
-    return (
-        <>
-            <GtkColumnViewColumn {...intrinsicProps} id={id} title={title} ref={captureColumn} />
-            <CellRenderHost store={store} resolver={resolver} render={cellRenderer} />
-            {headerMenuPortal}
-        </>
-    );
-};

package/src/constraint-layout-apply.ts

@@ -1,173 +0,0 @@
-import * as GObject from "@gtkx/gi/gobject";
-import * as Gtk from "@gtkx/gi/gtk";
-
-/**
- * Describes one constraint added by `<ConstraintLayout.Constraint>`, relating a
- * target widget attribute to a source attribute of another widget or guide.
- */
-export type ConstraintProps = {
-    /** Name of the target widget or guide. Use "super" or omit to reference the layout's own widget. */
-    target?: string;
-    targetAttribute: Gtk.ConstraintAttribute;
-    /** Relation between the target and source attributes (defaults to equality). */
-    relation?: Gtk.ConstraintRelation;
-    /** Name of the source widget or guide. Use "super" or omit for a constant constraint. */
-    source?: string;
-    sourceAttribute?: Gtk.ConstraintAttribute;
-    /** Factor applied to the source attribute (defaults to 1). */
-    multiplier?: number;
-    /** Constant offset added to the relation (defaults to 0). */
-    constant?: number;
-    /** Constraint strength, higher values winning conflicts (defaults to required). */
-    strength?: number;
-};
-
-/**
- * Describes an invisible spacing guide added by `<ConstraintLayout.Guide>`,
- * usable as a constraint target under its id.
- */
-export type ConstraintGuideProps = {
-    /** Identifier used to reference this guide from constraints. */
-    id: string;
-    minWidth?: number;
-    minHeight?: number;
-    /** Preferred (natural) width. */
-    natWidth?: number;
-    /** Preferred (natural) height. */
-    natHeight?: number;
-    maxWidth?: number;
-    maxHeight?: number;
-    /** Strength of the guide's own size constraints. */
-    strength?: Gtk.ConstraintStrength;
-};
-
-/**
- * Describes constraints authored with the Visual Format Language (VFL), applied by
- * `<ConstraintLayout.Vfl>`.
- */
-export type ConstraintVflProps = {
-    /** VFL lines describing the constraints between named widgets and guides. */
-    lines: string[];
-    /** Default horizontal spacing used by the layout operator (defaults to 0). */
-    hspacing?: number;
-    /** Default vertical spacing used by the layout operator (defaults to 0). */
-    vspacing?: number;
-};
-
-const SUPER_ID = "super";
-
-const unknownIdMessage = (role: string, id: string): string =>
-    `<ConstraintLayout.Constraint> references unknown id '${id}'. ` +
-    `Set name="${id}" on the ${role} widget, or add a <ConstraintLayout.Guide id="${id}">.`;
-
-const guideRegistry = new WeakMap<Gtk.ConstraintLayout, Map<string, Gtk.ConstraintGuide>>();
-
-const guidesFor = (layout: Gtk.ConstraintLayout): Map<string, Gtk.ConstraintGuide> => {
-    let map = guideRegistry.get(layout);
-    if (!map) {
-        map = new Map<string, Gtk.ConstraintGuide>();
-        guideRegistry.set(layout, map);
-    }
-    return map;
-};
-
-const explicitWidgetName = (widget: Gtk.Widget): string | null => {
-    const value = new GObject.Value();
-    value.init(GObject.TYPE_STRING);
-    widget.getProperty("name", value);
-    const name = value.getString();
-    return name !== null && name.length > 0 ? name : null;
-};
-
-function* namedChildren(layout: Gtk.ConstraintLayout): Generator<[string, Gtk.Widget]> {
-    const host = layout.getWidget();
-    if (!host) return;
-    for (let child = host.getFirstChild(); child; child = child.getNextSibling()) {
-        const name = explicitWidgetName(child);
-        if (name !== null) yield [name, child];
-    }
-}
-
-const findChildByName = (layout: Gtk.ConstraintLayout, id: string): Gtk.Widget | undefined => {
-    for (const [name, child] of namedChildren(layout)) {
-        if (name === id) return child;
-    }
-    return undefined;
-};
-
-const resolveConstraintTarget = (
-    layout: Gtk.ConstraintLayout,
-    id: string | undefined,
-): Gtk.ConstraintTarget | null | undefined => {
-    if (id === undefined || id === SUPER_ID) return null;
-    return findChildByName(layout, id) ?? guidesFor(layout).get(id);
-};
-
-const constraintViews = (layout: Gtk.ConstraintLayout): Map<string, Gtk.ConstraintTarget> => {
-    const views = new Map<string, Gtk.ConstraintTarget>();
-    for (const [name, child] of namedChildren(layout)) views.set(name, child);
-    for (const [name, guide] of guidesFor(layout)) {
-        if (!views.has(name)) views.set(name, guide);
-    }
-    return views;
-};
-
-const isLayoutLive = (layout: Gtk.ConstraintLayout): boolean => layout.getWidget() !== null;
-
-export function applyConstraint(layout: Gtk.ConstraintLayout, props: ConstraintProps): () => void {
-    const target = resolveConstraintTarget(layout, props.target);
-    if (target === undefined) throw new Error(unknownIdMessage("target", String(props.target)));
-    const source = resolveConstraintTarget(layout, props.source);
-    if (source === undefined) throw new Error(unknownIdMessage("source", String(props.source)));
-
-    const constraint = new Gtk.Constraint({
-        target,
-        targetAttribute: props.targetAttribute,
-        relation: props.relation ?? Gtk.ConstraintRelation.EQ,
-        source,
-        sourceAttribute: props.sourceAttribute ?? Gtk.ConstraintAttribute.NONE,
-        multiplier: props.multiplier ?? 1,
-        constant: props.constant ?? 0,
-        strength: props.strength ?? Gtk.ConstraintStrength.REQUIRED,
-    });
-    layout.addConstraint(constraint);
-
-    return () => {
-        if (isLayoutLive(layout)) layout.removeConstraint(constraint);
-    };
-}
-
-export function applyVfl(layout: Gtk.ConstraintLayout, props: ConstraintVflProps): () => void {
-    const views = constraintViews(layout);
-    const constraints = layout.addConstraintsFromDescription(
-        props.lines,
-        props.hspacing ?? 0,
-        props.vspacing ?? 0,
-        views,
-    );
-
-    return () => {
-        if (!isLayoutLive(layout)) return;
-        for (const constraint of constraints) layout.removeConstraint(constraint);
-    };
-}
-
-export function applyGuide(layout: Gtk.ConstraintLayout, props: ConstraintGuideProps): () => void {
-    const guide = new Gtk.ConstraintGuide({
-        name: props.id,
-        minWidth: props.minWidth,
-        minHeight: props.minHeight,
-        natWidth: props.natWidth,
-        natHeight: props.natHeight,
-        maxWidth: props.maxWidth,
-        maxHeight: props.maxHeight,
-        strength: props.strength,
-    });
-    layout.addGuide(guide);
-    guidesFor(layout).set(props.id, guide);
-
-    return () => {
-        guidesFor(layout).delete(props.id);
-        if (isLayoutLive(layout)) layout.removeGuide(guide);
-    };
-}

package/src/constraint-layout.tsx

@@ -1,135 +0,0 @@
-import type * as Gtk from "@gtkx/gi/gtk";
-import { GtkConstraintLayout } from "@gtkx/jsx/gtk";
-import { useMergeRefs } from "@gtkx/react/internal";
-import {
-    type Context,
-    createContext,
-    type ReactNode,
-    type Ref,
-    type RefObject,
-    useContext,
-    useEffect,
-    useLayoutEffect,
-    useRef,
-} from "react";
-import {
-    applyConstraint,
-    applyGuide,
-    applyVfl,
-    type ConstraintGuideProps,
-    type ConstraintProps,
-    type ConstraintVflProps,
-} from "./constraint-layout-apply.js";
-
-const ORPHAN_MESSAGE = "<ConstraintLayout.Constraint> / <Guide> / <Vfl> must be a child of <ConstraintLayout>";
-
-const ConstraintLayoutContext: Context<RefObject<Gtk.ConstraintLayout | null> | null> =
-    createContext<RefObject<Gtk.ConstraintLayout | null> | null>(null);
-
-const useConstraintLayoutRef = (): RefObject<Gtk.ConstraintLayout | null> => {
-    const ref = useContext(ConstraintLayoutContext);
-    if (!ref) throw new Error(ORPHAN_MESSAGE);
-    return ref;
-};
-
-/** Props for {@link ConstraintLayout}. */
-export type ConstraintLayoutProps = {
-    children?: ReactNode;
-    ref?: Ref<Gtk.ConstraintLayout | null>;
-};
-
-type ContributionCleanupRef = { current: (() => void) | null };
-
-const cleanupContribution = (cleanupRef: ContributionCleanupRef): void => {
-    const cleanup = cleanupRef.current;
-    if (!cleanup) return;
-    cleanupRef.current = null;
-    cleanup();
-};
-
-const useLayoutContribution = (apply: (layout: Gtk.ConstraintLayout) => () => void, deps: unknown[]): void => {
-    const layoutRef = useConstraintLayoutRef();
-    useLayoutEffect(() => {
-        const layout = layoutRef.current;
-        if (!layout) return;
-        return apply(layout);
-    }, deps);
-};
-
-const useDeferredContribution = (apply: (layout: Gtk.ConstraintLayout) => () => void, deps: unknown[]): void => {
-    const layoutRef = useConstraintLayoutRef();
-    const cleanupRef = useRef<(() => void) | null>(null);
-
-    useLayoutEffect(() => () => cleanupContribution(cleanupRef), deps);
-
-    useEffect(() => {
-        const layout = layoutRef.current;
-        if (!layout) return;
-        const cleanup = apply(layout);
-        cleanupRef.current = cleanup;
-        return () => {
-            if (cleanupRef.current === cleanup) cleanupContribution(cleanupRef);
-        };
-    }, deps);
-};
-
-/**
- * Installs a Gtk.ConstraintLayout on a host widget and exposes child components to
- * populate it: {@link ConstraintProps | ConstraintLayout.Constraint} for individual constraints,
- * {@link ConstraintGuideProps | ConstraintLayout.Guide} for spacing guides, and {@link ConstraintVflProps | ConstraintLayout.Vfl}
- * for constraints authored in the Visual Format Language.
- */
-export const ConstraintLayout: ((props: ConstraintLayoutProps) => ReactNode) & {
-    Guide: (props: ConstraintGuideProps) => ReactNode;
-    Constraint: (props: ConstraintProps) => ReactNode;
-    Vfl: (props: ConstraintVflProps) => ReactNode;
-} = Object.assign(
-    ({ children, ref }: ConstraintLayoutProps): ReactNode => {
-        const layoutRef = useRef<Gtk.ConstraintLayout | null>(null);
-        const mergedRef = useMergeRefs<Gtk.ConstraintLayout>(ref, layoutRef);
-        return (
-            <>
-                <GtkConstraintLayout ref={mergedRef} />
-                <ConstraintLayoutContext.Provider value={layoutRef}>{children}</ConstraintLayoutContext.Provider>
-            </>
-        );
-    },
-    {
-        Guide: (props: ConstraintGuideProps): ReactNode => {
-            useLayoutContribution(
-                (layout) => applyGuide(layout, props),
-                [
-                    props.id,
-                    props.minWidth,
-                    props.minHeight,
-                    props.natWidth,
-                    props.natHeight,
-                    props.maxWidth,
-                    props.maxHeight,
-                    props.strength,
-                ],
-            );
-            return null;
-        },
-        Constraint: (props: ConstraintProps): ReactNode => {
-            useDeferredContribution(
-                (layout) => applyConstraint(layout, props),
-                [
-                    props.target,
-                    props.targetAttribute,
-                    props.relation,
-                    props.source,
-                    props.sourceAttribute,
-                    props.multiplier,
-                    props.constant,
-                    props.strength,
-                ],
-            );
-            return null;
-        },
-        Vfl: (props: ConstraintVflProps): ReactNode => {
-            useDeferredContribution((layout) => applyVfl(layout, props), [props.lines, props.hspacing, props.vspacing]);
-            return null;
-        },
-    },
-);

package/src/fixed.tsx

@@ -1,86 +0,0 @@
-import * as Graphene from "@gtkx/gi/graphene";
-import * as Gsk from "@gtkx/gi/gsk";
-import type * as Gtk from "@gtkx/gi/gtk";
-import { GtkFixed, type GtkFixedProps } from "@gtkx/jsx/gtk";
-import { useMergeRefs } from "@gtkx/react/internal";
-import {
-    createContext,
-    type ElementType,
-    type ReactNode,
-    type Ref,
-    type RefCallback,
-    useCallback,
-    useContext,
-    useLayoutEffect,
-    useRef,
-    useState,
-} from "react";
-import type { ChildProps } from "./types.js";
-
-const FixedContext = createContext<Gtk.Fixed | null | undefined>(undefined);
-
-const useFixedInstance = (): Gtk.Fixed | null => {
-    const fixed = useContext(FixedContext);
-    if (fixed === undefined) throw new Error("<Fixed.Child> must be a child of <Fixed>");
-    return fixed;
-};
-
-/** Props for {@link Fixed}. */
-export type FixedProps = GtkFixedProps & { ref?: Ref<Gtk.Fixed | null>; children?: ReactNode };
-
-export type FixedPlacementProps = {
-    x?: number | null | undefined;
-    y?: number | null | undefined;
-    /** Full transform applied to the child, overriding x and y when provided. */
-    transform?: Gsk.Transform | null | undefined;
-};
-
-/** Positions a single child inside a {@link Fixed} at coordinates x and y, or by an explicit transform. */
-export type FixedChildProps<C extends ElementType> = ChildProps<C, FixedPlacementProps>;
-
-const transformOf = (x: number, y: number, transform: Gsk.Transform | null | undefined): Gsk.Transform | null =>
-    transform !== undefined ? transform : Gsk.Transform.new().translate(Graphene.Point.create(x, y));
-
-const FixedChild = <C extends ElementType>({
-    component,
-    x,
-    y,
-    transform,
-    ref,
-    ...rest
-}: FixedChildProps<C>): ReactNode => {
-    const fixed = useFixedInstance();
-    const Component: ElementType = component;
-    const widgetRef = useRef<Gtk.Widget | null>(null);
-    const captureWidget = useCallback<RefCallback<Gtk.Widget>>((node) => {
-        widgetRef.current = node;
-    }, []);
-    const setWidget = useMergeRefs<Gtk.Widget>(ref, captureWidget);
-
-    useLayoutEffect(() => {
-        const widget = widgetRef.current;
-        if (widget === null || fixed === null) return;
-        fixed.setChildTransform(widget, transformOf(x ?? 0, y ?? 0, transform));
-    });
-
-    return <Component {...rest} ref={setWidget} />;
-};
-
-/**
- * Renders a Gtk.Fixed container whose children are placed at explicit positions via
- * {@link Fixed.Child}.
- */
-export const Fixed: ((props: FixedProps) => ReactNode) & {
-    Child: <C extends ElementType>(props: FixedChildProps<C>) => ReactNode;
-} = Object.assign(
-    ({ children, ref, ...rest }: FixedProps): ReactNode => {
-        const [fixed, setFixed] = useState<Gtk.Fixed | null>(null);
-        const mergedRef = useMergeRefs<Gtk.Fixed>(ref, setFixed);
-        return (
-            <GtkFixed {...rest} ref={mergedRef}>
-                <FixedContext.Provider value={fixed}>{children}</FixedContext.Provider>
-            </GtkFixed>
-        );
-    },
-    { Child: FixedChild },
-);

package/src/grid.tsx

@@ -1,88 +0,0 @@
-import type * as Gtk from "@gtkx/gi/gtk";
-import { GtkGrid, type GtkGridProps } from "@gtkx/jsx/gtk";
-import { useMergeRefs } from "@gtkx/react/internal";
-import { Children, type ElementType, type ReactNode, type Ref, useRef } from "react";
-import { createParentContext, usePlacedChild } from "./hooks/use-placed-child.js";
-import type { ChildProps } from "./types.js";
-
-const { Context: GridContext, useParentRef: useGridRef } = createParentContext<Gtk.Grid>(
-    "<Grid.Child> must be a child of <Grid>",
-);
-
-/** Props for {@link Grid}. */
-export type GridProps = GtkGridProps & { ref?: Ref<Gtk.Grid | null>; children?: ReactNode };
-
-export type GridPlacement = {
-    column?: number | null | undefined;
-    row?: number | null | undefined;
-    /** Number of columns the child spans (defaults to 1). */
-    columnSpan?: number | null | undefined;
-    /** Number of rows the child spans (defaults to 1). */
-    rowSpan?: number | null | undefined;
-};
-
-/** Places a single child inside a {@link Grid} at a column and row, optionally spanning multiple cells. */
-export type GridChildProps<C extends ElementType> = ChildProps<C, GridPlacement>;
-
-type Placement = { column: number; row: number; columnSpan: number; rowSpan: number };
-
-const placementOf = (props: GridPlacement): Placement => ({
-    column: props.column ?? 0,
-    row: props.row ?? 0,
-    columnSpan: props.columnSpan ?? 1,
-    rowSpan: props.rowSpan ?? 1,
-});
-
-const samePlacement = (a: Placement, b: Placement): boolean =>
-    a.column === b.column && a.row === b.row && a.columnSpan === b.columnSpan && a.rowSpan === b.rowSpan;
-
-const GridChild = <C extends ElementType>({
-    component,
-    column,
-    row,
-    columnSpan,
-    rowSpan,
-    ref,
-    ...rest
-}: GridChildProps<C>): ReactNode => {
-    const gridRef = useGridRef();
-    const Component: ElementType = component;
-    return usePlacedChild<Gtk.Widget, Placement>({
-        render: (placeRef) => <Component {...rest} ref={placeRef} />,
-        ref,
-        placement: placementOf({ column, row, columnSpan, rowSpan }),
-        samePlacement,
-        place: (widget, placement, previous) => {
-            const grid = gridRef.current;
-            if (!grid) return;
-            if (previous !== undefined && widget.getParent() === grid) grid.remove(widget);
-            if (widget.getParent() !== grid) {
-                grid.attach(widget, placement.column, placement.row, placement.columnSpan, placement.rowSpan);
-            }
-        },
-        release: (widget) => {
-            const grid = gridRef.current;
-            if (grid && widget.getParent() === grid) grid.remove(widget);
-        },
-    });
-};
-
-/**
- * Renders a Gtk.Grid whose children are attached at explicit column/row positions via
- * {@link Grid.Child}.
- */
-export const Grid: ((props: GridProps) => ReactNode) & {
-    Child: <C extends ElementType>(props: GridChildProps<C>) => ReactNode;
-} = Object.assign(
-    ({ children, ref, ...rest }: GridProps): ReactNode => {
-        const gridRef = useRef<Gtk.Grid | null>(null);
-        const mergedRef = useMergeRefs<Gtk.Grid>(ref, gridRef);
-        return (
-            <>
-                <GtkGrid {...rest} ref={mergedRef} />
-                <GridContext.Provider value={gridRef}>{Children.toArray(children)}</GridContext.Provider>
-            </>
-        );
-    },
-    { Child: GridChild },
-);

package/src/hooks/use-cell-containers.ts

@@ -1,93 +0,0 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import * as Gtk from "@gtkx/gi/gtk";
-import { type ObjectProp, useObjectAttachment } from "@gtkx/react/internal";
-import { useRef } from "react";
-import { CellContainerStore } from "../utils/cell-container-store.js";
-
-type ChildContainer = {
-    getChild(): Gtk.Widget | null;
-    setChild(child: Gtk.Widget | null): void;
-    getItem(): GObject.Object | null;
-};
-
-const isChildContainer = (container: GObject.Object): container is GObject.Object & ChildContainer =>
-    container instanceof Gtk.ListItem || container instanceof Gtk.ListHeader;
-
-const positionOf = (container: GObject.Object & ChildContainer): number => {
-    if (container instanceof Gtk.ListItem) return container.getPosition();
-    if (container instanceof Gtk.ListHeader) return container.getStart();
-    return -1;
-};
-
-export type FactoryInstaller<W extends GObject.Object> = {
-    install(widget: W, factory: Gtk.SignalListItemFactory): void;
-    uninstall(widget: W): void;
-};
-
-export const makeFactoryInstaller = <W extends GObject.Object>(
-    setFactory: (widget: W, factory: Gtk.SignalListItemFactory | null) => void,
-): FactoryInstaller<W> => ({
-    install: (widget, factory) => setFactory(widget, factory),
-    uninstall: (widget) => setFactory(widget, null),
-});
-
-type CellContainersOptions<W extends GObject.Object> = {
-    object: ObjectProp<W>;
-    installer: FactoryInstaller<W>;
-    estimatedHeight?: number | undefined;
-    estimatedWidth?: number | undefined;
-};
-
-const applyEstimatedSize = (child: Gtk.Widget, height: number | undefined, width: number | undefined): void => {
-    if (height === undefined && width === undefined) return;
-    child.setSizeRequest(width ?? -1, height ?? -1);
-};
-
-export const useCellContainers = <W extends GObject.Object>(options: CellContainersOptions<W>): CellContainerStore => {
-    const { object, installer, estimatedHeight, estimatedWidth } = options;
-    const storeRef = useRef<CellContainerStore | null>(null);
-    if (storeRef.current === null) storeRef.current = new CellContainerStore();
-    const store = storeRef.current;
-
-    const installerRef = useRef(installer);
-    installerRef.current = installer;
-
-    const factoryRef = useRef<Gtk.SignalListItemFactory | null>(null);
-    if (factoryRef.current === null) {
-        const factory = Gtk.SignalListItemFactory.new();
-        factory.on("setup", (container) => {
-            if (isChildContainer(container) && container.getChild() === null) {
-                const placeholder = new Gtk.Box();
-                applyEstimatedSize(placeholder, estimatedHeight, estimatedWidth);
-                container.setChild(placeholder);
-            }
-            store.addContainer(container);
-        });
-        factory.on("bind", (container) => {
-            if (isChildContainer(container)) {
-                const item = container.getItem();
-                const treeRow = item instanceof Gtk.TreeListRow ? item : null;
-                store.bind(container, positionOf(container), treeRow);
-            }
-        });
-        factory.on("unbind", (container) => {
-            store.unbind(container);
-        });
-        factory.on("teardown", (container) => {
-            store.removeContainer(container);
-        });
-        factoryRef.current = factory;
-    }
-    const factory = factoryRef.current;
-
-    useObjectAttachment<W, { widget: W }>(object, {
-        attach: (widget) => {
-            installerRef.current.install(widget, factory);
-            return { widget };
-        },
-        detach: (attachment) => installerRef.current.uninstall(attachment.widget),
-        isSame: (attachment, widget) => attachment.widget === widget,
-    });
-
-    return store;
-};