@gtkx/react 0.21.0 → 1.0.0-rc.2

package/src/reconciler/child-routing.ts

@@ -0,0 +1,202 @@
+import { indexBeforeOrEnd, remove } from "@gtkx/utils";
+import type { AnyNode, ContentChild, ElementNode, LazyNode, ParentNode, PlaceableNode, PropNode } from "./node.js";
+import { DEFAULT_SLOT, ELEMENT_KIND, LAZY_KIND, nodeObject, PROP_KIND, TEXT_KIND } from "./node.js";
+import { placeChild, unplaceChild } from "./placement.js";
+import { addContent, canAcceptText, removeContent, textRestrictionError } from "./text.js";
+
+const asPlaceable = (node: AnyNode | null): PlaceableNode | null =>
+    node !== null && (node.kind === ELEMENT_KIND || node.kind === LAZY_KIND) ? node : null;
+
+const attachPropToElement = (parent: ElementNode, node: PropNode, before: AnyNode | null): void => {
+    node.parent = parent;
+
+    for (const child of node.children) {
+        placeChild(parent, node.slot, child, asPlaceable(before));
+    }
+};
+
+const detachPropFromElement = (parent: ElementNode, node: PropNode): void => {
+    for (const child of node.children) {
+        unplaceChild(parent, node.slot, child);
+    }
+};
+
+const asContentChild = (node: AnyNode | null): ContentChild | null =>
+    node !== null && (node.kind === TEXT_KIND || node.kind === ELEMENT_KIND) ? node : null;
+
+const attachToContentHost = (parent: ElementNode, child: AnyNode, before: AnyNode | null): void => {
+    if (child.kind === TEXT_KIND && !canAcceptText(parent)) {
+        throw textRestrictionError(child.text);
+    }
+
+    if (child.kind === TEXT_KIND || child.kind === ELEMENT_KIND) {
+        addContent(parent, child, asContentChild(before));
+    }
+};
+
+const attachToElement = (parent: ElementNode, child: AnyNode, before: AnyNode | null): void => {
+    if (child.kind === PROP_KIND) {
+        attachPropToElement(parent, child, before);
+
+        return;
+    }
+
+    if (parent.contentKind !== null) {
+        attachToContentHost(parent, child, before);
+
+        return;
+    }
+
+    if (child.kind === TEXT_KIND) {
+        throw textRestrictionError(child.text);
+    }
+
+    if (child.kind === LAZY_KIND) {
+        child.parent = parent;
+    }
+
+    placeChild(parent, DEFAULT_SLOT, child, asPlaceable(before));
+};
+
+const insertPlaceable = (list: PlaceableNode[], node: PlaceableNode, before: AnyNode | null): void => {
+    const beforeNode = asPlaceable(before);
+
+    list.splice(
+        indexBeforeOrEnd(list, beforeNode, (item, target) => item === target),
+        0,
+        node,
+    );
+};
+
+const insertChild = (parent: PropNode | LazyNode, child: AnyNode, before: AnyNode | null): PlaceableNode | null => {
+    const placeable = asPlaceable(child);
+
+    if (placeable === null) {
+        return null;
+    }
+
+    insertPlaceable(parent.children, placeable, before);
+
+    return placeable;
+};
+
+const attachToProp = (parent: PropNode, child: AnyNode, before: AnyNode | null): void => {
+    const placeable = insertChild(parent, child, before);
+
+    if (placeable === null) {
+        return;
+    }
+
+    const owner = parent.parent;
+
+    if (owner === null) {
+        return;
+    }
+
+    placeChild(owner, parent.slot, placeable, asPlaceable(before));
+};
+
+const placeLazy = (owner: ElementNode, node: LazyNode, hasObject: boolean): void => {
+    if (hasObject) {
+        placeChild(owner, DEFAULT_SLOT, node, null);
+    }
+};
+
+const syncLazy = (node: LazyNode): void => {
+    const owner = node.parent;
+
+    if (owner === null) {
+        return;
+    }
+
+    const entry = owner.placements.get(DEFAULT_SLOT)?.find((entry) => entry.node === node);
+    const object = nodeObject(node);
+
+    if (entry === undefined) {
+        placeLazy(owner, node, object !== null);
+    } else if (entry.object !== object) {
+        unplaceChild(owner, DEFAULT_SLOT, node);
+        placeLazy(owner, node, object !== null);
+    }
+};
+
+const attachToLazy = (parent: LazyNode, child: AnyNode, before: AnyNode | null): void => {
+    if (insertChild(parent, child, before) === null) {
+        return;
+    }
+
+    syncLazy(parent);
+};
+
+const attachChild = (parent: ParentNode, child: AnyNode, before: AnyNode | null): void => {
+    if (parent.kind === ELEMENT_KIND) {
+        attachToElement(parent, child, before);
+    } else if (parent.kind === PROP_KIND) {
+        attachToProp(parent, child, before);
+    } else {
+        attachToLazy(parent, child, before);
+    }
+};
+
+const removeContentChild = (parent: ElementNode, child: AnyNode): void => {
+    if (child.kind === TEXT_KIND || child.kind === ELEMENT_KIND) {
+        removeContent(parent, child);
+    }
+};
+
+const unplaceChildNode = (parent: ElementNode, child: AnyNode): void => {
+    const placeable = asPlaceable(child);
+
+    if (placeable !== null) {
+        unplaceChild(parent, DEFAULT_SLOT, placeable);
+    }
+};
+
+const detachFromElement = (parent: ElementNode, child: AnyNode): void => {
+    if (child.kind === PROP_KIND) {
+        detachPropFromElement(parent, child);
+    } else if (parent.contentKind === null) {
+        unplaceChildNode(parent, child);
+    } else {
+        removeContentChild(parent, child);
+    }
+};
+
+const detachFromProp = (parent: PropNode, child: AnyNode): void => {
+    const placeable = asPlaceable(child);
+
+    if (placeable === null) {
+        return;
+    }
+
+    remove(parent.children, placeable);
+    const owner = parent.parent;
+
+    if (owner === null) {
+        return;
+    }
+
+    unplaceChild(owner, parent.slot, placeable);
+};
+
+const detachFromLazy = (parent: LazyNode, child: AnyNode): void => {
+    const placeable = asPlaceable(child);
+
+    if (placeable !== null) {
+        remove(parent.children, placeable);
+    }
+
+    syncLazy(parent);
+};
+
+const detachChild = (parent: ParentNode, child: AnyNode): void => {
+    if (parent.kind === ELEMENT_KIND) {
+        detachFromElement(parent, child);
+    } else if (parent.kind === PROP_KIND) {
+        detachFromProp(parent, child);
+    } else {
+        detachFromLazy(parent, child);
+    }
+};
+
+export { attachChild, detachChild };

package/src/reconciler/host-config.ts

@@ -0,0 +1,278 @@
+import type * as GObject from "@gtkx/gi/gobject";
+import * as Gtk from "@gtkx/gi/gtk";
+import { getInstanceType, typeName } from "@gtkx/runtime";
+import { getOrInsert } from "@gtkx/utils";
+import { createContext } from "react";
+import ReactReconciler from "react-reconciler";
+import { DefaultEventPriority, DiscreteEventPriority, NoEventPriority } from "react-reconciler/constants.js";
+import type { Props } from "./registry.js";
+import { Prop } from "../components/element.js";
+import {
+    applyAdoptedProps,
+    applyElementProps,
+    assertConstructOnlyUnchanged,
+    flushBehaviors,
+    mountBehaviors,
+    unmountBehaviors,
+} from "./apply-props.js";
+import { attachChild, detachChild } from "./child-routing.js";
+import { resolveElementNode } from "./instance.js";
+import { typeInfoFor } from "./metadata.js";
+import {
+    type AnyNode,
+    createElementNode,
+    createPropNode,
+    createTextNode,
+    type Dispatch,
+    ELEMENT_KIND,
+    type ElementNode,
+    type Instance,
+    LAZY_KIND,
+    lazyTarget,
+    type TextNode,
+} from "./node.js";
+import { isRootElement, type RootElement } from "./root-element.js";
+import { beginSuppression, disconnectAllHandlers, endSuppression } from "./signals.js";
+import {
+    didUpdateTextSurgically,
+    enclosingHost,
+    flushTextHosts,
+    markTextDirty,
+    validateContentMix,
+} from "./text.js";
+
+/** A top-level container an element tree can be mounted into. */
+type Container = RootElement | GObject.Object;
+
+type PriorityTracker = {
+    get: () => number;
+    set: (priority: number) => void;
+    withDiscrete: <T>(fn: () => T) => T;
+};
+
+const HOST_CONTEXT: Record<string, never> = {};
+const containerNodes: WeakMap<object, ElementNode> = new WeakMap();
+const priority = createPriorityTracker();
+
+const hostConfig = {
+    supportsMutation: true,
+    supportsPersistence: false,
+    supportsHydration: false,
+    isPrimaryRenderer: true,
+    noTimeout: -1,
+    scheduleTimeout: (fn: (...args: unknown[]) => unknown, delay?: number): ReturnType<typeof setTimeout> =>
+        setTimeout(fn, delay),
+    cancelTimeout: (id: ReturnType<typeof setTimeout>): void => {
+        clearTimeout(id);
+    },
+    createInstance: (type: string, props: Props): Instance => createNode(type, props),
+    createTextInstance: (text: string): TextNode => createTextNode(text),
+    appendInitialChild: (parent: Instance, child: AnyNode): void => {
+        attachChild(parent, child, null);
+    },
+    finalizeInitialChildren: (instance: Instance, _type: string, props: Props): boolean => {
+        if (instance.kind !== ELEMENT_KIND) {
+            return false;
+        }
+
+        validateContentMix(instance, props);
+
+        return typeInfoFor(instance.typeName).hasMount;
+    },
+    commitMount: (instance: Instance): void => {
+        if (instance.kind === ELEMENT_KIND) {
+            mountBehaviors(instance);
+        }
+    },
+    shouldSetTextContent: (): boolean => false,
+    getRootHostContext: (): Record<string, never> => HOST_CONTEXT,
+    getChildHostContext: (parent: Record<string, never>): Record<string, never> => parent,
+    getPublicInstance: (instance: Instance): object => getPublicInstance(instance),
+    prepareForCommit: (): null => {
+        beginSuppression();
+
+        return null;
+    },
+    resetAfterCommit: (): void => {
+        flushTextHosts();
+        flushBehaviors();
+        endSuppression();
+    },
+    preparePortalMount: (): void => undefined,
+    clearContainer: (): void => undefined,
+    appendChild: (parent: Instance, child: AnyNode): void => {
+        attachChild(parent, child, null);
+    },
+    appendChildToContainer: (container: Container, child: AnyNode): void => {
+        attachToContainer(container, child, null);
+    },
+    insertBefore: (parent: Instance, child: AnyNode, before: AnyNode): void => {
+        attachChild(parent, child, before);
+    },
+    insertInContainerBefore: (container: Container, child: AnyNode, before: AnyNode): void => {
+        attachToContainer(container, child, before);
+    },
+    removeChild: (parent: Instance, child: AnyNode): void => {
+        detachChild(parent, child);
+    },
+    removeChildFromContainer: (container: Container, child: AnyNode): void => {
+        detachFromContainer(container, child);
+    },
+    commitTextUpdate: (textInstance: TextNode, oldText: string, newText: string): void => {
+        textInstance.text = newText;
+        const host = enclosingHost(textInstance);
+
+        if (host !== null && !didUpdateTextSurgically(host, textInstance, oldText, newText)) {
+            markTextDirty(host);
+        }
+    },
+    commitUpdate: (instance: Instance, _type: string, prevProps: Props, nextProps: Props): void => {
+        updateInstance(instance, prevProps, nextProps);
+    },
+    hideInstance: (instance: Instance): void => {
+        setWidgetVisible(instance, false);
+    },
+    unhideInstance: (instance: Instance, props: Props): void => {
+        setWidgetVisible(instance, props.visible !== false);
+    },
+    hideTextInstance: (): void => undefined,
+    unhideTextInstance: (): void => undefined,
+    detachDeletedInstance: (instance: Instance): void => {
+        if (instance.kind === ELEMENT_KIND) {
+            disconnectAllHandlers(instance);
+            unmountBehaviors(instance);
+        } else if (instance.kind === LAZY_KIND && instance.adopted !== null) {
+            disconnectAllHandlers(lazyTarget(instance, instance.adopted));
+        }
+    },
+    getInstanceFromNode: (): null => null,
+    beforeActiveInstanceBlur: (): void => undefined,
+    afterActiveInstanceBlur: (): void => undefined,
+    prepareScopeUpdate: (): void => undefined,
+    getInstanceFromScope: (): null => null,
+    setCurrentUpdatePriority: (next: number): void => {
+        priority.set(next);
+    },
+    getCurrentUpdatePriority: (): number => priority.get(),
+    resolveUpdatePriority: (): number => (priority.get() === NoEventPriority ? DefaultEventPriority : priority.get()),
+    resetFormInstance: (): void => undefined,
+    requestPostPaintCallback: (): void => undefined,
+    shouldAttemptEagerTransition: (): boolean => false,
+    trackSchedulerEvent: (): void => undefined,
+    resolveEventType: (): null => null,
+    resolveEventTimeStamp: (): number => -1,
+    maySuspendCommit: (): boolean => false,
+    preloadInstance: (): boolean => true,
+    startSuspendingCommit: (): void => undefined,
+    suspendInstance: (): void => undefined,
+    waitForCommitToBeReady: (): null => null,
+    NotPendingTransition: null,
+    HostTransitionContext: createContext(null) as unknown as ReactReconciler.ReactContext<null>,
+};
+
+const reconciler: ReactReconciler.Reconciler<Container, Instance, TextNode, unknown, unknown, object> =
+    ReactReconciler(hostConfig);
+
+function createPriorityTracker(): PriorityTracker {
+    let current: number = NoEventPriority;
+
+    return {
+        get: () => current,
+        set: (next) => {
+            current = next;
+        },
+        withDiscrete: (fn) => {
+            const previous = current;
+            current = DiscreteEventPriority;
+
+            try {
+                return fn();
+            } finally {
+                current = previous;
+            }
+        },
+    };
+}
+
+const updateInstance = (instance: Instance, prev: Props, next: Props): void => {
+    if (instance.kind === ELEMENT_KIND) {
+        assertConstructOnlyUnchanged(instance.typeName, prev, next);
+        applyElementProps(instance, prev, next);
+
+        return;
+    }
+
+    if (instance.kind === LAZY_KIND && instance.adopted !== null) {
+        assertConstructOnlyUnchanged(instance.typeName, prev, next);
+        applyAdoptedProps(lazyTarget(instance, instance.adopted), prev, next);
+        instance.props = next;
+    }
+};
+
+const attachToContainer = (container: Container, child: AnyNode, before: AnyNode | null): void => {
+    if (!isRootElement(container)) {
+        attachChild(getOrCreateContainerNode(container), child, before);
+    }
+};
+
+const detachFromContainer = (container: Container, child: AnyNode): void => {
+    if (!isRootElement(container)) {
+        detachChild(getOrCreateContainerNode(container), child);
+    }
+};
+
+const getPublicInstance = (instance: Instance): object => {
+    if (instance.kind === ELEMENT_KIND) {
+        return instance.object;
+    }
+
+    if (instance.kind === LAZY_KIND) {
+        return instance.adopted ?? instance;
+    }
+
+    return instance;
+};
+
+const setWidgetVisible = (instance: Instance, isVisible: boolean): void => {
+    if (instance.kind === ELEMENT_KIND && instance.object instanceof Gtk.Widget) {
+        instance.object.setVisible(isVisible);
+    }
+};
+
+const runDiscrete: Dispatch = (fn) => {
+    try {
+        return priority.withDiscrete(fn);
+    } finally {
+        reconciler.flushSyncWork();
+    }
+};
+
+const adoptContainer = (container: GObject.Object): ElementNode => {
+    const name = typeName(getInstanceType(container));
+
+    if (name === null) {
+        throw new Error("Cannot adopt a container whose GType has no registered name");
+    }
+
+    return createElementNode(name, container, runDiscrete, null);
+};
+
+const getOrCreateContainerNode = (container: GObject.Object): ElementNode =>
+    getOrInsert(containerNodes, container, adoptContainer);
+
+const createNode = (type: string, props: Props): Instance => {
+    if (type === Prop) {
+        return createPropNode(props.propName as string);
+    }
+
+    const node = resolveElementNode(type, props, runDiscrete);
+
+    if (node.kind === ELEMENT_KIND) {
+        containerNodes.set(node.object, node);
+        applyElementProps(node, {}, props);
+    }
+
+    return node;
+};
+
+export { reconciler, type Container };

package/src/reconciler/instance.ts

@@ -0,0 +1,82 @@
+import type * as GObject from "@gtkx/gi/gobject";
+import { getWrapperClass, TYPE_INVALID, typeFromName, typeIsA } from "@gtkx/runtime";
+import { pickBy } from "@gtkx/utils";
+import type { Props } from "./registry.js";
+import { type TypeInfo, typeInfoFor } from "./metadata.js";
+import {
+    type ContentKind,
+    createElementNode,
+    createLazyNode,
+    type Dispatch,
+    type ElementNode,
+    type LazyNode,
+} from "./node.js";
+import { ELEMENTS } from "./registry.js";
+
+type WidgetConstructor = new (props: Props) => GObject.Object;
+type ContentType = { kind: ContentKind; type: bigint };
+
+const CONTENT_TYPE_NAMES: { kind: ContentKind; name: string }[] = [
+    { kind: "label", name: "GtkLabel" },
+    { kind: "buffer", name: "GtkTextBuffer" },
+    { kind: "tag", name: "GtkTextTag" },
+    { kind: "anchor", name: "GtkTextChildAnchor" },
+];
+
+const getContentTypes = createContentTypeCache();
+
+function createContentTypeCache(): () => ContentType[] {
+    let cached: ContentType[] | null = null;
+
+    return () => {
+        cached ??= CONTENT_TYPE_NAMES.map((entry) => ({ kind: entry.kind, type: typeFromName(entry.name) }));
+
+        return cached;
+    };
+}
+
+const resolveContentKind = (type: bigint): ContentKind | null => {
+    for (const entry of getContentTypes()) {
+        if (entry.type !== TYPE_INVALID && typeIsA(type, entry.type)) {
+            return entry.kind;
+        }
+    }
+
+    return null;
+};
+
+const constructInput = (info: TypeInfo, props: Props): Props =>
+    pickBy(
+        props,
+        (value, name) =>
+            value !== undefined &&
+            !info.deferred.has(name) &&
+            (info.constructOnly.has(name) || info.construct.has(name)),
+    );
+
+const instantiate = (type: bigint, input: Props): GObject.Object => {
+    const cls = getWrapperClass(type) as WidgetConstructor;
+
+    return new cls(input);
+};
+
+const createObject = (typeName: string, type: bigint, input: Props): GObject.Object => {
+    const create = ELEMENTS[typeName]?.behaviors?.find((behavior) => behavior.create !== undefined)?.create;
+
+    return create === undefined ? instantiate(type, input) : create(input);
+};
+
+const resolveElementNode = (typeName: string, props: Props, dispatch: Dispatch): ElementNode | LazyNode => {
+    const info = typeInfoFor(typeName);
+
+    if (info.lazy) {
+        return createLazyNode(typeName, props, dispatch);
+    }
+
+    const type = typeFromName(typeName);
+    const object = createObject(typeName, type, constructInput(info, props));
+
+    return createElementNode(typeName, object, dispatch, resolveContentKind(type));
+};
+
+export { resolveElementNode };

package/src/reconciler/metadata.ts

@@ -0,0 +1,119 @@
+import { TYPE_INVALID, typeFromName, typeInterfaces, typeName, typeParent } from "@gtkx/runtime";
+import { getOrInsert } from "@gtkx/utils";
+import { CONSTRUCT_ONLY_PROPS, CONSTRUCT_PROPS, DEFAULT_PROPS, SIGNALS, userEventSignals } from "virtual:gtkx-config";
+import { deferredProps, type ElementBehavior, ELEMENTS } from "./registry.js";
+
+type TypeInfo = {
+    typeName: string;
+    signals: Record<string, string>;
+    userEventSignals: Set<string>;
+    behaviors: ElementBehavior[];
+    deferred: Set<string>;
+    lazy: boolean;
+    hasFlush: boolean;
+    hasMount: boolean;
+    constructOnly: Set<string>;
+    construct: Set<string>;
+    defaults: Record<string, unknown>;
+};
+
+const ancestryCache: Map<string, string[]> = new Map();
+const typeInfoCache: Map<string, TypeInfo> = new Map();
+
+const addAncestor = (names: string[], seen: Set<string>, name: string | null): void => {
+    if (name === null || seen.has(name)) {
+        return;
+    }
+
+    seen.add(name);
+    names.push(name);
+};
+
+const buildAncestry = (name: string): string[] => {
+    const names: string[] = [];
+    const seen: Set<string> = new Set();
+    let type = typeFromName(name);
+
+    while (type !== TYPE_INVALID) {
+        addAncestor(names, seen, typeName(type));
+
+        for (const iface of typeInterfaces(type)) {
+            addAncestor(names, seen, typeName(iface));
+        }
+
+        type = typeParent(type);
+    }
+
+    return names;
+};
+
+const ancestryFor = (name: string): string[] => getOrInsert(ancestryCache, name, buildAncestry);
+
+const addAll = <T>(target: Set<T>, source: Iterable<T> | undefined): void => {
+    const items = source ?? [];
+
+    for (const item of items) {
+        target.add(item);
+    }
+};
+
+const accumulateAncestor = (info: TypeInfo, ancestor: string): void => {
+    Object.assign(info.signals, SIGNALS[ancestor] ?? {});
+    addAll(info.userEventSignals, userEventSignals[ancestor]);
+    addAll(info.constructOnly, CONSTRUCT_ONLY_PROPS[ancestor]);
+    addAll(info.construct, CONSTRUCT_PROPS[ancestor]);
+    info.behaviors.push(...(ELEMENTS[ancestor]?.behaviors ?? []));
+};
+
+const applyBehaviorFlags = (info: TypeInfo, behavior: ElementBehavior): void => {
+    if (behavior.flush !== undefined) {
+        info.hasFlush = true;
+    }
+
+    if (behavior.mount !== undefined) {
+        info.hasMount = true;
+    }
+
+    addAll(info.deferred, deferredProps(behavior));
+};
+
+const resolveBehaviorFlags = (info: TypeInfo): void => {
+    for (const behavior of info.behaviors) {
+        applyBehaviorFlags(info, behavior);
+    }
+};
+
+const buildTypeInfo = (name: string): TypeInfo => {
+    const chain = ancestryFor(name);
+
+    const info: TypeInfo = {
+        typeName: name,
+        signals: {},
+        userEventSignals: new Set(),
+        behaviors: [],
+        deferred: new Set(),
+        lazy: false,
+        hasFlush: false,
+        hasMount: false,
+        constructOnly: new Set(),
+        construct: new Set(),
+        defaults: {},
+    };
+
+    for (const ancestor of chain) {
+        accumulateAncestor(info, ancestor);
+    }
+
+    resolveBehaviorFlags(info);
+    info.lazy = chain.some((ancestor) => ELEMENTS[ancestor]?.lazy === true);
+
+    for (const ancestor of chain.toReversed()) {
+        Object.assign(info.defaults, DEFAULT_PROPS[ancestor] ?? {});
+    }
+
+    return info;
+};
+
+const typeInfoFor = (name: string): TypeInfo => getOrInsert(typeInfoCache, name, buildTypeInfo);
+
+export { typeInfoFor, type TypeInfo };