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

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;
-};

package/src/hooks/use-collection-model.ts

@@ -1,60 +0,0 @@
-import type * as Gtk from "@gtkx/gi/gtk";
-import { type ReactNode, useCallback } from "react";
-import type { ItemNode, SectionNode } from "../types.js";
-import { type ItemResolver, rowIdOf } from "../utils/item-resolver.js";
-import { useExpansionModel } from "./use-expansion-model.js";
-import { useListModel } from "./use-list-model.js";
-import { useSelectionModel } from "./use-selection-model.js";
-
-type CollectionModelInput<T, S> = {
-    items: ItemNode<T>[] | undefined;
-    sections: SectionNode<S, T>[] | undefined;
-    selectionMode: Gtk.SelectionMode | null | undefined;
-    selectedIds: string[] | null | undefined;
-    onSelectionChanged: ((ids: string[]) => void) | null | undefined;
-    expandedIds?: string[] | null | undefined;
-    onExpandedChange?: ((ids: string[]) => void) | null | undefined;
-    renderHeader: ((info: { section: S }) => ReactNode) | null | undefined;
-};
-
-export type CollectionModelResult<T, S> = {
-    resolver: ItemResolver<T, S>;
-    headerResolver: ItemResolver<T, S>;
-    installedModel: Gtk.SelectionModel;
-    useHeader: boolean;
-    rowId: (row: Gtk.TreeListRow) => string | undefined;
-};
-
-export const useCollectionModel = <T, S>(input: CollectionModelInput<T, S>): CollectionModelResult<T, S> => {
-    const listModel = useListModel<T, S>({
-        items: input.items,
-        sections: input.sections,
-    });
-
-    useExpansionModel<T>({
-        treeModel: listModel.treeModel,
-        rowValues: listModel.rowValues,
-        expandedIds: input.expandedIds,
-        onExpandedChange: input.onExpandedChange,
-    });
-
-    const installedModel = useSelectionModel<T, S>({
-        base: listModel.model,
-        resolver: listModel.resolver,
-        selectionMode: input.selectionMode,
-        selectedIds: input.selectedIds,
-        onSelectionChanged: input.onSelectionChanged,
-    });
-
-    const useHeader = typeof input.renderHeader === "function";
-    const { rowValues } = listModel;
-    const rowId = useCallback((row: Gtk.TreeListRow): string | undefined => rowIdOf(rowValues, row), [rowValues]);
-
-    return {
-        resolver: listModel.resolver,
-        headerResolver: listModel.headerResolver,
-        installedModel,
-        useHeader,
-        rowId,
-    };
-};

package/src/hooks/use-collection-widget.ts

@@ -1,47 +0,0 @@
-import type * as Gtk from "@gtkx/gi/gtk";
-import { useMergeRefs } from "@gtkx/react/internal";
-import { type ReactNode, type Ref, type RefCallback, type RefObject, useRef } from "react";
-import type { ItemNode, SectionNode } from "../types.js";
-import { type CollectionModelResult, useCollectionModel } from "./use-collection-model.js";
-import { useInstalledModel } from "./use-installed-model.js";
-
-type CollectionWidget = Gtk.Widget & {
-    setModel(model: Gtk.SelectionModel | null): void;
-};
-
-type CollectionWidgetInput<W extends CollectionWidget, T, S> = {
-    ref?: Ref<W | null> | undefined;
-    items?: ItemNode<T>[] | undefined;
-    sections?: SectionNode<S, T>[] | undefined;
-    selectionMode?: Gtk.SelectionMode | null | undefined;
-    selectedIds?: string[] | null | undefined;
-    onSelectionChanged?: ((ids: string[]) => void) | null | undefined;
-    expandedIds?: string[] | null | undefined;
-    onExpandedChange?: ((ids: string[]) => void) | null | undefined;
-    renderHeader?: ((info: { section: S }) => ReactNode) | null | undefined;
-};
-
-type CollectionWidgetResult<W extends CollectionWidget, T, S> = {
-    widgetRef: RefObject<W | null>;
-    setRef: RefCallback<W>;
-    collection: CollectionModelResult<T, S>;
-};
-
-export const useCollectionWidget = <W extends CollectionWidget, T, S>(
-    props: CollectionWidgetInput<W, T, S>,
-): CollectionWidgetResult<W, T, S> => {
-    const widgetRef = useRef<W | null>(null);
-    const setRef = useMergeRefs<W>(props.ref, widgetRef);
-    const collection = useCollectionModel<T, S>({
-        items: props.items,
-        sections: props.sections,
-        selectionMode: props.selectionMode,
-        selectedIds: props.selectedIds,
-        onSelectionChanged: props.onSelectionChanged,
-        expandedIds: props.expandedIds,
-        onExpandedChange: props.onExpandedChange,
-        renderHeader: props.renderHeader,
-    });
-    useInstalledModel(widgetRef, collection.installedModel, (widget, model) => widget.setModel(model));
-    return { widgetRef, setRef, collection };
-};

package/src/hooks/use-drop-down-selection.ts

@@ -1,52 +0,0 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import * as Gtk from "@gtkx/gi/gtk";
-import { useSignal } from "@gtkx/react";
-import { type ObjectProp, resolveObjectProp, useObjectValue } from "@gtkx/react/internal";
-import { useLayoutEffect, useRef } from "react";
-import type { ItemResolver } from "../utils/item-resolver.js";
-
-type DropDownSelectionObject = GObject.Object & {
-    getSelected(): number;
-    setSelected(position: number): void;
-};
-
-type DropDownSelectionOptions<T, S> = {
-    widget: ObjectProp<DropDownSelectionObject>;
-    resolver: ItemResolver<T, S>;
-    selectedId: string | null | undefined;
-    onSelectionChanged: ((id: string) => void) | null | undefined;
-};
-
-const normalizeSelected = (position: number): number =>
-    position === Gtk.INVALID_LIST_POSITION || position < 0 ? -1 : position;
-
-export const useDropDownSelection = <T, S>(options: DropDownSelectionOptions<T, S>): number => {
-    const { widget, resolver, selectedId, onSelectionChanged } = options;
-    const resolved = resolveObjectProp(widget);
-
-    const selectedPosition = useObjectValue(widget, "notify::selected", (object) =>
-        object === null ? -1 : normalizeSelected(object.getSelected()),
-    );
-
-    const resolverRef = useRef(resolver);
-    resolverRef.current = resolver;
-    const onSelectionChangedRef = useRef(onSelectionChanged);
-    onSelectionChangedRef.current = onSelectionChanged;
-
-    useLayoutEffect(() => {
-        if (resolved === null || selectedId === undefined || selectedId === null) return;
-        const position = resolverRef.current.positionOfId(selectedId);
-        if (position < 0) return;
-        if (normalizeSelected(resolved.getSelected()) !== position) resolved.setSelected(position);
-    }, [resolved, selectedId, resolver]);
-
-    useSignal(widget, "notify::selected", () => {
-        if (resolved === null) return;
-        const position = normalizeSelected(resolved.getSelected());
-        if (position < 0) return;
-        const id = resolverRef.current.idOf(position);
-        if (id !== undefined) onSelectionChangedRef.current?.(id);
-    });
-
-    return selectedPosition;
-};

package/src/hooks/use-expansion-model.ts

@@ -1,82 +0,0 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type * as Gtk from "@gtkx/gi/gtk";
-import { useSignal } from "@gtkx/react";
-import { isSameArray } from "@gtkx/utils";
-import { useLayoutEffect, useRef } from "react";
-import { type RowValue, rowIdOf } from "../utils/item-resolver.js";
-
-type ExpansionModelOptions<T> = {
-    treeModel: Gtk.TreeListModel | null;
-    rowValues: WeakMap<GObject.Object, RowValue<T>>;
-    expandedIds: string[] | null | undefined;
-    onExpandedChange: ((ids: string[]) => void) | null | undefined;
-};
-
-const readExpandedIds = <T>(model: Gtk.TreeListModel, rowValues: WeakMap<GObject.Object, RowValue<T>>): string[] => {
-    const ids: string[] = [];
-    const count = model.getNItems();
-    for (let position = 0; position < count; position++) {
-        const row = model.getRow(position);
-        if (row?.getExpanded()) {
-            const id = rowIdOf(rowValues, row);
-            if (id !== undefined) ids.push(id);
-        }
-    }
-    return ids;
-};
-
-const applyExpanded = <T>(
-    model: Gtk.TreeListModel,
-    rowValues: WeakMap<GObject.Object, RowValue<T>>,
-    ids: string[],
-): void => {
-    const target = new Set(ids);
-    let changed = true;
-    while (changed) {
-        changed = false;
-        const count = model.getNItems();
-        for (let position = 0; position < count; position++) {
-            const row = model.getRow(position);
-            if (row === null || !row.isExpandable()) continue;
-            const id = rowIdOf(rowValues, row);
-            if (id === undefined) continue;
-            const desired = target.has(id);
-            if (row.getExpanded() !== desired) {
-                row.setExpanded(desired);
-                changed = true;
-            }
-        }
-    }
-};
-
-export const useExpansionModel = <T>(options: ExpansionModelOptions<T>): void => {
-    const { treeModel, rowValues, expandedIds, onExpandedChange } = options;
-    const onChangeRef = useRef(onExpandedChange);
-    onChangeRef.current = onExpandedChange;
-    const rowValuesRef = useRef(rowValues);
-    rowValuesRef.current = rowValues;
-    const lastReportedRef = useRef<string[] | null>(null);
-    const applyingRef = useRef(false);
-
-    const report = (): void => {
-        if (treeModel === null || applyingRef.current) return;
-        const callback = onChangeRef.current;
-        if (!callback) return;
-        const ids = readExpandedIds(treeModel, rowValuesRef.current);
-        if (lastReportedRef.current !== null && isSameArray(lastReportedRef.current, ids)) return;
-        lastReportedRef.current = ids;
-        callback(ids);
-    };
-
-    useSignal(treeModel, "items-changed", report);
-
-    useLayoutEffect(() => {
-        if (treeModel === null) return;
-        if (expandedIds !== undefined && expandedIds !== null) {
-            applyingRef.current = true;
-            applyExpanded(treeModel, rowValuesRef.current, expandedIds);
-            applyingRef.current = false;
-        }
-        report();
-    }, [treeModel, expandedIds]);
-};

package/src/hooks/use-header-menu.ts

@@ -1,34 +0,0 @@
-import type * as Gio from "@gtkx/gi/gio";
-import type * as Gtk from "@gtkx/gi/gtk";
-import { createPortal, rootElement } from "@gtkx/react";
-import { useMergeRefs } from "@gtkx/react/internal";
-import {
-    cloneElement,
-    isValidElement,
-    type ReactElement,
-    type ReactNode,
-    type Ref,
-    type RefCallback,
-    useCallback,
-    useLayoutEffect,
-    useRef,
-} from "react";
-
-type MenuElement = ReactElement<{ ref?: Ref<Gio.MenuModel | null> }>;
-
-export const useHeaderMenu = (column: Gtk.ColumnViewColumn | null, headerMenu: ReactNode): ReactNode => {
-    const modelRef = useRef<Gio.MenuModel | null>(null);
-    const setModel = useCallback<RefCallback<Gio.MenuModel>>((model) => {
-        modelRef.current = model;
-    }, []);
-    const element = isValidElement(headerMenu) ? (headerMenu as MenuElement) : null;
-    const mergedRef = useMergeRefs<Gio.MenuModel>(setModel, element?.props.ref);
-
-    useLayoutEffect(() => {
-        if (column === null) return;
-        column.setHeaderMenu(headerMenu == null ? null : modelRef.current);
-    });
-
-    if (element === null) return null;
-    return createPortal(cloneElement(element, { ref: mergedRef }), rootElement);
-};