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

package/src/reconciler/element-props.ts

@@ -1,192 +0,0 @@
-/// <reference types="@gtkx/config/env" />
-
-import { ELEMENT_PROPS } from "virtual:gtkx-config";
-import type { AppliedProp, Arg, ArgRef, Call, ContainerProp } from "@gtkx/config";
-import { typeFromName } from "@gtkx/gi/gobject";
-import { callMethod } from "@gtkx/utils";
-import { collectTypeNamesWithInterfaces, foldInheritedTableWithInterfaces } from "../utils/gtype.js";
-
-export type CallScope = {
-    child?: unknown;
-    item?: unknown;
-    index?: number;
-    sibling?: unknown;
-    adopted?: unknown;
-    props?: Record<string, unknown>;
-};
-
-const MISSING_ARG = Symbol("gtkx.missing-arg");
-
-const fieldOf = (source: unknown, name: string): unknown =>
-    source == null ? undefined : Reflect.get(Object(source), name);
-
-const evalArg = (arg: Arg, scope: CallScope): unknown => {
-    if (typeof arg === "string") {
-        switch (arg) {
-            case "child":
-                return scope.child;
-            case "item":
-                return scope.item;
-            case "index":
-                return scope.index;
-            case "sibling":
-                return scope.sibling;
-            case "adopted":
-                return scope.adopted;
-        }
-    }
-    if ("literal" in arg) return arg.literal;
-    if ("prop" in arg) {
-        const value = scope.props?.[arg.prop];
-        return value == null ? MISSING_ARG : value;
-    }
-    const value = fieldOf(scope.item, arg.field);
-    if (value == null && "or" in arg) return arg.or;
-    return value;
-};
-
-type CallResult = {
-    called: boolean;
-    value: unknown;
-};
-
-export const runCallValue = (target: object, call: Call, defaults: unknown[], scope: CallScope): CallResult => {
-    if (typeof call === "string") {
-        return { called: true, value: callMethod(target, call, defaults) };
-    }
-    const args = call.args.map((arg) => evalArg(arg, scope));
-    if (args.includes(MISSING_ARG)) return { called: false, value: undefined };
-    return { called: true, value: callMethod(target, call.method, args) };
-};
-
-export const runCall = (target: object, call: Call, defaults: unknown[], scope: CallScope): boolean =>
-    runCallValue(target, call, defaults, scope).called;
-
-export const callUsesRef = (call: Call | undefined, ref: ArgRef): boolean =>
-    call !== undefined && typeof call !== "string" && call.args.some((arg) => arg === ref);
-
-export const nullSetterCurrentHolder = (target: object, call: Call): unknown => {
-    if (typeof call === "string" || !call.method.startsWith("set")) return undefined;
-    if (!call.args.some((arg) => typeof arg === "object" && "literal" in arg && arg.literal === null)) {
-        return undefined;
-    }
-    const getter = `get${call.method.slice(3)}`;
-    if (typeof Reflect.get(target, getter) !== "function") return undefined;
-    return callMethod(target, getter, []);
-};
-
-const attachIndex = new Map<string, ContainerProp>();
-const adoptByParent = new Map<string, ContainerProp>();
-const namedContainerPropsByParent: Record<string, string[]> = {};
-const APPLIED_BY_TYPE: Record<string, AppliedProp[]> = {};
-
-for (const [parent, props] of Object.entries(ELEMENT_PROPS)) {
-    for (const prop of props) {
-        if (prop.kind === "container") {
-            attachIndex.set(`${parent}:${prop.child}:${prop.prop === "children" ? "" : prop.prop}`, prop);
-            if (prop.prop !== "children") {
-                const propNames = namedContainerPropsByParent[parent] ?? [];
-                propNames.push(prop.prop);
-                namedContainerPropsByParent[parent] = propNames;
-            }
-            if (prop.adopt !== undefined) adoptByParent.set(parent, prop);
-        } else {
-            const applied = APPLIED_BY_TYPE[parent] ?? [];
-            applied.push(prop);
-            APPLIED_BY_TYPE[parent] = applied;
-        }
-    }
-}
-
-const attachCache = new Map<string, ContainerProp | null>();
-
-export const resolveContainerProp = (
-    parentType: bigint,
-    childType: bigint,
-    propName: string | undefined,
-): ContainerProp | null => {
-    const cacheKey = `${parentType}:${childType}:${propName ?? ""}`;
-    const cached = attachCache.get(cacheKey);
-    if (cached !== undefined) return cached;
-    let resolved: ContainerProp | null = null;
-    const parentNames = collectTypeNamesWithInterfaces(parentType);
-    for (const childName of collectTypeNamesWithInterfaces(childType)) {
-        for (const parentName of parentNames) {
-            resolved = attachIndex.get(`${parentName}:${childName}:${propName ?? ""}`) ?? null;
-            if (resolved !== null) break;
-        }
-        if (resolved !== null) break;
-    }
-    attachCache.set(cacheKey, resolved);
-    return resolved;
-};
-
-const adoptCache = new Map<bigint, ContainerProp | null>();
-
-export const adoptContainerPropFor = (parentType: bigint): ContainerProp | null => {
-    const cached = adoptCache.get(parentType);
-    if (cached !== undefined) return cached;
-    let resolved: ContainerProp | null = null;
-    for (const name of collectTypeNamesWithInterfaces(parentType)) {
-        const cp = adoptByParent.get(name);
-        if (cp !== undefined) {
-            resolved = cp;
-            break;
-        }
-    }
-    adoptCache.set(parentType, resolved);
-    return resolved;
-};
-
-const containerPropNamesCache = new Map<string, Set<string>>();
-
-export const containerPropNamesFor = (elementName: string): Set<string> => {
-    const cached = containerPropNamesCache.get(elementName);
-    if (cached) return cached;
-    const names = foldInheritedTableWithInterfaces(
-        typeFromName(elementName),
-        namedContainerPropsByParent,
-        (collected: Set<string>, propNames) => {
-            for (const name of propNames) collected.add(name);
-            return collected;
-        },
-        new Set<string>(),
-    );
-    containerPropNamesCache.set(elementName, names);
-    return names;
-};
-
-const appliedCache = new Map<bigint, Map<string, AppliedProp>>();
-
-export const appliedPropsFor = (gtype: bigint): Map<string, AppliedProp> => {
-    const cached = appliedCache.get(gtype);
-    if (cached) return cached;
-    const resolved = foldInheritedTableWithInterfaces<AppliedProp[], Map<string, AppliedProp>>(
-        gtype,
-        APPLIED_BY_TYPE,
-        (collected, props) => {
-            for (const prop of props) {
-                if (!collected.has(prop.prop)) collected.set(prop.prop, prop);
-            }
-            return collected;
-        },
-        new Map(),
-    );
-    appliedCache.set(gtype, resolved);
-    return resolved;
-};
-
-export const isAppliedProp = (gtype: bigint, name: string): boolean => appliedPropsFor(gtype).has(name);
-
-const constructionSkipCache = new Map<bigint, Set<string>>();
-
-export const constructionSkipProps = (gtype: bigint): Set<string> => {
-    const cached = constructionSkipCache.get(gtype);
-    if (cached) return cached;
-    const skipped = new Set<string>();
-    for (const prop of appliedPropsFor(gtype).values()) {
-        if (prop.kind === "lazy") skipped.add(prop.prop);
-    }
-    constructionSkipCache.set(gtype, skipped);
-    return skipped;
-};

package/src/reconciler/label-text-rebuild.ts

@@ -1,26 +0,0 @@
-import * as Gtk from "@gtkx/gi/gtk";
-import { scheduleContentRebuild } from "./content-rebuild.js";
-import { type Node, stateOf } from "./state.js";
-import { isLabelTextNode } from "./text-node.js";
-
-const rebuildLabelText = (owner: Gtk.Label): void => {
-    const state = stateOf(owner);
-    const runs = state.children.filter(isLabelTextNode);
-    if (state.props.label !== undefined) {
-        if (runs.length === 0) return;
-        throw new Error("<GtkLabel> cannot mix a `label` prop with text children; use one or the other");
-    }
-    const text = runs
-        .filter((run) => !stateOf(run).hidden)
-        .map((run) => String(stateOf(run).props.text))
-        .join("");
-    owner.setLabel(text);
-};
-
-export const scheduleLabelTextRebuild = (node: Node): void => {
-    scheduleContentRebuild(
-        node,
-        (candidate): candidate is Gtk.Label => candidate instanceof Gtk.Label,
-        (owner) => () => rebuildLabelText(owner),
-    );
-};

package/src/reconciler/portal.ts

@@ -1,28 +0,0 @@
-import type { ReactNode, ReactPortal } from "react";
-import type { Container } from "./types.js";
-
-type ObjectPortal = ReactPortal & {
-    $$typeof: symbol;
-    containerInfo: Container;
-    implementation: null;
-};
-
-/**
- * Creates a React portal that renders `children` into a different container in the widget tree.
- *
- * @param children The nodes to render inside the container.
- * @param container The GObject or root element to render into.
- * @param key An optional React key for the portal.
- */
-export const createPortal = (children: ReactNode, container: Container, key?: string | null): ReactPortal => {
-    const portal: ObjectPortal = {
-        $$typeof: Symbol.for("react.portal"),
-        type: "",
-        props: { children },
-        key: key ?? null,
-        children,
-        containerInfo: container,
-        implementation: null,
-    };
-    return portal;
-};

package/src/reconciler/reconciler-error-handler.ts

@@ -1,29 +0,0 @@
-import { createLogger, type Logger } from "@gtkx/utils";
-
-export const log: Logger = createLogger("react");
-
-export type ReconcilerErrorHandler = (error: unknown) => void;
-
-let errorHandler: ReconcilerErrorHandler | null = null;
-
-export function setReconcilerErrorHandler(handler: ReconcilerErrorHandler | null): ReconcilerErrorHandler | null {
-    const prior = errorHandler;
-    errorHandler = handler;
-    return prior;
-}
-
-export function reportReconcilerError(error: unknown): void {
-    if (errorHandler) {
-        errorHandler(error);
-        return;
-    }
-    log.error("unhandled reconciler error", error);
-}
-
-export function catchReconcilerError(fn: () => void): void {
-    try {
-        fn();
-    } catch (error) {
-        reportReconcilerError(error);
-    }
-}

package/src/reconciler/reconciler-root.ts

@@ -1,57 +0,0 @@
-import type { ReactNode } from "react";
-import { reconciler } from "./reconciler.js";
-import type { Container } from "./types.js";
-
-const noop = (): void => {};
-
-type FiberRoot = ReturnType<typeof reconciler.createContainer>;
-
-type ReconcilerErrorCallback = (error: Error, info: { componentStack?: string | null }) => void;
-
-export type ReconcilerRootOptions = {
-    containerInfo: Container;
-    onUncaughtError: ReconcilerErrorCallback;
-    onCaughtError: ReconcilerErrorCallback;
-    onRecoverableError?: ReconcilerErrorCallback;
-};
-
-export type ReconcilerRoot = {
-    update(element: ReactNode): void;
-    unmount<R>(free: (root: ReconcilerRoot) => R): R | undefined;
-};
-
-const activeRoots = new Set<ReconcilerRoot>();
-
-export const createReconcilerRoot = (options: ReconcilerRootOptions): ReconcilerRoot => {
-    const fiberRoot: FiberRoot = reconciler.createContainer(
-        options.containerInfo,
-        1,
-        null,
-        false,
-        null,
-        "",
-        options.onUncaughtError,
-        options.onCaughtError,
-        options.onRecoverableError ?? noop,
-        noop,
-    );
-
-    const root: ReconcilerRoot = {
-        update: (element: ReactNode): void => {
-            reconciler.updateContainer(element, fiberRoot, null, noop);
-        },
-        unmount: <R>(free: (root: ReconcilerRoot) => R): R | undefined => {
-            if (!activeRoots.delete(root)) return undefined;
-            return free(root);
-        },
-    };
-
-    activeRoots.add(root);
-    return root;
-};
-
-export const unmountAllReconcilerRoots = (free: (root: ReconcilerRoot) => void): void => {
-    const roots = [...activeRoots];
-    activeRoots.clear();
-    roots.forEach(free);
-};

package/src/reconciler/reconciler.ts

@@ -1,13 +0,0 @@
-import ReactReconciler from "react-reconciler";
-import packageJson from "../../package.json" with { type: "json" };
-import { createHostConfig, type ReconcilerInstance } from "./host-config.js";
-
-export const reconciler: ReconcilerInstance = ReactReconciler(createHostConfig());
-
-if (process.env.NODE_ENV !== "production") {
-    reconciler.injectIntoDevTools({
-        bundleType: 1,
-        version: packageJson.version,
-        rendererPackageName: "@gtkx/react",
-    });
-}

package/src/reconciler/render.ts

@@ -1,61 +0,0 @@
-import type { ReactNode } from "react";
-import { log, type ReconcilerErrorHandler, setReconcilerErrorHandler } from "./reconciler-error-handler.js";
-import { createReconcilerRoot, type ReconcilerRoot, unmountAllReconcilerRoots } from "./reconciler-root.js";
-import { type RootElement, rootElement } from "./root-element.js";
-import { getSignalStore } from "./signal-store.js";
-
-const priorHandlers = new WeakMap<ReconcilerRoot, ReconcilerErrorHandler | null>();
-
-const teardownRoot = (root: ReconcilerRoot): void => {
-    setReconcilerErrorHandler(priorHandlers.get(root) ?? null);
-    root.update(null);
-};
-
-/**
- * A render root that mounts a React element tree into a container and can unmount it.
- */
-export type Root = {
-    render(element: ReactNode): void;
-    unmount(): void;
-};
-
-/**
- * Creates a render root for a container, wiring reconciler error handling to the container's signal store.
- *
- * @param container The root element to render into; defaults to the shared `rootElement`.
- * @returns A root with `render` and `unmount` methods.
- */
-export const createRoot = (container: RootElement = rootElement): Root => {
-    const onUncaughtError = (error: unknown): void => {
-        getSignalStore(container).unblock();
-        throw error;
-    };
-    const onCaughtError = (error: unknown): void => {
-        getSignalStore(container).unblock();
-        log.error("caught render error", error);
-    };
-
-    const priorHandler = setReconcilerErrorHandler(onUncaughtError);
-
-    const root = createReconcilerRoot({ containerInfo: container, onUncaughtError, onCaughtError });
-    priorHandlers.set(root, priorHandler);
-
-    return {
-        render: (element: ReactNode): void => {
-            root.update(element);
-        },
-        unmount: (): void => {
-            root.unmount(teardownRoot);
-        },
-    };
-};
-
-/**
- * Unmounts all active render roots.
- *
- * @returns `true` once every root has been torn down.
- */
-export const quit = (): true => {
-    unmountAllReconcilerRoots(teardownRoot);
-    return true;
-};

package/src/reconciler/signal-store.ts

@@ -1,103 +0,0 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type { SignalHandler } from "@gtkx/runtime";
-
-const UNBLOCKED_SIGNALS = new Set([
-    "realize",
-    "unrealize",
-    "map",
-    "unmap",
-    "show",
-    "hide",
-    "destroy",
-    "resize",
-    "render",
-    "input",
-    "output",
-]);
-
-type SignalBinding = {
-    instance: GObject.Object;
-    signal: string;
-    handler?: SignalHandler | undefined;
-};
-
-export class SignalStore {
-    private instanceHandlers: Map<GObject.Object, Map<string, number>> = new Map();
-
-    private blockDepth: number = 0;
-
-    private getInstanceMap(instance: GObject.Object): Map<string, number> {
-        let instanceMap = this.instanceHandlers.get(instance);
-        if (!instanceMap) {
-            instanceMap = new Map();
-            this.instanceHandlers.set(instance, instanceMap);
-        }
-        return instanceMap;
-    }
-
-    private gateHandler(handler: SignalHandler, signal: string, instance: GObject.Object): SignalHandler {
-        return (...args: unknown[]) => {
-            if (this.blockDepth > 0 && !UNBLOCKED_SIGNALS.has(signal)) {
-                return;
-            }
-            return handler(...args, instance);
-        };
-    }
-
-    private disconnect(instance: GObject.Object, signal: string): void {
-        const instanceMap = this.instanceHandlers.get(instance);
-        if (!instanceMap) return;
-        const handlerId = instanceMap.get(signal);
-        if (handlerId === undefined) return;
-        instance.disconnect(handlerId);
-        instanceMap.delete(signal);
-        if (instanceMap.size === 0) this.instanceHandlers.delete(instance);
-    }
-
-    private connect(binding: SignalBinding & { handler: SignalHandler }): void {
-        const { instance, signal, handler } = binding;
-        const gatedHandler = this.gateHandler(handler, signal, instance);
-        const handlerId = instance.connect(signal, gatedHandler);
-        this.getInstanceMap(instance).set(signal, handlerId);
-    }
-
-    public set(binding: SignalBinding): void {
-        const { instance, signal, handler } = binding;
-        this.disconnect(instance, signal);
-
-        if (handler) {
-            this.connect({ instance, signal, handler });
-        }
-    }
-
-    public clear(instance: GObject.Object): void {
-        const instanceMap = this.instanceHandlers.get(instance);
-
-        if (instanceMap) {
-            for (const [, handlerId] of instanceMap) {
-                instance.disconnect(handlerId);
-            }
-
-            this.instanceHandlers.delete(instance);
-        }
-    }
-
-    public block(): void {
-        this.blockDepth += 1;
-    }
-
-    public unblock(): void {
-        if (this.blockDepth > 0) this.blockDepth -= 1;
-    }
-}
-
-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;
-}

package/src/reconciler/state.ts

@@ -1,72 +0,0 @@
-import * as GObject from "@gtkx/gi/gobject";
-import { isRootElement, type RootElement } from "./root-element.js";
-import { getSignalStore, type SignalStore } from "./signal-store.js";
-import type { Container, Props } from "./types.js";
-import { isWrapperNode, type WrapperNode } from "./wrapper-node.js";
-import type { WrapperKind } from "./wrapper-protocol.js";
-
-export type Node = GObject.Object | WrapperNode | RootElement;
-
-export type ElementHandler = {
-    attach(anchor?: GObject.Object | null, fresh?: boolean): void;
-    detach(): void;
-};
-
-export type ElementMapping = (child: Node, parent: Node) => ElementHandler | null;
-
-export type State = {
-    kind?: WrapperKind | undefined;
-    props: Props;
-    parent: Node | null;
-    children: Node[];
-    rootContainer: Container;
-    signalStore: SignalStore;
-    adoptedInstance?: GObject.Object | undefined;
-    hidden?: boolean | undefined;
-    visibleWhenShown?: boolean | undefined;
-};
-
-const stateMap = new WeakMap<Node, State>();
-
-type StateSeed = {
-    kind?: WrapperKind;
-    props: Props;
-    rootContainer: Container;
-};
-
-export const registerState = (node: Node, { kind, props, rootContainer }: StateSeed): State => {
-    const state: State = {
-        kind,
-        props,
-        parent: null,
-        children: [],
-        rootContainer,
-        signalStore: getSignalStore(rootContainer),
-    };
-    stateMap.set(node, state);
-    return state;
-};
-
-export const ensureState = (container: Container): State =>
-    stateMap.get(container) ?? registerState(container, { props: {}, rootContainer: container });
-
-export const registeredStateOf = (node: Node): State | undefined => stateMap.get(node);
-
-export const stateOf = (node: Node): State => {
-    const state = stateMap.get(node);
-    if (state) return state;
-    if (node instanceof GObject.Object || isRootElement(node)) return ensureState(node);
-    throw new Error("reconciler node has no registered state");
-};
-
-export const hasWrapperKind = (node: Node, kind: WrapperKind): boolean =>
-    isWrapperNode(node) && stateOf(node).kind === kind;
-
-export const closestInstance = <T extends Node>(node: Node, matches: (node: Node) => node is T): T | null => {
-    let current: Node | null = node;
-    while (current !== null) {
-        if (matches(current)) return current;
-        current = stateOf(current).parent;
-    }
-    return null;
-};

package/src/reconciler/text-buffer-controller.ts

@@ -1,107 +0,0 @@
-import type * as Gdk from "@gtkx/gi/gdk";
-import * as GObject from "@gtkx/gi/gobject";
-import * as Gtk from "@gtkx/gi/gtk";
-import { unparentWidget } from "./container-attach.js";
-import { type Node, stateOf } from "./state.js";
-import { isAnchorNode, isBufferContentNode, isBufferTextNode, isPaintableNode } from "./text-node.js";
-
-export class TextBufferController {
-    private managesContent = false;
-    private owner: Gtk.TextBuffer;
-
-    constructor(owner: Gtk.TextBuffer) {
-        this.owner = owner;
-    }
-
-    private resolveView(): Gtk.TextView | null {
-        let ancestor = stateOf(this.owner).parent;
-        while (ancestor && !(ancestor instanceof GObject.Object)) ancestor = stateOf(ancestor).parent;
-        return ancestor instanceof Gtk.TextView ? ancestor : null;
-    }
-
-    private hasManagedChildren(): boolean {
-        return stateOf(this.owner).children.some((child) => isBufferContentNode(child) || child instanceof Gtk.TextTag);
-    }
-
-    public rebuild = (): void => {
-        const buffer = this.owner;
-
-        if (this.hasManagedChildren()) this.managesContent = true;
-        if (!this.managesContent) return;
-
-        const state = stateOf(this.owner);
-        buffer.beginIrreversibleAction();
-        try {
-            this.clearBuffer(buffer);
-            this.insertChildren(buffer, state.children);
-        } finally {
-            buffer.endIrreversibleAction();
-        }
-    };
-
-    private clearBuffer(buffer: Gtk.TextBuffer): void {
-        const start = buffer.getStartIter();
-        const end = buffer.getEndIter();
-        if (!start.equal(end)) buffer.delete(start, end);
-
-        const tagTable = buffer.getTagTable();
-        const tags: Gtk.TextTag[] = [];
-        tagTable.foreach((tag) => tags.push(tag));
-        for (const tag of tags) tagTable.remove(tag);
-    }
-
-    private insertChildren(buffer: Gtk.TextBuffer, children: Node[]): void {
-        for (const child of children) {
-            this.insertChild(buffer, child);
-        }
-    }
-
-    private insertChild(buffer: Gtk.TextBuffer, child: Node): void {
-        if (stateOf(child).hidden) return;
-        if (isBufferTextNode(child)) {
-            this.insertText(buffer, stateOf(child).props.text as string);
-        } else if (isPaintableNode(child)) {
-            this.insertPaintable(buffer, stateOf(child).props.paintable as Gdk.Paintable);
-        } else if (isAnchorNode(child)) {
-            this.insertAnchor(buffer, child);
-        } else if (child instanceof Gtk.TextTag) {
-            this.insertTag(buffer, child);
-        }
-    }
-
-    private insertTag(buffer: Gtk.TextBuffer, tag: Gtk.TextTag): void {
-        const tagTable = buffer.getTagTable();
-        if (tag.name && !tagTable.lookup(tag.name)) tagTable.add(tag);
-
-        const start = buffer.getCharCount();
-        this.insertChildren(buffer, stateOf(tag).children);
-        const end = buffer.getCharCount();
-        if (end > start) {
-            buffer.applyTag(tag, buffer.getIterAtOffset(start), buffer.getIterAtOffset(end));
-        }
-    }
-
-    private insertAnchor(buffer: Gtk.TextBuffer, node: Node): void {
-        const child = stateOf(node).children[0];
-        const replacement = stateOf(node).props.replacementChar;
-        const anchor =
-            typeof replacement === "string"
-                ? Gtk.TextChildAnchor.newWithReplacement(replacement)
-                : Gtk.TextChildAnchor.new();
-        buffer.insertChildAnchor(buffer.getEndIter(), anchor);
-        const view = this.resolveView();
-        if (view && child instanceof Gtk.Widget) {
-            unparentWidget(child);
-            view.addChildAtAnchor(child, anchor);
-        }
-    }
-
-    private insertPaintable(buffer: Gtk.TextBuffer, paintable: Gdk.Paintable): void {
-        buffer.insertPaintable(buffer.getEndIter(), paintable);
-    }
-
-    private insertText(buffer: Gtk.TextBuffer, text: string): void {
-        if (text.length === 0) return;
-        buffer.insert(buffer.getEndIter(), text, -1);
-    }
-}