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

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

@@ -1,12 +0,0 @@
-import * as Gtk from "@gtkx/gi/gtk";
-import { scheduleContentRebuild } from "./content-rebuild.js";
-import type { Node } from "./state.js";
-import { TextBufferController } from "./text-buffer-controller.js";
-
-export const scheduleBufferRebuild = (node: Node): void => {
-    scheduleContentRebuild(
-        node,
-        (candidate): candidate is Gtk.TextBuffer => candidate instanceof Gtk.TextBuffer,
-        (owner) => new TextBufferController(owner).rebuild,
-    );
-};

package/src/reconciler/text-node.ts

@@ -1,13 +0,0 @@
-import { hasWrapperKind, type Node } from "./state.js";
-import { BUFFER_TEXT_KIND, LABEL_TEXT_KIND, TEXT_ANCHOR_KIND, TEXT_PAINTABLE_KIND } from "./wrapper-protocol.js";
-
-export const isBufferTextNode = (node: Node): boolean => hasWrapperKind(node, BUFFER_TEXT_KIND);
-
-export const isPaintableNode = (node: Node): boolean => hasWrapperKind(node, TEXT_PAINTABLE_KIND);
-
-export const isAnchorNode = (node: Node): boolean => hasWrapperKind(node, TEXT_ANCHOR_KIND);
-
-export const isBufferContentNode = (node: Node): boolean =>
-    isBufferTextNode(node) || isPaintableNode(node) || isAnchorNode(node);
-
-export const isLabelTextNode = (node: Node): boolean => hasWrapperKind(node, LABEL_TEXT_KIND);

package/src/reconciler/types.ts

@@ -1,6 +0,0 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type { RootElement } from "./root-element.js";
-
-export type Container = GObject.Object | RootElement;
-
-export type Props = Record<string, unknown>;

package/src/reconciler/visibility.ts

@@ -1,52 +0,0 @@
-import * as Gtk from "@gtkx/gi/gtk";
-import { scheduleLabelTextRebuild } from "./label-text-rebuild.js";
-import { type Node, stateOf } from "./state.js";
-import { scheduleBufferRebuild } from "./text-buffer-rebuild.js";
-import { isBufferContentNode } from "./text-node.js";
-
-const widgetOf = (node: Node): Gtk.Widget | null => {
-    if (node instanceof Gtk.Widget) return node;
-    const adopted = stateOf(node).adoptedInstance;
-    return adopted instanceof Gtk.Widget ? adopted : null;
-};
-
-export const hideNode = (node: Node): void => {
-    const state = stateOf(node);
-    if (state.hidden) return;
-    state.hidden = true;
-    const widget = widgetOf(node);
-    if (!widget) return;
-    state.visibleWhenShown = widget.getVisible();
-    widget.setVisible(false);
-};
-
-export const unhideNode = (node: Node): void => {
-    const state = stateOf(node);
-    if (!state.hidden) return;
-    state.hidden = false;
-    const widget = widgetOf(node);
-    if (!widget) return;
-    widget.setVisible(state.visibleWhenShown ?? true);
-    state.visibleWhenShown = undefined;
-};
-
-export const reassertHidden = (node: Node): void => {
-    const state = stateOf(node);
-    if (!state.hidden) return;
-    const widget = widgetOf(node);
-    if (!widget?.getVisible()) return;
-    state.visibleWhenShown = true;
-    widget.setVisible(false);
-};
-
-const scheduleTextNodeRebuild = (node: Node): void => {
-    if (isBufferContentNode(node)) scheduleBufferRebuild(node);
-    else scheduleLabelTextRebuild(node);
-};
-
-export const setTextNodeHidden = (node: Node, hidden: boolean): void => {
-    const state = stateOf(node);
-    if ((state.hidden ?? false) === hidden) return;
-    state.hidden = hidden;
-    scheduleTextNodeRebuild(node);
-};

package/src/reconciler/wrapper-apply.ts

@@ -1,308 +0,0 @@
-import type { ContainerProp } from "@gtkx/config";
-import * as GObject from "@gtkx/gi/gobject";
-import * as Gtk from "@gtkx/gi/gtk";
-import { applyProps } from "./apply-props.js";
-import { attachChild, detachChild, getFocusWidget, isDescendantOf, unparentWidget } from "./container-attach.js";
-import {
-    adoptContainerPropFor,
-    type CallScope,
-    nullSetterCurrentHolder,
-    resolveContainerProp,
-    runCall,
-    runCallValue,
-} from "./element-props.js";
-import { type ElementMapping, hasWrapperKind, type Node, registeredStateOf, registerState, stateOf } from "./state.js";
-import type { Props } from "./types.js";
-import { trackedInstance, trackedWidget, wrapperChildInstances } from "./wrapper-content.js";
-import { CONTAINER_PROP_KIND, LAZY_ELEMENT_KIND, OBJECT_PROP_KIND } from "./wrapper-protocol.js";
-
-const attachedParent = new WeakMap<GObject.Object, GObject.Object>();
-
-const scopeFor = (child: GObject.Object, extra?: Partial<CallScope>): CallScope => ({
-    child,
-    props: stateOf(child).props,
-    ...extra,
-});
-
-const runRemove = (parent: GObject.Object, child: GObject.Object, cp: ContainerProp): void => {
-    if (cp.remove !== undefined) runCall(parent, cp.remove, [child], scopeFor(child));
-};
-
-const collectContainerSiblings = (parent: GObject.Object, cp: ContainerProp): GObject.Object[] => {
-    const siblings: GObject.Object[] = [];
-    for (const sibling of stateOf(parent).children) {
-        if (!(sibling instanceof GObject.Object) || sibling instanceof Gtk.Widget) continue;
-        if (resolveContainerProp(parent.__type__, sibling.__type__, undefined) === cp) siblings.push(sibling);
-    }
-    return siblings;
-};
-
-const insertContainerChildAt = (
-    parent: GObject.Object,
-    child: GObject.Object,
-    cp: ContainerProp,
-    index: number,
-): void => {
-    if (cp.insert !== undefined && runCall(parent, cp.insert, [child, index], scopeFor(child, { index }))) {
-        attachedParent.set(child, parent);
-    }
-};
-
-const attachContainerChild = (
-    parent: GObject.Object,
-    child: GObject.Object,
-    cp: ContainerProp,
-    anchor: GObject.Object | null | undefined,
-): void => {
-    const isMove = attachedParent.get(child) === parent;
-    if (cp.insert !== undefined && (anchor != null || isMove)) {
-        if (isMove) runRemove(parent, child, cp);
-        const siblings = collectContainerSiblings(parent, cp);
-        const index = siblings.indexOf(child);
-        insertContainerChildAt(parent, child, cp, index);
-        if (!isMove) {
-            for (const trailing of siblings.slice(index + 1)) {
-                runRemove(parent, trailing, cp);
-                insertContainerChildAt(parent, trailing, cp, siblings.indexOf(trailing));
-            }
-        }
-        return;
-    }
-    if (isMove) return;
-    if (cp.append !== undefined && runCall(parent, cp.append, [child], scopeFor(child))) {
-        attachedParent.set(child, parent);
-    }
-};
-
-const detachContainerChild = (parent: GObject.Object, child: GObject.Object, cp: ContainerProp): void => {
-    if (attachedParent.get(child) !== parent) return;
-    const holder = cp.remove !== undefined ? nullSetterCurrentHolder(parent, cp.remove) : undefined;
-    if (holder === undefined || holder === child) runRemove(parent, child, cp);
-    attachedParent.delete(child);
-};
-
-type ContainerChildMatch = { child: GObject.Object; parent: GObject.Object; cp: ContainerProp };
-
-const resolveContainerChild = (child: Node, parent: Node): ContainerChildMatch | null => {
-    if (!(child instanceof GObject.Object) || child instanceof Gtk.Widget) return null;
-    if (!(parent instanceof GObject.Object)) return null;
-    const cp = resolveContainerProp(parent.__type__, child.__type__, undefined);
-    return cp === null ? null : { child, parent, cp };
-};
-
-export const containerChildMapping: ElementMapping = (child, parent) => {
-    const match = resolveContainerChild(child, parent);
-    if (match === null) return null;
-    return {
-        attach: (anchor) => attachContainerChild(match.parent, match.child, match.cp, anchor),
-        detach: () => detachContainerChild(match.parent, match.child, match.cp),
-    };
-};
-
-const attachPropChild = (parent: GObject.Object, child: GObject.Object, propName: string): void => {
-    const cp = resolveContainerProp(parent.__type__, child.__type__, propName);
-    if (cp !== null) attachContainerChild(parent, child, cp, null);
-};
-
-const detachPropChild = (parent: GObject.Object, child: GObject.Object, propName: string): void => {
-    const cp = resolveContainerProp(parent.__type__, child.__type__, propName);
-    if (cp !== null) detachContainerChild(parent, child, cp);
-};
-
-const isRooted = (instance: GObject.Object): boolean =>
-    instance instanceof Gtk.Widget ? instance.getRoot() !== null : true;
-
-const rescueFocus = (parent: GObject.Object, child: GObject.Object | undefined): void => {
-    if (!(parent instanceof Gtk.Widget) || !(child instanceof Gtk.Widget)) return;
-    const focus = getFocusWidget(child);
-    if (focus && isDescendantOf(focus, child)) parent.grabFocus();
-};
-
-type ObjectPropState = { prop: string; value: GObject.Object };
-
-const objectPropState = new WeakMap<Node, ObjectPropState>();
-
-export const objectPropMapping: ElementMapping = (child, parent) => {
-    if (!hasWrapperKind(child, OBJECT_PROP_KIND) || !(parent instanceof GObject.Object)) return null;
-    return {
-        attach: () => {
-            const prop = propNameOf(child);
-            if (prop === undefined) return;
-            const value = trackedInstance(child);
-            const state = objectPropState.get(child);
-            if (state && state.value === value) return;
-            Reflect.set(parent, prop, value ?? null);
-            if (value) objectPropState.set(child, { prop, value });
-            else objectPropState.delete(child);
-        },
-        detach: () => {
-            const state = objectPropState.get(child);
-            objectPropState.delete(child);
-            if (!state || !isRooted(parent)) return;
-            rescueFocus(parent, state.value);
-            Reflect.set(parent, state.prop, null);
-        },
-    };
-};
-
-const sameInstances = (a: Node[], b: Node[]): boolean =>
-    a.length === b.length && a.every((instance, index) => instance === b[index]);
-
-const propNameOf = (node: Node): string | undefined => {
-    const propName = stateOf(node).props.propName;
-    return typeof propName === "string" ? propName : undefined;
-};
-
-const containerPropState = new WeakMap<Node, GObject.Object[]>();
-
-const detachContainerPropChild = (instance: GObject.Object, parent: GObject.Object, propName: string): void => {
-    detachPropChild(parent, instance, propName);
-    if (instance instanceof Gtk.Widget && instance.getParent() !== null) unparentWidget(instance);
-};
-
-export const containerPropMapping: ElementMapping = (child, parent) => {
-    if (!hasWrapperKind(child, CONTAINER_PROP_KIND) || !(parent instanceof GObject.Object)) return null;
-    return {
-        attach: () => {
-            const propName = propNameOf(child);
-            if (propName === undefined) return;
-            const desired = wrapperChildInstances(child);
-            const prev = containerPropState.get(child) ?? [];
-            if (sameInstances(prev, desired)) return;
-            for (const instance of prev) detachContainerPropChild(instance, parent, propName);
-            for (const instance of desired) attachPropChild(parent, instance, propName);
-            containerPropState.set(child, desired);
-        },
-        detach: () => {
-            const propName = propNameOf(child);
-            const instances = containerPropState.get(child) ?? [];
-            containerPropState.delete(child);
-            if (propName === undefined) return;
-            for (const instance of instances) detachContainerPropChild(instance, parent, propName);
-        },
-    };
-};
-
-type LazyState = { content: Gtk.Widget | null; instance: GObject.Object | null; appliedProps: Props; ordinal: number };
-
-const lazyState = new WeakMap<Node, LazyState>();
-
-const freshLazyState = (): LazyState => ({ content: null, instance: null, appliedProps: {}, ordinal: -1 });
-
-const RESERVED_LAZY_PROPS = new Set(["children", "ref", "key", "kind"]);
-
-const lazyPropsOf = (nodeProps: Props): Props => {
-    const built: Props = {};
-    for (const [name, value] of Object.entries(nodeProps)) {
-        if (RESERVED_LAZY_PROPS.has(name)) continue;
-        built[name] = value;
-    }
-    return built;
-};
-
-const lazyOrdinal = (parent: Node, node: Node): number => {
-    let ordinal = 0;
-    for (const sibling of stateOf(parent).children) {
-        if (sibling === node) return ordinal;
-        if (hasWrapperKind(sibling, LAZY_ELEMENT_KIND)) ordinal++;
-    }
-    return ordinal;
-};
-
-const appendLazyContent = (
-    parent: GObject.Object,
-    cp: ContainerProp,
-    node: Node,
-    content: Gtk.Widget,
-): GObject.Object | undefined => {
-    let appended: unknown;
-    if (cp.insert !== undefined) {
-        const ordinal = lazyOrdinal(parent, node);
-        appended = runCallValue(parent, cp.insert, [content, ordinal], {
-            child: content,
-            index: ordinal,
-            props: stateOf(node).props,
-        }).value;
-    } else if (cp.append !== undefined) {
-        appended = runCallValue(parent, cp.append, [content], { child: content, props: stateOf(node).props }).value;
-    } else {
-        attachChild(content, parent);
-    }
-    const accessor = typeof cp.adopt === "string" ? cp.adopt : undefined;
-    const acquired =
-        accessor !== undefined ? runCallValue(parent, accessor, [content], { child: content }).value : appended;
-    return acquired instanceof GObject.Object ? acquired : undefined;
-};
-
-const applyAdoptedProps = (state: LazyState, node: Node): void => {
-    if (state.instance === null) return;
-    const built = lazyPropsOf(stateOf(node).props);
-    applyProps(state.instance, state.appliedProps, built, {});
-    state.appliedProps = built;
-};
-
-const releaseLazyContent = (node: Node, state: LazyState, parent: GObject.Object, cp: ContainerProp): void => {
-    const { content, instance } = state;
-    if (instance !== null) {
-        registeredStateOf(instance)?.signalStore.clear(instance);
-        stateOf(node).adoptedInstance = undefined;
-    }
-    state.instance = null;
-    state.appliedProps = {};
-    if (content !== null) {
-        if (cp.remove !== undefined) {
-            const stillInside =
-                !(parent instanceof Gtk.Widget) || (content.getParent() !== null && isDescendantOf(content, parent));
-            if (stillInside) runCall(parent, cp.remove, [content], { child: content, adopted: instance ?? undefined });
-        } else {
-            detachChild(content, parent);
-        }
-    }
-    state.content = null;
-};
-
-const syncLazyElement = (parent: GObject.Object, cp: ContainerProp, node: Node): void => {
-    const state = lazyState.get(node) ?? freshLazyState();
-    lazyState.set(node, state);
-    const content = trackedWidget(node);
-    if (state.content !== null && state.content !== content) releaseLazyContent(node, state, parent, cp);
-    if (content === null) return;
-    if (state.instance === null) {
-        const instance = appendLazyContent(parent, cp, node, content);
-        state.content = content;
-        state.ordinal = lazyOrdinal(parent, node);
-        if (instance !== undefined) {
-            state.instance = instance;
-            stateOf(node).adoptedInstance = instance;
-            if (!registeredStateOf(instance)) {
-                registerState(instance, { props: {}, rootContainer: stateOf(node).rootContainer });
-            }
-        }
-    } else if (cp.reorder !== undefined) {
-        const ordinal = lazyOrdinal(parent, node);
-        if (ordinal !== state.ordinal) {
-            runCall(parent, cp.reorder, [content, ordinal], {
-                child: content,
-                index: ordinal,
-                adopted: state.instance ?? undefined,
-            });
-            state.ordinal = ordinal;
-        }
-    }
-    applyAdoptedProps(state, node);
-};
-
-export const lazyElementMapping: ElementMapping = (child, parent) => {
-    if (!hasWrapperKind(child, LAZY_ELEMENT_KIND) || !(parent instanceof GObject.Object)) return null;
-    const cp = adoptContainerPropFor(parent.__type__);
-    if (cp === null) return null;
-    return {
-        attach: () => syncLazyElement(parent, cp, child),
-        detach: () => {
-            const state = lazyState.get(child);
-            lazyState.delete(child);
-            if (!state) return;
-            releaseLazyContent(child, state, parent, cp);
-        },
-    };
-};

package/src/reconciler/wrapper-content.ts

@@ -1,24 +0,0 @@
-import * as GObject from "@gtkx/gi/gobject";
-import * as Gtk from "@gtkx/gi/gtk";
-import { type Node, stateOf } from "./state.js";
-import { isWrapperNode } from "./wrapper-node.js";
-
-export const childWidget = (instance: Node): Gtk.Widget | null => (instance instanceof Gtk.Widget ? instance : null);
-
-const trackedChild = (node: Node): Node | null => {
-    const { children } = stateOf(node);
-    return children.find((child) => !isWrapperNode(child)) ?? children[0] ?? null;
-};
-
-export const trackedWidget = (node: Node): Gtk.Widget | null => {
-    const child = trackedChild(node);
-    return child instanceof Gtk.Widget ? child : null;
-};
-
-export const trackedInstance = (node: Node): GObject.Object | undefined => {
-    const child = trackedChild(node);
-    return child instanceof GObject.Object ? child : undefined;
-};
-
-export const wrapperChildInstances = (node: Node): GObject.Object[] =>
-    stateOf(node).children.filter((child): child is GObject.Object => child instanceof GObject.Object);

package/src/reconciler/wrapper-node.ts

@@ -1,8 +0,0 @@
-const WRAPPER_NODE: unique symbol = Symbol.for("gtkx.wrapperNode");
-
-export type WrapperNode = { [WRAPPER_NODE]: true };
-
-export const createWrapperNode = (): WrapperNode => ({ [WRAPPER_NODE]: true });
-
-export const isWrapperNode = (value: unknown): value is WrapperNode =>
-    typeof value === "object" && value !== null && WRAPPER_NODE in value;

package/src/reconciler/wrapper-protocol.ts

@@ -1,32 +0,0 @@
-export const WRAPPER_NODE_ELEMENT = "__GTKX_WRAPPER_NODE__";
-
-const WRAPPER_KINDS = [
-    "lazy-element",
-    "object-prop",
-    "container-prop",
-    "text-anchor",
-    "text-paintable",
-    "buffer-text",
-    "label-text",
-] as const;
-
-export type WrapperKind = (typeof WRAPPER_KINDS)[number];
-
-const WRAPPER_KIND_SET: Set<string> = new Set(WRAPPER_KINDS);
-
-export const isWrapperKind = (value: unknown): value is WrapperKind =>
-    typeof value === "string" && WRAPPER_KIND_SET.has(value);
-
-export const LAZY_ELEMENT_KIND: WrapperKind = "lazy-element";
-
-export const OBJECT_PROP_KIND: WrapperKind = "object-prop";
-
-export const CONTAINER_PROP_KIND: WrapperKind = "container-prop";
-
-export const TEXT_ANCHOR_KIND: WrapperKind = "text-anchor";
-
-export const TEXT_PAINTABLE_KIND: WrapperKind = "text-paintable";
-
-export const BUFFER_TEXT_KIND: WrapperKind = "buffer-text";
-
-export const LABEL_TEXT_KIND: WrapperKind = "label-text";

package/src/utils/create-element-component.ts

@@ -1,77 +0,0 @@
-import { createElement, isValidElement, type ReactNode } from "react";
-import { containerPropNamesFor } from "../reconciler/element-props.js";
-import {
-    CONTAINER_PROP_KIND,
-    LAZY_ELEMENT_KIND,
-    OBJECT_PROP_KIND,
-    WRAPPER_NODE_ELEMENT,
-} from "../reconciler/wrapper-protocol.js";
-
-const needsSplit = (props: object, containerPropNames: Set<string>): boolean => {
-    for (const [name, value] of Object.entries(props)) {
-        if (name === "children") continue;
-        if (containerPropNames.has(name)) return true;
-        if (isValidElement(value)) return true;
-    }
-    return false;
-};
-
-type SplitProps = {
-    rest: Record<string, unknown>;
-    wrappers: ReactNode[];
-    children: ReactNode;
-};
-
-const splitProps = (props: object, containerPropNames: Set<string>): SplitProps => {
-    const rest: Record<string, unknown> = {};
-    const wrappers: ReactNode[] = [];
-    let children: ReactNode = null;
-    for (const [name, value] of Object.entries(props)) {
-        if (name === "children") {
-            children = value as ReactNode;
-            continue;
-        }
-        if (containerPropNames.has(name)) {
-            if (value != null) {
-                wrappers.push(
-                    createElement(
-                        WRAPPER_NODE_ELEMENT,
-                        { kind: CONTAINER_PROP_KIND, propName: name, key: `container-prop:${name}` },
-                        value as ReactNode,
-                    ),
-                );
-            }
-            continue;
-        }
-        if (isValidElement(value)) {
-            wrappers.push(
-                createElement(
-                    WRAPPER_NODE_ELEMENT,
-                    { kind: OBJECT_PROP_KIND, propName: name, key: `object-prop:${name}` },
-                    value as ReactNode,
-                ),
-            );
-            continue;
-        }
-        rest[name] = value;
-    }
-    return { rest, wrappers, children };
-};
-
-export const createElementComponent = <P extends object>(elementName: string): ((props: P) => ReactNode) => {
-    const containerPropNames = containerPropNamesFor(elementName);
-    return (props: P): ReactNode => {
-        if (!needsSplit(props, containerPropNames)) return createElement(elementName, props);
-        const { rest, wrappers, children } = splitProps(props, containerPropNames);
-        return createElement(elementName, rest, children, ...wrappers);
-    };
-};
-
-const NO_CONTAINER_PROPS: Set<string> = new Set();
-
-export const createLazyElementComponent = <P extends object>(): ((props: P) => ReactNode) => {
-    return (props: P): ReactNode => {
-        const { rest, wrappers, children } = splitProps(props, NO_CONTAINER_PROPS);
-        return createElement(WRAPPER_NODE_ELEMENT, { kind: LAZY_ELEMENT_KIND, ...rest }, children, ...wrappers);
-    };
-};