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

package/src/reconciler/instance.ts

@@ -1,30 +1,82 @@
-import * as GObject from "@gtkx/gi/gobject";
-import { collectConstructableProps, requireClassByName } from "../utils/gtype.js";
-import { constructionSkipProps } from "./element-props.js";
-import { type Node, registerState } from "./state.js";
-import type { Container, Props } from "./types.js";
-import { createWrapperNode } from "./wrapper-node.js";
-import type { WrapperKind } from "./wrapper-protocol.js";
-
-const pickConstructProps = (gtype: bigint, props: Props): Props => {
-    const constructable = collectConstructableProps(gtype);
-    const skipped = constructionSkipProps(gtype);
-    const result: Props = {};
-    for (const name in props) {
-        if (constructable.has(name) && !skipped.has(name)) result[name] = props[name];
+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 result;
+
+    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);
 };
 
-export const createElementInstance = (type: string, props: Props, rootContainer: Container): Node => {
-    const cls = requireClassByName(type);
-    const node = new cls(pickConstructProps(GObject.typeFromName(type), props));
-    registerState(node, { props, rootContainer });
-    return node;
+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);
 };
 
-export const createWrapperInstance = (kind: WrapperKind, props: Props, rootContainer: Container): Node => {
-    const node = createWrapperNode();
-    registerState(node, { kind, props, rootContainer });
-    return node;
+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 };

package/src/reconciler/node.ts

@@ -0,0 +1,161 @@
+import type * as GObject from "@gtkx/gi/gobject";
+import type * as Gtk from "@gtkx/gi/gtk";
+import type { SignalHandler } from "@gtkx/runtime";
+import { getOrInsert } from "@gtkx/utils";
+import type { ElementBehavior, Props } from "./registry.js";
+
+type ContentKind = "label" | "buffer" | "tag" | "anchor";
+type HandlerRecord = { signal: string; handler: SignalHandler; wrapped: SignalHandler; blockable: boolean };
+type Dispatch = (fn: () => unknown) => unknown;
+
+type SignalTarget = {
+    object: GObject.Object;
+    handlers: Map<string, HandlerRecord>;
+    typeName: string;
+    dispatch: Dispatch;
+};
+
+type PlacedChild = {
+    node: PlaceableNode;
+    object: GObject.Object;
+    adopted: GObject.Object | null;
+    slot: string;
+    behavior: ElementBehavior | null;
+    attached: boolean;
+};
+
+type ElementNode = SignalTarget & {
+    kind: typeof ELEMENT_KIND;
+    props: Props;
+    placements: Map<string, PlacedChild[]>;
+    contexts: Map<ElementBehavior, unknown>;
+    parent: ParentNode | null;
+    content: ContentChild[];
+    contentKind: ContentKind | null;
+    bufferView: Gtk.TextView | null;
+};
+
+type PropNode = {
+    kind: typeof PROP_KIND;
+    slot: string;
+    children: PlaceableNode[];
+    parent: ElementNode | null;
+};
+
+type LazyNode = {
+    kind: typeof LAZY_KIND;
+    typeName: string;
+    props: Props;
+    children: PlaceableNode[];
+    parent: ElementNode | null;
+    adopted: GObject.Object | null;
+    handlers: Map<string, HandlerRecord>;
+    dispatch: Dispatch;
+};
+
+type TextNode = {
+    kind: typeof TEXT_KIND;
+    text: string;
+    parent: ParentNode | null;
+};
+
+type PlaceableNode = ElementNode | LazyNode;
+type ParentNode = ElementNode | PropNode | LazyNode;
+type ContentChild = TextNode | ElementNode;
+type Instance = ElementNode | PropNode | LazyNode;
+type AnyNode = Instance | TextNode;
+
+const ELEMENT_KIND = "element";
+const PROP_KIND = "prop";
+const TEXT_KIND = "text";
+const LAZY_KIND = "lazy";
+const DEFAULT_SLOT = "children";
+
+const createPropNode = (slot: string): PropNode => ({
+    kind: PROP_KIND,
+    slot,
+    children: [],
+    parent: null,
+});
+
+const createLazyNode = (typeName: string, props: Props, dispatch: Dispatch): LazyNode => ({
+    kind: LAZY_KIND,
+    typeName,
+    props,
+    children: [],
+    parent: null,
+    adopted: null,
+    handlers: new Map(),
+    dispatch,
+});
+
+const createElementNode = (
+    typeName: string,
+    object: GObject.Object,
+    dispatch: Dispatch,
+    contentKind: ContentKind | null,
+): ElementNode => ({
+    kind: ELEMENT_KIND,
+    typeName,
+    object,
+    props: {},
+    handlers: new Map(),
+    placements: new Map(),
+    contexts: new Map(),
+    parent: null,
+    content: [],
+    contentKind,
+    bufferView: null,
+    dispatch,
+});
+
+const createTextNode = (text: string): TextNode => ({ kind: TEXT_KIND, text, parent: null });
+
+const nodeObject = (node: PlaceableNode): GObject.Object | null => {
+    if (node.kind === LAZY_KIND) {
+        const [child] = node.children;
+
+        return child === undefined ? null : nodeObject(child);
+    }
+
+    return node.object;
+};
+
+const lazyTarget = (node: LazyNode, adopted: GObject.Object): SignalTarget => ({
+    object: adopted,
+    handlers: node.handlers,
+    typeName: node.typeName,
+    dispatch: node.dispatch,
+});
+
+const getOrCreateContext = (node: ElementNode, behavior: ElementBehavior): unknown =>
+    getOrInsert(node.contexts, behavior, () => behavior.createContext?.(node.object));
+
+export {
+    ELEMENT_KIND,
+    PROP_KIND,
+    TEXT_KIND,
+    LAZY_KIND,
+    DEFAULT_SLOT,
+    createPropNode,
+    createLazyNode,
+    createElementNode,
+    createTextNode,
+    nodeObject,
+    lazyTarget,
+    getOrCreateContext,
+    type ContentKind,
+    type HandlerRecord,
+    type Dispatch,
+    type SignalTarget,
+    type PlacedChild,
+    type ElementNode,
+    type PropNode,
+    type LazyNode,
+    type TextNode,
+    type PlaceableNode,
+    type ParentNode,
+    type ContentChild,
+    type Instance,
+    type AnyNode,
+};

package/src/reconciler/placement.ts

@@ -0,0 +1,255 @@
+import * as GObject from "@gtkx/gi/gobject";
+import * as Gtk from "@gtkx/gi/gtk";
+import { getOrInsert, indexBeforeOrEnd, remove } from "@gtkx/utils";
+import type { DetachInfo, ElementBehavior, PlaceInfo } from "./registry.js";
+import { applyAdoptedProps, markFlush } from "./apply-props.js";
+import { typeInfoFor } from "./metadata.js";
+import {
+    DEFAULT_SLOT,
+    ELEMENT_KIND,
+    type ElementNode,
+    getOrCreateContext,
+    LAZY_KIND,
+    lazyTarget,
+    nodeObject,
+    type PlaceableNode,
+    type PlacedChild,
+} from "./node.js";
+import { markTextDirty } from "./text.js";
+
+type AttachContext = { parent: ElementNode; entry: PlacedChild; index: number; sibling: GObject.Object | null };
+
+const createEntry = (slot: string, node: PlaceableNode): PlacedChild | null => {
+    const object = nodeObject(node);
+
+    if (object === null) {
+        return null;
+    }
+
+    return { node, object, adopted: null, slot, behavior: null, attached: false };
+};
+
+const siblingAt = (entries: PlacedChild[], index: number): GObject.Object | null =>
+    index > 0 ? (entries[index - 1]?.object ?? null) : null;
+
+const placeInfo = (entry: PlacedChild, index: number, sibling: GObject.Object | null, context: unknown): PlaceInfo => ({
+    slot: entry.slot,
+    index,
+    sibling,
+    adopted: entry.adopted,
+    props: entry.node.props,
+    context,
+});
+
+const adoptedFrom = (parent: ElementNode, entry: PlacedChild, behavior: ElementBehavior, claim: unknown): void => {
+    if (behavior.resolve !== undefined) {
+        entry.adopted = behavior.resolve(parent.object, entry.object);
+
+        return;
+    }
+
+    entry.adopted = claim instanceof GObject.Object ? claim : null;
+};
+
+const applyLazyProps = (entry: PlacedChild): void => {
+    if (entry.node.kind !== LAZY_KIND || entry.adopted === null) {
+        return;
+    }
+
+    applyAdoptedProps(lazyTarget(entry.node, entry.adopted), {}, entry.node.props);
+    entry.node.adopted = entry.adopted;
+};
+
+const wireBufferView = (node: PlaceableNode, parent: ElementNode): void => {
+    if (!(node.kind === ELEMENT_KIND && node.contentKind === "buffer" && parent.object instanceof Gtk.TextView)) {
+        return;
+    }
+
+    node.bufferView = parent.object;
+    markTextDirty(node);
+};
+
+const setObjectSlot = (parent: ElementNode, entry: PlacedChild): void => {
+    Reflect.set(parent.object, entry.slot, entry.object);
+    wireBufferView(entry.node, parent);
+    entry.behavior = null;
+    entry.attached = true;
+};
+
+const didAttach = (ctx: AttachContext, behavior: ElementBehavior): boolean => {
+    const attach = behavior.attach;
+
+    if (attach === undefined) {
+        return false;
+    }
+
+    const context = getOrCreateContext(ctx.parent, behavior);
+    const claim = attach(ctx.parent.object, ctx.entry.object, placeInfo(ctx.entry, ctx.index, ctx.sibling, context));
+
+    if (claim === undefined) {
+        return false;
+    }
+
+    ctx.entry.behavior = behavior;
+    adoptedFrom(ctx.parent, ctx.entry, behavior, claim);
+    ctx.entry.attached = true;
+    applyLazyProps(ctx.entry);
+
+    return true;
+};
+
+const attachEntry = (parent: ElementNode, entry: PlacedChild, index: number, sibling: GObject.Object | null): void => {
+    const ctx: AttachContext = { parent, entry, index, sibling };
+
+    for (const behavior of typeInfoFor(parent.typeName).behaviors) {
+        if (didAttach(ctx, behavior)) {
+            return;
+        }
+    }
+
+    if (entry.slot !== DEFAULT_SLOT) {
+        setObjectSlot(parent, entry);
+    }
+};
+
+const detachInfo = (entry: PlacedChild, context: unknown): DetachInfo => ({
+    slot: entry.slot,
+    adopted: entry.adopted,
+    props: entry.node.props,
+    context,
+});
+
+const detachEntry = (parent: ElementNode, entry: PlacedChild): void => {
+    if (!entry.attached) {
+        return;
+    }
+
+    entry.attached = false;
+    const behavior = entry.behavior;
+
+    if (behavior === null) {
+        if (entry.slot !== DEFAULT_SLOT) {
+            Reflect.set(parent.object, entry.slot, null);
+        }
+
+        return;
+    }
+
+    behavior.detach?.(parent.object, entry.object, detachInfo(entry, getOrCreateContext(parent, behavior)));
+};
+
+const rebuild = (parent: ElementNode, entries: PlacedChild[]): void => {
+    for (const entry of entries) {
+        detachEntry(parent, entry);
+    }
+
+    for (const [index, entry] of entries.entries()) {
+        entry.behavior = null;
+        attachEntry(parent, entry, index, siblingAt(entries, index));
+    }
+};
+
+const getPosition = (entries: PlacedChild[], before: PlaceableNode | null): number =>
+    indexBeforeOrEnd(entries, before, (entry, target) => entry.node === target);
+
+const placeNew = (parent: ElementNode, entry: PlacedChild, entries: PlacedChild[], index: number): void => {
+    attachEntry(parent, entry, index, siblingAt(entries, index));
+
+    if (!entry.attached) {
+        remove(entries, entry);
+
+        return;
+    }
+
+    const isInsertedBeforeEnd = index < entries.length - 1;
+    const isCannotReorderInPlace = entry.behavior !== null && entry.behavior.reorder === undefined;
+
+    if (isInsertedBeforeEnd && isCannotReorderInPlace) {
+        rebuild(parent, entries);
+    }
+};
+
+const moveEntry = (parent: ElementNode, entry: PlacedChild, entries: PlacedChild[], index: number): void => {
+    const behavior = entry.behavior;
+    const reorder = behavior?.reorder;
+
+    if (behavior === null || reorder === undefined) {
+        rebuild(parent, entries);
+
+        return;
+    }
+
+    const context = getOrCreateContext(parent, behavior);
+    const claim = reorder(parent.object, entry.object, placeInfo(entry, index, siblingAt(entries, index), context));
+    adoptedFrom(parent, entry, behavior, claim);
+    applyLazyProps(entry);
+};
+
+const resolveEntry = (
+    entries: PlacedChild[],
+    existing: number,
+    slot: string,
+    node: PlaceableNode,
+): PlacedChild | null => {
+    if (existing >= 0) {
+        return entries[existing] ?? null;
+    }
+
+    return createEntry(slot, node);
+};
+
+const placeChild = (
+    parent: ElementNode,
+    slot: string,
+    node: PlaceableNode,
+    before: PlaceableNode | null,
+): void => {
+    const entries = getOrInsert(parent.placements, slot, () => []);
+    const existing = entries.findIndex((entry) => entry.node === node);
+    const entry = resolveEntry(entries, existing, slot, node);
+
+    if (entry === null) {
+        return;
+    }
+
+    const isMove = existing !== -1;
+
+    if (isMove) {
+        entries.splice(existing, 1);
+    }
+
+    const index = getPosition(entries, before);
+    entries.splice(index, 0, entry);
+
+    if (isMove) {
+        moveEntry(parent, entry, entries, index);
+    } else {
+        placeNew(parent, entry, entries, index);
+    }
+
+    markFlush(parent);
+};
+
+const unplaceChild = (parent: ElementNode, slot: string, node: PlaceableNode): void => {
+    const entries = parent.placements.get(slot);
+
+    if (entries === undefined) {
+        return;
+    }
+
+    const index = entries.findIndex((entry) => entry.node === node);
+
+    if (index === -1) {
+        return;
+    }
+
+    const [entry] = entries.splice(index, 1);
+
+    if (entry !== undefined) {
+        detachEntry(parent, entry);
+    }
+
+    markFlush(parent);
+};
+
+export { placeChild, unplaceChild };