@gtkx/react 0.20.0 → 1.0.0-rc.1

package/src/reconciler/wrapper-content.ts

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,32 @@
+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/accessible-metadata.ts

@@ -0,0 +1,26 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+
+type AccessibleMetadata = Map<string, unknown>;
+
+const accessibleMetadata = new WeakMap<Gtk.Accessible, AccessibleMetadata>();
+
+export const setAccessibleMetadata = (accessible: Gtk.Accessible, propName: string, value: unknown): void => {
+    let entry = accessibleMetadata.get(accessible);
+    if (!entry) {
+        entry = new Map();
+        accessibleMetadata.set(accessible, entry);
+    }
+    entry.set(propName, value);
+};
+
+export const deleteAccessibleMetadata = (accessible: Gtk.Accessible, propName: string): void => {
+    const entry = accessibleMetadata.get(accessible);
+    if (entry) entry.delete(propName);
+};
+
+export const getAccessibleMetadata = <T = unknown>(accessible: Gtk.Accessible, propName: string): T | null => {
+    const entry = accessibleMetadata.get(accessible);
+    if (!entry) return null;
+    const value = entry.get(propName);
+    return (value as T) ?? null;
+};

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

@@ -0,0 +1,77 @@
+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);
+    };
+};

package/src/utils/gtype.ts

@@ -0,0 +1,166 @@
+/// <reference types="@gtkx/config/env" />
+
+import { CONSTRUCT_ONLY_PROPS, CONSTRUCT_PROPS, DEFAULT_PROPS, SIGNALS } from "virtual:gtkx-config";
+import * as GObject from "@gtkx/gi/gobject";
+import { getWrapperClass, type TypedClass } from "@gtkx/runtime";
+import { NOTIFY_SIGNAL, propToNotifySignal } from "./notify-name.js";
+
+const NOTIFY_PREFIX = "onNotify";
+
+const resolveNotifySignal = (propName: string): string | null => {
+    if (propName === NOTIFY_PREFIX) return NOTIFY_SIGNAL;
+    if (!propName.startsWith(NOTIFY_PREFIX)) return null;
+    const tail = propName.slice(NOTIFY_PREFIX.length);
+    if (tail.charAt(0) !== tail.charAt(0).toUpperCase()) return null;
+    return propToNotifySignal(tail);
+};
+
+const typeNameChainCache = new Map<bigint, string[]>();
+const interfaceNamesCache = new Map<bigint, string[]>();
+const typeNameSetCache = new Map<bigint, Set<string>>();
+const signalCache = new Map<bigint, Map<string, string | null>>();
+const constructOnlyCache = new Map<bigint, Map<string, boolean>>();
+const defaultPropCache = new Map<bigint, Map<string, DefaultPropLookup>>();
+const constructablePropsCache = new Map<bigint, Set<string>>();
+
+const memoizeGtype = <T>(cache: Map<bigint, T>, gtype: bigint, compute: () => T): T => {
+    const cached = cache.get(gtype);
+    if (cached !== undefined) return cached;
+    const result = compute();
+    cache.set(gtype, result);
+    return result;
+};
+
+const collectTypeNameChain = (gtype: bigint): string[] =>
+    memoizeGtype(typeNameChainCache, gtype, () => {
+        const chain: string[] = [];
+        let current = gtype;
+        while (current !== 0n) {
+            const name = GObject.typeName(current);
+            if (!name) break;
+            chain.push(name);
+            current = GObject.typeParent(current);
+        }
+        return chain;
+    });
+
+const collectInterfaceNames = (gtype: bigint): string[] =>
+    memoizeGtype(interfaceNamesCache, gtype, () => {
+        const names: string[] = [];
+        for (const iface of GObject.typeInterfaces(gtype)) {
+            const name = GObject.typeName(iface);
+            if (name) names.push(name);
+        }
+        return names;
+    });
+
+const typeNamesWithInterfacesCache = new Map<bigint, string[]>();
+
+export const collectTypeNamesWithInterfaces = (gtype: bigint): string[] =>
+    memoizeGtype(typeNamesWithInterfacesCache, gtype, () => [
+        ...collectTypeNameChain(gtype),
+        ...collectInterfaceNames(gtype),
+    ]);
+
+const foldInheritedTable = <R, T>(
+    gtype: bigint,
+    table: Record<string, R>,
+    fold: (accumulator: T, row: R) => T,
+    seed: T,
+): T => {
+    let accumulator = seed;
+    for (const name of collectTypeNameChain(gtype)) {
+        const row = table[name];
+        if (row !== undefined) accumulator = fold(accumulator, row);
+    }
+    return accumulator;
+};
+
+export const foldInheritedTableWithInterfaces = <R, T>(
+    gtype: bigint,
+    table: Record<string, R>,
+    fold: (accumulator: T, row: R) => T,
+    seed: T,
+): T => {
+    let accumulator = foldInheritedTable(gtype, table, fold, seed);
+    for (const name of collectInterfaceNames(gtype)) {
+        const row = table[name];
+        if (row !== undefined) accumulator = fold(accumulator, row);
+    }
+    return accumulator;
+};
+
+export const typeChainIncludes = (gtype: bigint, name: string): boolean =>
+    memoizeGtype(typeNameSetCache, gtype, () => new Set(collectTypeNameChain(gtype))).has(name);
+
+const memoize = <T>(
+    cache: Map<bigint, Map<string, T>>,
+    instance: TypedClass,
+    key: string,
+    compute: (typeNames: string[]) => T,
+): T => {
+    const gtype = instance.__type__;
+    const perGtype = memoizeGtype(cache, gtype, () => new Map<string, T>());
+    const cached = perGtype.get(key);
+    if (cached !== undefined) return cached;
+    const result = compute(collectTypeNameChain(gtype));
+    perGtype.set(key, result);
+    return result;
+};
+
+export const collectConstructableProps = (gtype: bigint): Set<string> =>
+    memoizeGtype(constructablePropsCache, gtype, () =>
+        foldInheritedTable(
+            gtype,
+            CONSTRUCT_PROPS,
+            (collected: Set<string>, props) => {
+                for (const prop of props) collected.add(prop);
+                return collected;
+            },
+            new Set<string>(),
+        ),
+    );
+
+export const isConstructOnlyProp = (instance: TypedClass, key: string): boolean =>
+    memoize(constructOnlyCache, instance, key, (typeNames) => {
+        for (const name of typeNames) {
+            if (CONSTRUCT_ONLY_PROPS[name]?.has(key)) return true;
+        }
+        return false;
+    });
+
+export const resolveSignal = (instance: TypedClass, propName: string): string | null => {
+    const notify = resolveNotifySignal(propName);
+    if (notify) return notify;
+    return memoize(signalCache, instance, propName, (typeNames) => {
+        for (const name of typeNames) {
+            const result = SIGNALS[name]?.[propName];
+            if (result) return result;
+        }
+        return null;
+    });
+};
+
+type DefaultPropLookup = { has: boolean; value: unknown };
+
+const NO_DEFAULT_PROP: DefaultPropLookup = { has: false, value: undefined };
+
+export const resolveDefaultProp = (instance: TypedClass, key: string): DefaultPropLookup =>
+    memoize(defaultPropCache, instance, key, (typeNames) => {
+        for (const name of typeNames) {
+            const table = DEFAULT_PROPS[name];
+            if (table && key in table) return { has: true, value: table[key] };
+        }
+        return NO_DEFAULT_PROP;
+    });
+
+export const requireClassByName = (typeName: string): (new (props: Record<string, unknown>) => GObject.Object) => {
+    const gtype = GObject.typeFromName(typeName);
+    if (gtype === GObject.TYPE_INVALID)
+        throw new Error(
+            `${typeName} is not registered. Import its @gtkx/jsx namespace module (e.g. \`import "@gtkx/jsx/adw"\`) before use.`,
+        );
+    return getWrapperClass(gtype) as new (
+        props: Record<string, unknown>,
+    ) => GObject.Object;
+};

package/src/utils/notify-name.ts

@@ -0,0 +1,10 @@
+import { toCamelCase, toKebabCase } from "@gtkx/utils";
+
+export const NOTIFY_SIGNAL = "notify";
+
+export const NOTIFY_DETAIL_PREFIX = "notify::";
+
+export const propToNotifySignal = (property: string): `notify::${string}` =>
+    `${NOTIFY_DETAIL_PREFIX}${toKebabCase(property)}`;
+
+export const notifyDetailToProp = (detail: string): string => toCamelCase(detail.slice(NOTIFY_DETAIL_PREFIX.length));

package/src/utils/object-prop.ts

@@ -0,0 +1,13 @@
+import * as GObject from "@gtkx/gi/gobject";
+import type { RefObject } from "react";
+
+/**
+ * An object accepted by the GObject-aware hooks: a GObject, a ref to one, or a nullish value.
+ */
+export type ObjectProp<T extends GObject.Object> = T | RefObject<T | null> | null | undefined;
+
+export const resolveObjectProp = <T extends GObject.Object>(prop: ObjectProp<T>): T | null => {
+    if (!prop) return null;
+    if (prop instanceof GObject.Object) return prop;
+    return prop.current;
+};

package/src/utils/settings-accessor.ts

@@ -0,0 +1,89 @@
+import type * as Gio from "@gtkx/gi/gio";
+import * as GLib from "@gtkx/gi/glib";
+
+type SettingAccessor = {
+    read: (settings: Gio.Settings, key: string) => unknown;
+    write: (settings: Gio.Settings, key: string, value: unknown) => void;
+};
+
+const settingTypeError = (expected: string, value: unknown): TypeError =>
+    new TypeError(`Expected ${expected} for the settings value, got ${typeof value}`);
+
+const expect =
+    <T>(guard: (value: unknown) => value is T, label: string) =>
+    (value: unknown): T => {
+        if (!guard(value)) throw settingTypeError(label, value);
+        return value;
+    };
+
+const expectBoolean = expect((value): value is boolean => typeof value === "boolean", "a boolean");
+
+const expectNumber = expect((value): value is number => typeof value === "number", "a number");
+
+const expectString = expect((value): value is string => typeof value === "string", "a string");
+
+const isStringArray = (value: unknown): value is string[] =>
+    Array.isArray(value) && value.every((entry) => typeof entry === "string");
+
+const expectStringArray = expect(isStringArray, "an array of strings");
+
+const expectVariant = expect((value): value is GLib.Variant => value instanceof GLib.Variant, "a GLib.Variant");
+
+const expectBigInt = (value: unknown): bigint => {
+    if (typeof value === "bigint") return value;
+    if (typeof value === "number") return BigInt(value);
+    throw settingTypeError("a bigint", value);
+};
+
+const STRING_ACCESSOR: SettingAccessor = {
+    read: (settings, key) => settings.getString(key),
+    write: (settings, key, value) => settings.setString(key, expectString(value)),
+};
+
+const STRV_ACCESSOR: SettingAccessor = {
+    read: (settings, key) => settings.getStrv(key),
+    write: (settings, key, value) => settings.setStrv(key, expectStringArray(value)),
+};
+
+const ACCESSORS: Record<string, SettingAccessor> = {
+    b: {
+        read: (settings, key) => settings.getBoolean(key),
+        write: (settings, key, value) => settings.setBoolean(key, expectBoolean(value)),
+    },
+    i: {
+        read: (settings, key) => settings.getInt(key),
+        write: (settings, key, value) => settings.setInt(key, expectNumber(value)),
+    },
+    u: {
+        read: (settings, key) => settings.getUint(key),
+        write: (settings, key, value) => settings.setUint(key, expectNumber(value)),
+    },
+    x: {
+        read: (settings, key) => settings.getInt64(key),
+        write: (settings, key, value) => settings.setInt64(key, expectBigInt(value)),
+    },
+    t: {
+        read: (settings, key) => settings.getUint64(key),
+        write: (settings, key, value) => settings.setUint64(key, expectBigInt(value)),
+    },
+    d: {
+        read: (settings, key) => settings.getDouble(key),
+        write: (settings, key, value) => settings.setDouble(key, expectNumber(value)),
+    },
+    s: STRING_ACCESSOR,
+    as: STRV_ACCESSOR,
+    enum: STRING_ACCESSOR,
+    flags: STRV_ACCESSOR,
+};
+
+const VARIANT_ACCESSOR: SettingAccessor = {
+    read: (settings, key) => settings.getValue(key),
+    write: (settings, key, value) => settings.setValue(key, expectVariant(value)),
+};
+
+export const resolveAccessor = (kind: string | undefined, key: string, schemaId: string): SettingAccessor => {
+    if (kind === undefined) {
+        throw new TypeError(`Key "${key}" is not declared by the GSettings schema "${schemaId}"`);
+    }
+    return ACCESSORS[kind] ?? VARIANT_ACCESSOR;
+};

package/src/utils/wrapper-node-jsx.ts

@@ -0,0 +1,34 @@
+import type * as Gdk from "@gtkx/gi/gdk";
+import type { ReactNode } from "react";
+
+/**
+ * Props for a text anchor that embeds child widgets at a position within a text view's buffer.
+ */
+export type TextAnchorProps = {
+    /** The character used to represent the embedded widget in the buffer's text. */
+    replacementChar?: string;
+    children?: ReactNode;
+};
+
+/**
+ * Props for a node that embeds a `Gdk.Paintable` within a text view's buffer.
+ */
+export type TextPaintableProps = {
+    paintable: Gdk.Paintable;
+};
+
+type WrapperNodeElementProps = {
+    kind: string;
+    children?: ReactNode;
+    [key: string]: unknown;
+};
+
+declare global {
+    namespace React {
+        namespace JSX {
+            interface IntrinsicElements {
+                __GTKX_WRAPPER_NODE__: WrapperNodeElementProps;
+            }
+        }
+    }
+}

package/dist/components/list.d.ts

@@ -1,35 +0,0 @@
-import type * as Adw from "@gtkx/ffi/adw";
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { type ReactNode, type Ref } from "react";
-import type { AdwComboRowProps, GtkColumnViewProps, GtkDropDownProps, GtkGridViewProps, GtkListViewProps } from "../generated/jsx.js";
-import type { DropDownProps, GridViewProps, ListItem, ListViewProps } from "../jsx.js";
-type GenericListViewProps<T, S> = Omit<GtkListViewProps, keyof ListViewProps> & ListViewProps<T, S>;
-type GenericGridViewProps<T> = Omit<GtkGridViewProps, keyof GridViewProps> & GridViewProps<T>;
-type GenericDropDownProps<T, S> = Omit<GtkDropDownProps, keyof DropDownProps> & DropDownProps<T, S>;
-type GenericComboRowProps<T, S> = Omit<AdwComboRowProps, keyof DropDownProps> & DropDownProps<T, S>;
-type GenericColumnViewProps<T, S> = Omit<GtkColumnViewProps, "items" | "renderHeader"> & {
-    items?: ListItem<T, S>[];
-    renderHeader?: ((item: S) => ReactNode) | null;
-};
-export declare function GtkListView<T = unknown, S = unknown>(props: GenericListViewProps<T, S> & {
-    children?: ReactNode;
-    ref?: Ref<Gtk.ListView>;
-}): ReactNode;
-export declare function GtkGridView<T = unknown>(props: GenericGridViewProps<T> & {
-    children?: ReactNode;
-    ref?: Ref<Gtk.GridView>;
-}): ReactNode;
-export declare function GtkColumnView<T = unknown, S = unknown>(props: GenericColumnViewProps<T, S> & {
-    children?: ReactNode;
-    ref?: Ref<Gtk.ColumnView>;
-}): ReactNode;
-export declare function GtkDropDown<T = unknown, S = unknown>(props: GenericDropDownProps<T, S> & {
-    children?: ReactNode;
-    ref?: Ref<Gtk.DropDown>;
-}): ReactNode;
-export declare function AdwComboRow<T = unknown, S = unknown>(props: GenericComboRowProps<T, S> & {
-    children?: ReactNode;
-    ref?: Ref<Adw.ComboRow>;
-}): ReactNode;
-export {};
-//# sourceMappingURL=list.d.ts.map

package/dist/components/list.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/components/list.tsx"],"names":[],"mappings":"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"}

package/dist/components/list.js

@@ -1,40 +0,0 @@
-import { createElement, Fragment, useReducer, useRef } from "react";
-import { createPortal } from "../portal.js";
-function useListHandle() {
-    const [, rerender] = useReducer((x) => x + 1, 0);
-    const boundItemsRef = useRef([]);
-    const headerBoundItemsRef = useRef([]);
-    return { rerender, boundItemsRef, headerBoundItemsRef };
-}
-function renderListElement(intrinsicName, handle, props) {
-    const { rerender, boundItemsRef, headerBoundItemsRef } = handle;
-    const portals = [];
-    for (const [content, container, key] of boundItemsRef.current) {
-        portals.push(createPortal(content, container, key));
-    }
-    for (const [content, container, key] of headerBoundItemsRef.current) {
-        portals.push(createPortal(content, container, key));
-    }
-    return createElement(Fragment, null, createElement(intrinsicName, {
-        ...props,
-        __boundItemsRef: boundItemsRef,
-        __rerender: rerender,
-        __headerBoundItemsRef: headerBoundItemsRef,
-    }), ...portals);
-}
-export function GtkListView(props) {
-    return renderListElement("GtkListView", useListHandle(), props);
-}
-export function GtkGridView(props) {
-    return renderListElement("GtkGridView", useListHandle(), props);
-}
-export function GtkColumnView(props) {
-    return renderListElement("GtkColumnView", useListHandle(), props);
-}
-export function GtkDropDown(props) {
-    return renderListElement("GtkDropDown", useListHandle(), props);
-}
-export function AdwComboRow(props) {
-    return renderListElement("AdwComboRow", useListHandle(), props);
-}
-//# sourceMappingURL=list.js.map

package/dist/components/list.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"list.js","sourceRoot":"","sources":["../../src/components/list.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAA4B,UAAU,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAU9F,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAW5C,SAAS,aAAa;IAClB,MAAM,CAAC,EAAE,QAAQ,CAAC,GAAG,UAAU,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACzD,MAAM,aAAa,GAAG,MAAM,CAAc,EAAE,CAAC,CAAC;IAC9C,MAAM,mBAAmB,GAAG,MAAM,CAAc,EAAE,CAAC,CAAC;IACpD,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,mBAAmB,EAAE,CAAC;AAC5D,CAAC;AAED,SAAS,iBAAiB,CAAC,aAAqB,EAAE,MAAwC,EAAE,KAAa;IACrG,MAAM,EAAE,QAAQ,EAAE,aAAa,EAAE,mBAAmB,EAAE,GAAG,MAAM,CAAC;IAEhE,MAAM,OAAO,GAAgB,EAAE,CAAC;IAChC,KAAK,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,CAAC,IAAI,aAAa,CAAC,OAAO,EAAE,CAAC;QAC5D,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC;IACxD,CAAC;IACD,KAAK,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,CAAC,IAAI,mBAAmB,CAAC,OAAO,EAAE,CAAC;QAClE,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC;IACxD,CAAC;IAED,OAAO,aAAa,CAChB,QAAQ,EACR,IAAI,EACJ,aAAa,CAAC,aAAa,EAAE;QACzB,GAAI,KAAiC;QACrC,eAAe,EAAE,aAAa;QAC9B,UAAU,EAAE,QAAQ;QACpB,qBAAqB,EAAE,mBAAmB;KAC7C,CAAC,EACF,GAAG,OAAO,CACb,CAAC;AACN,CAAC;AAED,MAAM,UAAU,WAAW,CACvB,KAAqF;IAErF,OAAO,iBAAiB,CAAC,aAAa,EAAE,aAAa,EAAE,EAAE,KAAK,CAAC,CAAC;AACpE,CAAC;AAED,MAAM,UAAU,WAAW,CACvB,KAAkF;IAElF,OAAO,iBAAiB,CAAC,aAAa,EAAE,aAAa,EAAE,EAAE,KAAK,CAAC,CAAC;AACpE,CAAC;AAED,MAAM,UAAU,aAAa,CACzB,KAAyF;IAEzF,OAAO,iBAAiB,CAAC,eAAe,EAAE,aAAa,EAAE,EAAE,KAAK,CAAC,CAAC;AACtE,CAAC;AAED,MAAM,UAAU,WAAW,CACvB,KAAqF;IAErF,OAAO,iBAAiB,CAAC,aAAa,EAAE,aAAa,EAAE,EAAE,KAAK,CAAC,CAAC;AACpE,CAAC;AAED,MAAM,UAAU,WAAW,CACvB,KAAqF;IAErF,OAAO,iBAAiB,CAAC,aAAa,EAAE,aAAa,EAAE,EAAE,KAAK,CAAC,CAAC;AACpE,CAAC"}

package/dist/errors.d.ts

@@ -1,9 +0,0 @@
-export declare class GtkxError extends Error {
-    widgetType?: string | undefined;
-    componentStack?: string | undefined;
-    constructor(message: string, widgetType?: string | undefined, componentStack?: string | undefined);
-    toString(): string;
-}
-export declare function formatRenderError(error: unknown, widgetType?: string): GtkxError;
-export declare function formatBoundaryError(error: unknown): GtkxError;
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAU,SAAQ,KAAK;IAGrB,UAAU,CAAC,EAAE,MAAM;IACnB,cAAc,CAAC,EAAE,MAAM;gBAF9B,OAAO,EAAE,MAAM,EACR,UAAU,CAAC,EAAE,MAAM,YAAA,EACnB,cAAc,CAAC,EAAE,MAAM,YAAA;IAUzB,QAAQ,IAAI,MAAM;CAa9B;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAahF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAO7D"}

package/dist/errors.js

@@ -1,42 +0,0 @@
-export class GtkxError extends Error {
-    widgetType;
-    componentStack;
-    constructor(message, widgetType, componentStack) {
-        super(message);
-        this.widgetType = widgetType;
-        this.componentStack = componentStack;
-        this.name = "GtkxError";
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, GtkxError);
-        }
-    }
-    toString() {
-        const parts = [`GtkxError: ${this.message}`];
-        if (this.widgetType) {
-            parts.push(`Widget Type: ${this.widgetType}`);
-        }
-        if (this.componentStack) {
-            parts.push(`Component Stack:\n${this.componentStack}`);
-        }
-        return parts.join("\n");
-    }
-}
-export function formatRenderError(error, widgetType) {
-    if (error instanceof GtkxError) {
-        return error;
-    }
-    if (error instanceof Error) {
-        console.error("[formatRenderError] Original error stack:", error.stack);
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    const formattedMessage = widgetType ? `Failed to render ${widgetType}: ${message}` : `Render error: ${message}`;
-    return new GtkxError(formattedMessage, widgetType);
-}
-export function formatBoundaryError(error) {
-    if (error instanceof GtkxError) {
-        return error;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return new GtkxError(`Error caught by boundary: ${message}`);
-}
-//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,SAAU,SAAQ,KAAK;IAGrB;IACA;IAHX,YACI,OAAe,EACR,UAAmB,EACnB,cAAuB;QAE9B,KAAK,CAAC,OAAO,CAAC,CAAC;QAHR,eAAU,GAAV,UAAU,CAAS;QACnB,mBAAc,GAAd,cAAc,CAAS;QAG9B,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC;QAExB,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAC1B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC7C,CAAC;IACL,CAAC;IAEQ,QAAQ;QACb,MAAM,KAAK,GAAG,CAAC,cAAc,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAE7C,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,KAAK,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAClD,CAAC;QAED,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,KAAK,CAAC,IAAI,CAAC,qBAAqB,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QAC3D,CAAC;QAED,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;CACJ;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAc,EAAE,UAAmB;IACjE,IAAI,KAAK,YAAY,SAAS,EAAE,CAAC;QAC7B,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QACzB,OAAO,CAAC,KAAK,CAAC,2CAA2C,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAC5E,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,MAAM,gBAAgB,GAAG,UAAU,CAAC,CAAC,CAAC,oBAAoB,UAAU,KAAK,OAAO,EAAE,CAAC,CAAC,CAAC,iBAAiB,OAAO,EAAE,CAAC;IAEhH,OAAO,IAAI,SAAS,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,KAAc;IAC9C,IAAI,KAAK,YAAY,SAAS,EAAE,CAAC;QAC7B,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,OAAO,IAAI,SAAS,CAAC,6BAA6B,OAAO,EAAE,CAAC,CAAC;AACjE,CAAC"}

package/dist/factory.d.ts

@@ -1,5 +0,0 @@
-import type { Node } from "./node.js";
-import type { Container, ContainerClass, Props } from "./types.js";
-export declare const resolveContainerClass: (type: string) => ContainerClass | null;
-export declare const createNode: (typeName: string, props: Props, existingContainer: Container | undefined, rootContainer: Container) => Node;
-//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnE,eAAO,MAAM,qBAAqB,GAAI,MAAM,MAAM,KAAG,cAAc,GAAG,IAQrE,CAAC;AAqBF,eAAO,MAAM,UAAU,GACnB,UAAU,MAAM,EAChB,OAAO,KAAK,EACZ,mBAAmB,SAAS,GAAG,SAAS,EACxC,eAAe,SAAS,KACzB,IASF,CAAC"}