@gtkx/components 0.21.0 → 1.0.0-rc.2

package/src/utils/item-resolver.ts

@@ -1,143 +0,0 @@
-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";
-
-const NO_TREE_METADATA: TreeItemMetadata = { hideExpander: false, indentForDepth: true, indentForIcon: true };
-
-const treeItemCache = new WeakMap<Gtk.TreeListRow, GObject.Object>();
-
-const treeRowItem = (treeRow: Gtk.TreeListRow): GObject.Object | null => {
-    const cached = treeItemCache.get(treeRow);
-    if (cached !== undefined) return cached;
-    const item = treeRow.getItem();
-    if (item !== null) treeItemCache.set(treeRow, item);
-    return item;
-};
-
-export interface 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;
-    idOf(position: number): string | undefined;
-    count: number;
-}
-
-export interface RowValue<T = unknown, S = unknown> {
-    id: string;
-    value: T | S;
-    isHeader: boolean;
-    metadata: TreeItemMetadata;
-}
-
-export const createControlledResolver = <T, S>(
-    items: ListItem<T, S>[] | undefined,
-    flattenTreeChildren: boolean,
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
-): ItemResolver<T, S> => {
-    const flattened = flattenListItems(items, flattenTreeChildren);
-    return {
-        count: flattened.records.length,
-        positionOf(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> {
-            if (treeRow !== null && !flattenTreeChildren) {
-                const rowItem = treeRowItem(treeRow);
-                if (rowItem !== null) {
-                    const tagged = rowValues.get(rowItem);
-                    if (tagged !== undefined) {
-                        return {
-                            value: tagged.value,
-                            present: true,
-                            isHeader: tagged.isHeader,
-                            treeRow,
-                            metadata: tagged.metadata,
-                        };
-                    }
-                }
-            }
-            const record = flattened.records[position];
-            if (record === undefined) {
-                return {
-                    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,
-            };
-        },
-    };
-};
-
-export const createSectionHeaderResolver = <T, S>(items: ListItem<T, S>[] | undefined): ItemResolver<T, S> => {
-    const valueByStart = new Map<number, S>();
-    let start = 0;
-    for (const section of items ?? []) {
-        if (section.section !== true) continue;
-        valueByStart.set(start, section.value);
-        start += section.children?.length ?? 0;
-    }
-    return {
-        count: valueByStart.size,
-        positionOf: () => -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: valueByStart.get(position),
-                present: true,
-                isHeader: true,
-                treeRow: null,
-                metadata: NO_TREE_METADATA,
-            };
-        },
-    };
-};

package/src/utils/list-item-flatten.ts

@@ -1,113 +0,0 @@
-import type { ListItem } from "../types.js";
-
-export interface TreeItemMetadata {
-    hideExpander: boolean;
-    indentForDepth: boolean;
-    indentForIcon: boolean;
-}
-
-export interface FlattenedRecord<T = unknown, S = unknown> {
-    id: string;
-    value: T | S;
-    isHeader: boolean;
-    hasChildren: boolean;
-    children: ListItem<T, S>[];
-    metadata: TreeItemMetadata;
-}
-
-export interface FlattenResult<T = unknown, S = unknown> {
-    records: FlattenedRecord<T, S>[];
-    idToPosition: Map<string, number>;
-    positionToId: Map<number, string>;
-    isTree: boolean;
-    isSectioned: boolean;
-}
-
-export type ListStructure = "flat" | "tree" | "sections";
-
-/**
- * Classify a controlled item list as flat, tree, or sectioned without building a
- * {@link FlattenResult}. A list is sectioned if any top-level item is a section, a
- * tree if any top-level item carries children, and flat otherwise.
- */
-export const detectStructure = <T, S>(items: ListItem<T, S>[] | undefined): ListStructure => {
-    if (items === undefined) return "flat";
-    let sawTree = false;
-    for (const item of items) {
-        if (item.section === true) return "sections";
-        if (item.children !== undefined && item.children.length > 0) sawTree = true;
-    }
-    return sawTree ? "tree" : "flat";
-};
-
-export const structuralSignature = <T, S>(items: ListItem<T, S>[] | undefined): string => {
-    if (items === undefined) return "";
-    const parts: string[] = [];
-    const walk = (list: ListItem<T, S>[]): void => {
-        parts.push("[");
-        for (const item of list) {
-            const hidden = item.section === true ? false : item.hideExpander === true;
-            parts.push(`${item.id}|${item.section === true ? 1 : 0}|${hidden ? 1 : 0}`);
-            if (item.children !== undefined && item.children.length > 0) walk(item.children);
-        }
-        parts.push("]");
-    };
-    walk(items);
-    return parts.join(",");
-};
-
-export const treeItemMetadata = <T, S>(item: ListItem<T, S>): TreeItemMetadata => {
-    if (item.section === true) {
-        return { hideExpander: false, indentForDepth: false, indentForIcon: false };
-    }
-    return {
-        hideExpander: item.hideExpander ?? false,
-        indentForDepth: item.indentForDepth ?? true,
-        indentForIcon: item.indentForIcon ?? true,
-    };
-};
-
-const hasChildren = <T, S>(item: ListItem<T, S>): boolean => item.children !== undefined && item.children.length > 0;
-
-const appendRecord = <T, S>(item: ListItem<T, S>, result: FlattenResult<T, S>, includeChildren: boolean): void => {
-    const position = result.records.length;
-    result.idToPosition.set(item.id, position);
-    result.positionToId.set(position, item.id);
-    result.records.push({
-        id: item.id,
-        value: item.value,
-        isHeader: item.section === true,
-        hasChildren: hasChildren(item),
-        children: item.children ?? [],
-        metadata: treeItemMetadata(item),
-    });
-    if (includeChildren && item.children !== undefined) {
-        for (const child of item.children) appendRecord(child, result, includeChildren);
-    }
-};
-
-export const flattenListItems = <T, S>(
-    items: ListItem<T, S>[] | undefined,
-    flattenTreeChildren: boolean,
-): FlattenResult<T, S> => {
-    const result: FlattenResult<T, S> = {
-        records: [],
-        idToPosition: new Map(),
-        positionToId: new Map(),
-        isTree: false,
-        isSectioned: false,
-    };
-    if (items === undefined) return result;
-    for (const item of items) {
-        if (item.section === true) {
-            result.isSectioned = true;
-            if (item.children !== undefined) {
-                for (const child of item.children) appendRecord(child, result, true);
-            }
-            continue;
-        }
-        if (hasChildren(item)) result.isTree = true;
-        appendRecord(item, result, flattenTreeChildren);
-    }
-    return result;
-};

package/src/utils/position-only-model.ts

@@ -1,115 +0,0 @@
-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 { RowValue } from "./item-resolver.js";
-import { 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>>,
-    placeholdersById: Map<string, GObject.Object>,
-): void => {
-    const walk = (list: ListItem<T, S>[]): 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),
-                });
-            }
-            if (item.children !== undefined && item.children.length > 0) walk(item.children);
-        }
-    };
-    walk(items);
-};
-
-export const createFlatModel = (count: number): Gtk.StringList => Gtk.StringList.new(emptyStrings(count));
-
-export const resizeFlatModel = (model: Gtk.StringList, count: number): void => {
-    const target = Math.max(0, count);
-    const current = model.getNItems();
-    if (current === target) return;
-    if (target > current) {
-        model.splice(current, 0, emptyStrings(target - current));
-        return;
-    }
-    model.splice(target, current - target, null);
-};
-
-const createTaggedRow = <T, S>(
-    row: RowValue<T, S>,
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
-    placeholdersById?: Map<string, GObject.Object>,
-): GObject.Object => {
-    const placeholder = Gtk.StringObject.new("");
-    rowValues.set(placeholder, row);
-    if (placeholdersById !== undefined) placeholdersById.set(row.id, placeholder);
-    return placeholder;
-};
-
-const childModelOf = <T, S>(
-    children: ListItem<T, S>[],
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
-    placeholdersById: Map<string, GObject.Object>,
-): Gio.ListStore => {
-    const store = Gio.ListStore.new(Gtk.StringObject.prototype.__gtype__);
-    for (const child of children) {
-        store.append(
-            createTaggedRow(
-                { id: child.id, value: child.value, isHeader: false, metadata: treeItemMetadata(child) },
-                rowValues,
-                placeholdersById,
-            ),
-        );
-    }
-    return store;
-};
-
-export const createTreeModel = <T, S>(
-    items: ListItem<T, S>[],
-    autoexpand: boolean,
-    rowValues: WeakMap<GObject.Object, RowValue<T, S>>,
-    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__);
-    for (const item of items) {
-        const placeholder = createTaggedRow(
-            { id: item.id, value: item.value, isHeader: item.section === true, metadata: treeItemMetadata(item) },
-            rowValues,
-            placeholdersById,
-        );
-        if (item.children !== undefined && item.children.length > 0) {
-            childrenByRow.set(placeholder, item.children);
-        }
-        root.append(placeholder);
-    }
-    const createFunc = (rowItem: GObject.Object): Gio.ListModel | null => {
-        const children = childrenByRow.get(rowItem);
-        if (children === undefined) return null;
-        const store = childModelOf(children, rowValues, placeholdersById);
-        for (let index = 0; index < children.length; index++) {
-            const child = children[index];
-            if (child !== undefined && child.children !== undefined && child.children.length > 0) {
-                const placeholder = store.getItem(index);
-                if (placeholder !== null) childrenByRow.set(placeholder, child.children);
-            }
-        }
-        return store;
-    };
-    return Gtk.TreeListModel.new(root, false, autoexpand, 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)));
-    }
-    return Gtk.FlattenListModel.new(sections);
-};

package/src/utils/realized-slot-store.ts

@@ -1,126 +0,0 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type * as Gtk from "@gtkx/gi/gtk";
-
-export interface SlotEntry {
-    container: GObject.Object;
-    position: number;
-    treeRow: Gtk.TreeListRow | null;
-    item: GObject.Object | null;
-}
-
-let nextKey = 0;
-
-export class RealizedSlotStore {
-    private entries = new Map<GObject.Object, SlotEntry>();
-
-    private published = new Map<GObject.Object, SlotEntry>();
-
-    private setListeners = new Set<() => void>();
-
-    private positionListeners = new Map<GObject.Object, Set<() => void>>();
-
-    private positionFlushers = new Map<GObject.Object, () => void>();
-
-    private keys = new WeakMap<GObject.Object, string>();
-
-    private snapshot: GObject.Object[] = [];
-
-    subscribeSet = (onChange: () => void): (() => void) => {
-        this.setListeners.add(onChange);
-        return () => {
-            this.setListeners.delete(onChange);
-        };
-    };
-
-    getSlotsSnapshot = (): GObject.Object[] => this.snapshot;
-
-    subscribePosition = (container: GObject.Object, onChange: () => void): (() => void) => {
-        let listeners = this.positionListeners.get(container);
-        if (listeners === undefined) {
-            listeners = new Set();
-            this.positionListeners.set(container, listeners);
-        }
-        listeners.add(onChange);
-        return () => {
-            const current = this.positionListeners.get(container);
-            if (current === undefined) return;
-            current.delete(onChange);
-            if (current.size === 0) this.positionListeners.delete(container);
-        };
-    };
-
-    getPosition = (container: GObject.Object): SlotEntry => {
-        let entry = this.published.get(container);
-        if (entry === undefined) {
-            entry = { container, position: -1, treeRow: null, item: null };
-            this.published.set(container, entry);
-        }
-        return entry;
-    };
-
-    keyFor = (container: GObject.Object): string => {
-        const existing = this.keys.get(container);
-        if (existing !== undefined) return existing;
-        const key = `slot-${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.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 });
-        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.notifyPosition(container);
-    };
-
-    removeContainer = (container: GObject.Object): void => {
-        if (!this.entries.delete(container)) return;
-        this.published.delete(container);
-        this.positionFlushers.delete(container);
-        this.notifySet();
-    };
-
-    private flushSet = (): void => {
-        this.snapshot = [...this.entries.keys()];
-        for (const listener of [...this.setListeners]) listener();
-    };
-
-    private notifySet(): void {
-        this.flushSet();
-    }
-
-    private notifyPosition(container: GObject.Object): void {
-        let flush = this.positionFlushers.get(container);
-        if (flush === undefined) {
-            flush = (): void => {
-                const live = this.entries.get(container);
-                if (live !== undefined) this.published.set(container, live);
-                const listeners = this.positionListeners.get(container);
-                if (listeners === undefined) return;
-                for (const listener of [...listeners]) listener();
-            };
-            this.positionFlushers.set(container, flush);
-        }
-        flush();
-    }
-}