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

package/src/utils/cell-container-store.ts

@@ -1,114 +0,0 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type * as Gtk from "@gtkx/gi/gtk";
-
-export type CellEntry = {
-    position: number;
-    treeRow: Gtk.TreeListRow | null;
-};
-
-let nextKey = 0;
-
-export class CellContainerStore {
-    private entries = new Map<GObject.Object, CellEntry>();
-
-    private published = new Map<GObject.Object, CellEntry>();
-
-    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);
-        };
-    };
-
-    getContainersSnapshot = (): 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): CellEntry => {
-        let entry = this.published.get(container);
-        if (entry === undefined) {
-            entry = { position: -1, treeRow: 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 = `cell-${nextKey++}`;
-        this.keys.set(container, key);
-        return key;
-    };
-
-    addContainer = (container: GObject.Object): void => {
-        if (this.entries.has(container)) return;
-        this.entries.set(container, { position: -1, treeRow: null });
-        this.notifySet();
-    };
-
-    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, { position: -1, treeRow: 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();
-    }
-}

package/src/utils/item-models.ts

@@ -1,113 +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 { ItemNode, SectionNode } from "../types.js";
-import type { RowValue } from "./item-resolver.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>(
-    items: ItemNode<T>[],
-    rowValues: WeakMap<GObject.Object, RowValue<T>>,
-    placeholdersById: Map<string, GObject.Object>,
-): 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,
-                    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>(
-    row: RowValue<T>,
-    rowValues: WeakMap<GObject.Object, RowValue<T>>,
-    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>(
-    children: ItemNode<T>[],
-    rowValues: WeakMap<GObject.Object, RowValue<T>>,
-    placeholdersById: Map<string, GObject.Object>,
-): Gio.ListStore => {
-    const store = Gio.ListStore.new(Gtk.StringObject.prototype.__type__);
-    for (const child of children) {
-        store.append(
-            createTaggedRow(
-                { id: child.id, value: child.value, metadata: treeItemMetadata(child) },
-                rowValues,
-                placeholdersById,
-            ),
-        );
-    }
-    return store;
-};
-
-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, 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, 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, false, createFunc);
-};
-
-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(store);
-};

package/src/utils/item-resolver.ts

@@ -1,138 +0,0 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type * as Gtk from "@gtkx/gi/gtk";
-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 };
-
-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 type Resolved<T = unknown, S = unknown> = {
-    value: T | S | undefined;
-    present: boolean;
-    isHeader: boolean;
-    metadata: TreeItemMetadata;
-};
-
-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;
-};
-
-export type RowValue<T = unknown> = {
-    id: string;
-    value: T;
-    metadata: TreeItemMetadata;
-};
-
-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>>,
-): ItemResolver<T, S> => {
-    const flattened = flattenListItems(items, flattenTreeChildren);
-    return {
-        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): 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: false,
-                            metadata: tagged.metadata,
-                        };
-                    }
-                }
-            }
-            const record = flattened.records[position];
-            if (record === undefined) {
-                return {
-                    value: undefined,
-                    present: false,
-                    isHeader: false,
-                    metadata: NO_TREE_METADATA,
-                };
-            }
-            return {
-                value: record.value,
-                present: true,
-                isHeader: false,
-                metadata: record.metadata,
-            };
-        },
-    };
-};
-
-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 sections ?? []) {
-        valueByStart.set(start, section.value);
-        start += countDescendants(section.data);
-    }
-    return {
-        positionOfId: () => -1,
-        idOf: () => undefined,
-        resolve(position: number): Resolved<T, S> {
-            if (!valueByStart.has(position)) {
-                return { value: undefined, present: false, isHeader: true, metadata: NO_TREE_METADATA };
-            }
-            return {
-                value: valueByStart.get(position),
-                present: true,
-                isHeader: true,
-                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;
-        },
-    };
-};

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

@@ -1,90 +0,0 @@
-import type { ItemNode } from "../types.js";
-
-export type TreeItemMetadata = {
-    hideExpander: boolean;
-    indentForDepth: boolean;
-    indentForIcon: boolean;
-};
-
-type FlattenedRecord<T = unknown> = {
-    id: string;
-    value: T;
-    metadata: TreeItemMetadata;
-};
-
-type FlattenResult<T = unknown> = {
-    records: FlattenedRecord<T>[];
-    idToPosition: Map<string, number>;
-    positionToId: Map<number, string>;
-};
-
-export type ListStructure = "flat" | "tree";
-
-export const detectStructure = <T>(items: ItemNode<T>[] | undefined): ListStructure => {
-    if (items === undefined) return "flat";
-    for (const item of items) {
-        if (item.children !== undefined && item.children.length > 0) return "tree";
-    }
-    return "flat";
-};
-
-export const structuralSignature = <T>(items: ItemNode<T>[] | undefined): string => {
-    if (items === undefined) return "";
-    const parts: string[] = [];
-    const walk = (list: ItemNode<T>[]): void => {
-        parts.push("[");
-        for (const item of list) {
-            const hidden = item.hideExpander === true;
-            parts.push(`${item.id}|${hidden ? 1 : 0}`);
-            if (item.children !== undefined && item.children.length > 0) walk(item.children);
-        }
-        parts.push("]");
-    };
-    walk(items);
-    return parts.join(",");
-};
-
-export const countDescendants = <T>(items: ItemNode<T>[]): number => {
-    let total = 0;
-    for (const item of items) {
-        total += 1;
-        if (item.children !== undefined && item.children.length > 0) total += countDescendants(item.children);
-    }
-    return total;
-};
-
-export const treeItemMetadata = <T>(item: ItemNode<T>): TreeItemMetadata => ({
-    hideExpander: item.hideExpander ?? false,
-    indentForDepth: item.indentForDepth ?? true,
-    indentForIcon: item.indentForIcon ?? true,
-});
-
-const appendRecord = <T>(item: ItemNode<T>, result: FlattenResult<T>, 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,
-        metadata: treeItemMetadata(item),
-    });
-    if (includeChildren && item.children !== undefined) {
-        for (const child of item.children) appendRecord(child, result, includeChildren);
-    }
-};
-
-export const flattenListItems = <T>(
-    items: ItemNode<T>[] | undefined,
-    flattenTreeChildren: boolean,
-): FlattenResult<T> => {
-    const result: FlattenResult<T> = {
-        records: [],
-        idToPosition: new Map(),
-        positionToId: new Map(),
-    };
-    if (items === undefined) return result;
-    for (const item of items) {
-        appendRecord(item, result, flattenTreeChildren);
-    }
-    return result;
-};