@gtkx/react 0.21.0 → 1.0.0-rc.1

package/src/nodes/grid-child.ts

@@ -1,116 +0,0 @@
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { GridChildProps } from "../jsx.js";
-import type { Node } from "../node.js";
-import { isRemovable } from "./internal/predicates.js";
-import { hasChanged } from "./internal/props.js";
-import { VirtualNode } from "./virtual.js";
-import { WidgetNode } from "./widget.js";
-
-export class GridChildNode extends VirtualNode<GridChildProps, WidgetNode<Gtk.Grid>, WidgetNode> {
-    public override isValidChild(child: Node): boolean {
-        return child instanceof WidgetNode;
-    }
-
-    public override isValidParent(parent: Node): boolean {
-        return parent instanceof WidgetNode && parent.container instanceof Gtk.Grid;
-    }
-
-    public override setParent(parent: WidgetNode<Gtk.Grid> | null): void {
-        if (!parent && this.parent && this.children[0]) {
-            this.detachFromParent(this.parent.container, this.children[0].container);
-        }
-
-        super.setParent(parent);
-
-        if (parent && this.children[0]) {
-            this.attachToParent(parent.container, this.children[0].container);
-        }
-    }
-
-    public override appendChild(child: WidgetNode): void {
-        super.appendChild(child);
-
-        if (this.parent) {
-            this.detachFromGtkParent(child.container);
-            this.attachToParent(this.parent.container, child.container);
-        }
-    }
-
-    public override removeChild(child: WidgetNode): void {
-        if (this.parent) {
-            this.detachFromParent(this.parent.container, child.container);
-        }
-
-        super.removeChild(child);
-    }
-
-    public override commitUpdate(oldProps: GridChildProps | null, newProps: GridChildProps): void {
-        super.commitUpdate(oldProps, newProps);
-
-        const positionChanged =
-            hasChanged(oldProps, newProps, "column") ||
-            hasChanged(oldProps, newProps, "row") ||
-            hasChanged(oldProps, newProps, "columnSpan") ||
-            hasChanged(oldProps, newProps, "rowSpan");
-
-        if (positionChanged && this.parent && this.children[0]) {
-            this.reattachChild();
-        }
-    }
-
-    public override detachDeletedInstance(): void {
-        if (this.parent && this.children[0]) {
-            this.detachFromParent(this.parent.container, this.children[0].container);
-        }
-        super.detachDeletedInstance();
-    }
-
-    private attachToParent(parent: Gtk.Grid, child: Gtk.Widget): void {
-        const column = this.props.column ?? 0;
-        const row = this.props.row ?? 0;
-        const columnSpan = this.props.columnSpan ?? 1;
-        const rowSpan = this.props.rowSpan ?? 1;
-
-        const existingChild = parent.getChildAt(column, row);
-        if (existingChild && existingChild !== child) {
-            parent.remove(existingChild);
-        }
-
-        parent.attach(child, column, row, columnSpan, rowSpan);
-    }
-
-    private detachFromParent(parent: Gtk.Grid, child: Gtk.Widget): void {
-        const childParent = child.getParent();
-        if (childParent && childParent === parent) {
-            parent.remove(child);
-        }
-    }
-
-    private detachFromGtkParent(child: Gtk.Widget): void {
-        const currentParent = child.getParent();
-        if (currentParent !== null) {
-            if (isRemovable(currentParent)) {
-                currentParent.remove(child);
-            } else {
-                child.unparent();
-            }
-        }
-    }
-
-    private reattachChild(): void {
-        if (!this.parent || !this.children[0]) return;
-
-        const column = this.props.column ?? 0;
-        const row = this.props.row ?? 0;
-        const columnSpan = this.props.columnSpan ?? 1;
-        const rowSpan = this.props.rowSpan ?? 1;
-
-        const existingChild = this.parent.container.getChildAt(column, row);
-        if (existingChild && existingChild !== this.children[0].container) {
-            this.parent.container.remove(existingChild);
-        }
-
-        this.parent.container.remove(this.children[0].container);
-        this.parent.container.attach(this.children[0].container, column, row, columnSpan, rowSpan);
-    }
-}

package/src/nodes/internal/accessible.ts

@@ -1,155 +0,0 @@
-import type * as GObject from "@gtkx/ffi/gobject";
-import { Value } from "@gtkx/ffi/gobject";
-import * as Gtk from "@gtkx/ffi/gtk";
-import type { Props } from "../../types.js";
-
-type CreateValue = (jsValue: unknown) => Value;
-
-type PropertyDef = {
-    kind: "property";
-    enumValue: Gtk.AccessibleProperty;
-    createValue: CreateValue;
-};
-
-type StateDef = {
-    kind: "state";
-    enumValue: Gtk.AccessibleState;
-    createValue: CreateValue;
-};
-
-type RelationDef = {
-    kind: "relation";
-    enumValue: Gtk.AccessibleRelation;
-    createValue: CreateValue;
-};
-
-type AccessiblePropDef = PropertyDef | StateDef | RelationDef;
-
-const fromString: CreateValue = (val) => Value.newFromString(val as string);
-const fromBoolean: CreateValue = (val) => Value.newFromBoolean(val as boolean);
-const fromInt: CreateValue = (val) => Value.newFromInt(val as number);
-const fromDouble: CreateValue = (val) => Value.newFromDouble(val as number);
-const fromObject: CreateValue = (val) => Value.newFromObject((val as GObject.Object) ?? null);
-
-const fromRefList: CreateValue = (val) => {
-    const widgets = val as Gtk.Accessible[];
-    const list = Gtk.AccessibleList.newFromList(widgets);
-    return Value.newFromBoxed(list);
-};
-
-const prop = (enumValue: Gtk.AccessibleProperty, createValue: CreateValue): PropertyDef => ({
-    kind: "property",
-    enumValue,
-    createValue,
-});
-
-const state = (enumValue: Gtk.AccessibleState, createValue: CreateValue): StateDef => ({
-    kind: "state",
-    enumValue,
-    createValue,
-});
-
-const relation = (enumValue: Gtk.AccessibleRelation, createValue: CreateValue): RelationDef => ({
-    kind: "relation",
-    enumValue,
-    createValue,
-});
-
-const ACCESSIBLE_PROP_MAP: Record<string, AccessiblePropDef> = {
-    accessibleAutocomplete: prop(Gtk.AccessibleProperty.AUTOCOMPLETE, fromInt),
-    accessibleDescription: prop(Gtk.AccessibleProperty.DESCRIPTION, fromString),
-    accessibleHasPopup: prop(Gtk.AccessibleProperty.HAS_POPUP, fromBoolean),
-    accessibleKeyShortcuts: prop(Gtk.AccessibleProperty.KEY_SHORTCUTS, fromString),
-    accessibleLabel: prop(Gtk.AccessibleProperty.LABEL, fromString),
-    accessibleLevel: prop(Gtk.AccessibleProperty.LEVEL, fromInt),
-    accessibleModal: prop(Gtk.AccessibleProperty.MODAL, fromBoolean),
-    accessibleMultiLine: prop(Gtk.AccessibleProperty.MULTI_LINE, fromBoolean),
-    accessibleMultiSelectable: prop(Gtk.AccessibleProperty.MULTI_SELECTABLE, fromBoolean),
-    accessibleOrientation: prop(Gtk.AccessibleProperty.ORIENTATION, fromInt),
-    accessiblePlaceholder: prop(Gtk.AccessibleProperty.PLACEHOLDER, fromString),
-    accessibleReadOnly: prop(Gtk.AccessibleProperty.READ_ONLY, fromBoolean),
-    accessibleRequired: prop(Gtk.AccessibleProperty.REQUIRED, fromBoolean),
-    accessibleRoleDescription: prop(Gtk.AccessibleProperty.ROLE_DESCRIPTION, fromString),
-    accessibleSort: prop(Gtk.AccessibleProperty.SORT, fromInt),
-    accessibleValueMax: prop(Gtk.AccessibleProperty.VALUE_MAX, fromDouble),
-    accessibleValueMin: prop(Gtk.AccessibleProperty.VALUE_MIN, fromDouble),
-    accessibleValueNow: prop(Gtk.AccessibleProperty.VALUE_NOW, fromDouble),
-    accessibleValueText: prop(Gtk.AccessibleProperty.VALUE_TEXT, fromString),
-    accessibleHelpText: prop(Gtk.AccessibleProperty.HELP_TEXT, fromString),
-
-    accessibleBusy: state(Gtk.AccessibleState.BUSY, fromBoolean),
-    accessibleChecked: state(Gtk.AccessibleState.CHECKED, fromInt),
-    accessibleDisabled: state(Gtk.AccessibleState.DISABLED, fromBoolean),
-    accessibleExpanded: state(Gtk.AccessibleState.EXPANDED, fromInt),
-    accessibleHidden: state(Gtk.AccessibleState.HIDDEN, fromBoolean),
-    accessibleInvalid: state(Gtk.AccessibleState.INVALID, fromInt),
-    accessiblePressed: state(Gtk.AccessibleState.PRESSED, fromInt),
-    accessibleSelected: state(Gtk.AccessibleState.SELECTED, fromInt),
-    accessibleVisited: state(Gtk.AccessibleState.VISITED, fromInt),
-
-    accessibleActiveDescendant: relation(Gtk.AccessibleRelation.ACTIVE_DESCENDANT, fromObject),
-    accessibleColCount: relation(Gtk.AccessibleRelation.COL_COUNT, fromInt),
-    accessibleColIndex: relation(Gtk.AccessibleRelation.COL_INDEX, fromInt),
-    accessibleColIndexText: relation(Gtk.AccessibleRelation.COL_INDEX_TEXT, fromString),
-    accessibleColSpan: relation(Gtk.AccessibleRelation.COL_SPAN, fromInt),
-    accessibleControls: relation(Gtk.AccessibleRelation.CONTROLS, fromRefList),
-    accessibleDescribedBy: relation(Gtk.AccessibleRelation.DESCRIBED_BY, fromRefList),
-    accessibleDetails: relation(Gtk.AccessibleRelation.DETAILS, fromRefList),
-    accessibleErrorMessage: relation(Gtk.AccessibleRelation.ERROR_MESSAGE, fromRefList),
-    accessibleFlowTo: relation(Gtk.AccessibleRelation.FLOW_TO, fromRefList),
-    accessibleLabelledBy: relation(Gtk.AccessibleRelation.LABELLED_BY, fromRefList),
-    accessibleOwns: relation(Gtk.AccessibleRelation.OWNS, fromRefList),
-    accessiblePosInSet: relation(Gtk.AccessibleRelation.POS_IN_SET, fromInt),
-    accessibleRowCount: relation(Gtk.AccessibleRelation.ROW_COUNT, fromInt),
-    accessibleRowIndex: relation(Gtk.AccessibleRelation.ROW_INDEX, fromInt),
-    accessibleRowIndexText: relation(Gtk.AccessibleRelation.ROW_INDEX_TEXT, fromString),
-    accessibleRowSpan: relation(Gtk.AccessibleRelation.ROW_SPAN, fromInt),
-    accessibleSetSize: relation(Gtk.AccessibleRelation.SET_SIZE, fromInt),
-};
-
-export const isAccessibleProp = (name: string): boolean => name in ACCESSIBLE_PROP_MAP;
-
-function applyDef(widget: Gtk.Widget, def: AccessiblePropDef, newValue: unknown): void {
-    const gvalue = def.createValue(newValue);
-
-    switch (def.kind) {
-        case "property":
-            widget.updatePropertyValue(1, [def.enumValue], [gvalue]);
-            break;
-        case "state":
-            widget.updateStateValue(1, [def.enumValue], [gvalue]);
-            break;
-        case "relation":
-            widget.updateRelationValue(1, [def.enumValue], [gvalue]);
-            break;
-    }
-}
-
-function resetDef(widget: Gtk.Widget, def: AccessiblePropDef): void {
-    switch (def.kind) {
-        case "property":
-            widget.resetProperty(def.enumValue);
-            break;
-        case "state":
-            widget.resetState(def.enumValue);
-            break;
-        case "relation":
-            widget.resetRelation(def.enumValue);
-            break;
-    }
-}
-
-export const applyAccessibleProps = (widget: Gtk.Widget, oldProps: Props | null, newProps: Props): void => {
-    for (const [name, def] of Object.entries(ACCESSIBLE_PROP_MAP)) {
-        const oldValue = oldProps?.[name];
-        const newValue = newProps[name];
-
-        if (oldValue === newValue) continue;
-
-        if (newValue === undefined) {
-            resetDef(widget, def);
-        } else {
-            applyDef(widget, def, newValue);
-        }
-    }
-};

package/src/nodes/internal/bound-item.ts

@@ -1,4 +0,0 @@
-import type { ReactNode } from "react";
-import type { Container } from "../../types.js";
-
-export type BoundItem = [ReactNode, Container, string];

package/src/nodes/internal/construct.ts

@@ -1,60 +0,0 @@
-import type { NativeClass, Type } from "@gtkx/ffi";
-import { Object as GObject, Value } from "@gtkx/ffi/gobject";
-import { CONSTRUCTION_META } from "../../generated/internal.js";
-import type { Container, ContainerClass, Props } from "../../types.js";
-
-type ConstructionPropMeta = {
-    girName: string;
-    ffiType: Type;
-    constructOnly?: true;
-};
-
-function collectConstructionProps(
-    containerClass: ContainerClass,
-    props: Props,
-): Array<{ girName: string; ffiType: Type; value: unknown }> {
-    const result: Array<{ girName: string; ffiType: Type; value: unknown }> = [];
-    const seen = new Set<string>();
-
-    // biome-ignore lint/complexity/noBannedTypes: Walking prototype chain requires Function type
-    let current: Function | null = containerClass;
-    while (current) {
-        const typeName = (current as NativeClass).glibTypeName;
-        if (!typeName) break;
-
-        const meta: Record<string, ConstructionPropMeta> | undefined = CONSTRUCTION_META[typeName];
-        if (meta) {
-            for (const [camelName, propMeta] of Object.entries(meta)) {
-                if (seen.has(camelName)) continue;
-                seen.add(camelName);
-                if (props[camelName] !== undefined) {
-                    result.push({
-                        girName: propMeta.girName,
-                        ffiType: propMeta.ffiType,
-                        value: props[camelName],
-                    });
-                }
-            }
-        }
-
-        current = Object.getPrototypeOf(current);
-        if (current === Object || current === Function) break;
-    }
-
-    return result;
-}
-
-export function createContainerWithProperties(containerClass: ContainerClass, props: Props): Container {
-    const gtype = containerClass.getGType();
-    const constructionProps = collectConstructionProps(containerClass, props);
-
-    const names: string[] = [];
-    const values: Value[] = [];
-
-    for (const { girName, ffiType, value } of constructionProps) {
-        names.push(girName);
-        values.push(Value.newFrom(ffiType, value));
-    }
-
-    return GObject.newWithProperties(gtype, names, values) as unknown as Container;
-}

package/src/nodes/internal/predicates.ts

@@ -1,80 +0,0 @@
-/**
- * Runtime type predicates for GTK widget capability detection.
- *
- * These predicates check for specific APIs that widgets may or may not expose.
- * GTK widgets don't have a consistent interface - different widgets support
- * different child management APIs - so runtime checking is necessary.
- */
-import * as Gtk from "@gtkx/ffi/gtk";
-
-type AppendableWidget = Gtk.Widget & { append: (child: Gtk.Widget) => void };
-type AddableWidget = Gtk.Widget & { add: (child: Gtk.Widget) => void };
-type ContentWidget = Gtk.Widget & { setContent: (content?: Gtk.Widget | null) => void };
-type SingleChildWidget = Gtk.Widget & { setChild: (child: Gtk.Widget | null) => void };
-type RemovableWidget = Gtk.Widget & { remove: (child: Gtk.Widget) => void };
-
-export type ReorderableWidget = Gtk.Widget & {
-    reorderChildAfter: (child: Gtk.Widget, sibling?: Gtk.Widget) => void;
-    insertChildAfter: (child: Gtk.Widget, sibling?: Gtk.Widget) => void;
-};
-
-export type InsertableWidget = Gtk.Widget & {
-    insert: (child: Gtk.Widget, position: number) => void;
-    getFirstChild: () => Gtk.Widget | null;
-};
-
-type EditableWidget = Gtk.Widget & {
-    getPosition: () => number;
-    setPosition: (position: number) => void;
-    getText: () => string;
-};
-
-type BufferedWidget = Gtk.Widget & {
-    getBuffer: () => Gtk.TextBuffer;
-    setBuffer: (buffer?: Gtk.TextBuffer | null) => void;
-};
-
-export const isAppendable = (obj: unknown): obj is AppendableWidget =>
-    obj instanceof Gtk.Widget && "append" in obj && typeof obj.append === "function";
-
-export const isAddable = (obj: unknown): obj is AddableWidget =>
-    obj instanceof Gtk.Widget && "add" in obj && typeof obj.add === "function";
-
-export const isContentWidget = (obj: unknown): obj is ContentWidget =>
-    obj instanceof Gtk.Widget && "setContent" in obj && typeof obj.setContent === "function";
-
-export const isSingleChild = (obj: unknown): obj is SingleChildWidget =>
-    obj instanceof Gtk.Widget && "setChild" in obj && typeof obj.setChild === "function";
-
-export const isRemovable = (obj: unknown): obj is RemovableWidget =>
-    obj instanceof Gtk.Widget && "remove" in obj && typeof obj.remove === "function";
-
-export const isReorderable = (obj: unknown): obj is ReorderableWidget =>
-    obj instanceof Gtk.Widget &&
-    "reorderChildAfter" in obj &&
-    typeof obj.reorderChildAfter === "function" &&
-    "insertChildAfter" in obj &&
-    typeof obj.insertChildAfter === "function";
-
-export const isInsertable = (obj: unknown): obj is InsertableWidget =>
-    obj instanceof Gtk.Widget &&
-    "insert" in obj &&
-    typeof obj.insert === "function" &&
-    "getFirstChild" in obj &&
-    typeof obj.getFirstChild === "function";
-
-export const isEditable = (obj: unknown): obj is EditableWidget =>
-    obj instanceof Gtk.Widget &&
-    "getPosition" in obj &&
-    typeof obj.getPosition === "function" &&
-    "setPosition" in obj &&
-    typeof obj.setPosition === "function" &&
-    "getText" in obj &&
-    typeof obj.getText === "function";
-
-export const isBuffered = (obj: unknown): obj is BufferedWidget =>
-    obj instanceof Gtk.Widget &&
-    "getBuffer" in obj &&
-    typeof obj.getBuffer === "function" &&
-    "setBuffer" in obj &&
-    typeof obj.setBuffer === "function";

package/src/nodes/internal/props.ts

@@ -1,51 +0,0 @@
-import type { Props } from "../../types.js";
-
-export const filterProps = <T extends Props>(props: T, excludeKeys: readonly string[]): T => {
-    const result: Props = {};
-
-    for (const key of Object.keys(props)) {
-        if (!excludeKeys.includes(key)) {
-            result[key] = props[key];
-        }
-    }
-
-    return result as T;
-};
-
-export const hasChanged = <T>(oldProps: T | null, newProps: T, key: keyof T): boolean =>
-    !oldProps || oldProps[key] !== newProps[key];
-
-export const shallowArrayEqual = <T extends Record<string, unknown>>(a: T[], b: T[]): boolean => {
-    if (a.length !== b.length) return false;
-
-    for (let i = 0; i < a.length; i++) {
-        const itemA = a[i];
-        const itemB = b[i];
-        if (!itemA || !itemB) return false;
-
-        const keysA = Object.keys(itemA);
-        const keysB = Object.keys(itemB);
-        if (keysA.length !== keysB.length) return false;
-
-        for (const key of keysA) {
-            if (itemA[key] !== itemB[key]) return false;
-        }
-    }
-
-    return true;
-};
-
-export const primitiveArrayEqual = <T extends string | number | boolean>(
-    a: T[] | null | undefined,
-    b: T[] | null | undefined,
-): boolean => {
-    if (a === b) return true;
-    if (!a || !b) return false;
-    if (a.length !== b.length) return false;
-
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i]) return false;
-    }
-
-    return true;
-};

package/src/nodes/internal/signal-store.ts

@@ -1,141 +0,0 @@
-import * as GObject from "@gtkx/ffi/gobject";
-
-type SignalOwner = object;
-
-// biome-ignore lint/suspicious/noExplicitAny: Required for contravariant behavior
-export type SignalHandler = (...args: any[]) => any;
-
-const LIFECYCLE_SIGNALS = new Set([
-    "realize",
-    "unrealize",
-    "map",
-    "unmap",
-    "show",
-    "hide",
-    "destroy",
-    "resize",
-    "render",
-    "setup",
-    "bind",
-    "unbind",
-    "teardown",
-]);
-
-type HandlerEntry = { obj: GObject.Object; handlerId: number };
-
-type SignalKey = `${string}:${string}`;
-
-interface SignalOptions {
-    blockable?: boolean;
-}
-
-const signalKeyCache = new WeakMap<GObject.Object, string>();
-let nextSignalObjId = 0;
-
-function getSignalKey(obj: GObject.Object, signal: string): SignalKey {
-    let objKey = signalKeyCache.get(obj);
-    if (!objKey) {
-        objKey = String(nextSignalObjId++);
-        signalKeyCache.set(obj, objKey);
-    }
-    return `${objKey}:${signal}`;
-}
-
-export class SignalStore {
-    private ownerHandlers: Map<SignalOwner, Map<SignalKey, HandlerEntry>> = new Map();
-    private blockDepth = 0;
-
-    private getOwnerMap(owner: SignalOwner): Map<SignalKey, HandlerEntry> {
-        let map = this.ownerHandlers.get(owner);
-        if (!map) {
-            map = new Map();
-            this.ownerHandlers.set(owner, map);
-        }
-        return map;
-    }
-
-    private wrapHandler(handler: SignalHandler, signal: string, blockable: boolean): SignalHandler {
-        return (...args: unknown[]) => {
-            if (this.blockDepth > 0 && blockable && !LIFECYCLE_SIGNALS.has(signal)) {
-                return;
-            }
-            const [self, ...rest] = args;
-            return handler(...rest, self);
-        };
-    }
-
-    private disconnect(owner: SignalOwner, obj: GObject.Object, signal: string): void {
-        const key = getSignalKey(obj, signal);
-        const ownerMap = this.ownerHandlers.get(owner);
-        const existing = ownerMap?.get(key);
-
-        if (existing) {
-            GObject.signalHandlerDisconnect(existing.obj, existing.handlerId);
-            ownerMap?.delete(key);
-        }
-    }
-
-    private connect(
-        owner: SignalOwner,
-        obj: GObject.Object,
-        signal: string,
-        handler: SignalHandler,
-        blockable: boolean,
-    ): void {
-        const key = getSignalKey(obj, signal);
-        const wrappedHandler = this.wrapHandler(handler, signal, blockable);
-        const handlerId = obj.connect(signal, wrappedHandler);
-        this.getOwnerMap(owner).set(key, { obj, handlerId });
-    }
-
-    public set(
-        owner: SignalOwner,
-        obj: GObject.Object,
-        signal: string,
-        handler?: SignalHandler | null,
-        options?: SignalOptions,
-    ): void {
-        this.disconnect(owner, obj, signal);
-
-        if (handler) {
-            this.connect(owner, obj, signal, handler, options?.blockable ?? true);
-        }
-    }
-
-    public clear(owner: SignalOwner): void {
-        const ownerMap = this.ownerHandlers.get(owner);
-
-        if (ownerMap) {
-            for (const { obj, handlerId } of ownerMap.values()) {
-                GObject.signalHandlerDisconnect(obj, handlerId);
-            }
-
-            this.ownerHandlers.delete(owner);
-        }
-    }
-
-    public blockAll(): void {
-        this.blockDepth++;
-    }
-
-    public unblockAll(): void {
-        if (this.blockDepth > 0) {
-            this.blockDepth--;
-        }
-    }
-
-    public forceUnblockAll(): void {
-        this.blockDepth = 0;
-    }
-}
-
-const signalStores = new WeakMap<object, SignalStore>();
-
-export function getSignalStore(rootContainer: object): SignalStore {
-    let store = signalStores.get(rootContainer);
-    if (!store) {
-        store = new SignalStore();
-        signalStores.set(rootContainer, store);
-    }
-    return store;
-}