@gtkx/react 0.21.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/compound.d.ts

@@ -1,40 +0,0 @@
-import { type ReactNode } from "react";
-type ContainerSlotChild = (props: {
-    children?: ReactNode;
-}) => ReactNode;
-/**
- * Creates a compound child component that delegates to a ContainerSlot
- * with a specific method name.
- *
- * @param methodName - The container slot method name (e.g., "packStart", "addPrefix")
- */
-export declare function createContainerSlotChild(methodName: string): ContainerSlotChild;
-/**
- * Creates a compound child component that delegates to an existing
- * virtual node intrinsic element.
- *
- * @param intrinsicName - The intrinsic element name (e.g., "StackPage", "GridChild")
- */
-export declare function createVirtualChild<P extends Record<string, unknown>>(intrinsicName: string): (props: P & {
-    children?: ReactNode;
-}) => ReactNode;
-/**
- * Creates a compound child component for NavigationPage that automatically
- * sets the `for` discriminant based on the parent widget type.
- *
- * @param forValue - The `for` discriminant value (e.g., "AdwNavigationView")
- */
-export declare function createNavigationPageChild<P extends Record<string, unknown>>(forValue: string): (props: P & {
-    children?: ReactNode;
-}) => ReactNode;
-/**
- * Creates a compound child component for menu items that delegates to
- * an existing menu intrinsic element.
- *
- * @param intrinsicName - "MenuItem", "MenuSection", or "MenuSubmenu"
- */
-export declare function createMenuChild<P extends Record<string, unknown>>(intrinsicName: string): (props: P & {
-    children?: ReactNode;
-}) => ReactNode;
-export {};
-//# sourceMappingURL=compound.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"compound.d.ts","sourceRoot":"","sources":["../../src/components/compound.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEtD,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,KAAK,SAAS,CAAC;AAEzE;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,CAI/E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,aAAa,EAAE,MAAM,GACtB,CAAC,KAAK,EAAE,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,KAAK,SAAS,CAIpD;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvE,QAAQ,EAAE,MAAM,GACjB,CAAC,KAAK,EAAE,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,KAAK,SAAS,CAIpD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7D,aAAa,EAAE,MAAM,GACtB,CAAC,KAAK,EAAE,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,KAAK,SAAS,CAIpD"}

package/dist/components/compound.js

@@ -1,46 +0,0 @@
-import { createElement } from "react";
-/**
- * Creates a compound child component that delegates to a ContainerSlot
- * with a specific method name.
- *
- * @param methodName - The container slot method name (e.g., "packStart", "addPrefix")
- */
-export function createContainerSlotChild(methodName) {
-    return (props) => {
-        return createElement("ContainerSlot", { id: methodName }, props.children);
-    };
-}
-/**
- * Creates a compound child component that delegates to an existing
- * virtual node intrinsic element.
- *
- * @param intrinsicName - The intrinsic element name (e.g., "StackPage", "GridChild")
- */
-export function createVirtualChild(intrinsicName) {
-    return (props) => {
-        return createElement(intrinsicName, props, props.children);
-    };
-}
-/**
- * Creates a compound child component for NavigationPage that automatically
- * sets the `for` discriminant based on the parent widget type.
- *
- * @param forValue - The `for` discriminant value (e.g., "AdwNavigationView")
- */
-export function createNavigationPageChild(forValue) {
-    return (props) => {
-        return createElement("NavigationPage", { ...props, for: forValue }, props.children);
-    };
-}
-/**
- * Creates a compound child component for menu items that delegates to
- * an existing menu intrinsic element.
- *
- * @param intrinsicName - "MenuItem", "MenuSection", or "MenuSubmenu"
- */
-export function createMenuChild(intrinsicName) {
-    return (props) => {
-        return createElement(intrinsicName, props, props.children);
-    };
-}
-//# sourceMappingURL=compound.js.map

package/dist/components/compound.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"compound.js","sourceRoot":"","sources":["../../src/components/compound.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAkB,MAAM,OAAO,CAAC;AAItD;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAC,UAAkB;IACvD,OAAO,CAAC,KAA+B,EAAa,EAAE;QAClD,OAAO,aAAa,CAAC,eAAe,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC9E,CAAC,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAC9B,aAAqB;IAErB,OAAO,CAAC,KAAmC,EAAa,EAAE;QACtD,OAAO,aAAa,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC/D,CAAC,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CACrC,QAAgB;IAEhB,OAAO,CAAC,KAAmC,EAAa,EAAE;QACtD,OAAO,aAAa,CAAC,gBAAgB,EAAE,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IACxF,CAAC,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAC3B,aAAqB;IAErB,OAAO,CAAC,KAAmC,EAAa,EAAE;QACtD,OAAO,aAAa,CAAC,aAAa,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC/D,CAAC,CAAC;AACN,CAAC"}

package/dist/components/list.d.ts

@@ -1,75 +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 { ColumnViewColumnProps, DropDownProps, GridViewProps, ListItem, ListViewProps, MenuItemProps, MenuSectionProps, MenuSubmenuProps } 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;
-};
-/**
- * Virtualized scrollable list that renders items from a flat or tree data model.
- *
- * Wraps `GtkListView` with React-managed item rendering via portals,
- * supporting single/multi selection, section headers, and tree expansion.
- */
-export declare function GtkListView<T = unknown, S = unknown>(props: GenericListViewProps<T, S> & {
-    children?: ReactNode;
-    ref?: Ref<Gtk.ListView>;
-}): ReactNode;
-/**
- * Virtualized scrollable grid that renders items in a multi-column layout.
- *
- * Wraps `GtkGridView` with React-managed item rendering via portals,
- * supporting single/multi selection.
- */
-export declare function GtkGridView<T = unknown>(props: GenericGridViewProps<T> & {
-    children?: ReactNode;
-    ref?: Ref<Gtk.GridView>;
-}): ReactNode;
-/** @internal */
-declare function GtkColumnViewBase<T = unknown, S = unknown>(props: GenericColumnViewProps<T, S> & {
-    children?: ReactNode;
-    ref?: Ref<Gtk.ColumnView>;
-}): ReactNode;
-/**
- * Multi-column sortable list with React-managed cell rendering.
- *
- * Wraps `GtkColumnView` with portal-based factories. Use the
- * `GtkColumnView.Column` compound component to define columns,
- * and the `MenuItem` / `MenuSection` / `MenuSubmenu` compounds
- * for the column header context menu.
- */
-export declare const GtkColumnView: typeof GtkColumnViewBase & {
-    Column: <T = unknown>(props: ColumnViewColumnProps<T>) => ReactNode;
-    MenuItem: (props: MenuItemProps) => ReactNode;
-    MenuSection: (props: MenuSectionProps) => ReactNode;
-    MenuSubmenu: (props: MenuSubmenuProps) => ReactNode;
-};
-/**
- * Single-selection dropdown widget with React-managed item rendering.
- *
- * Wraps `GtkDropDown` with portal-based factories, supporting custom
- * item templates, separate list-item templates, and section headers.
- */
-export declare function GtkDropDown<T = unknown, S = unknown>(props: GenericDropDownProps<T, S> & {
-    children?: ReactNode;
-    ref?: Ref<Gtk.DropDown>;
-}): ReactNode;
-/**
- * Libadwaita combo row with React-managed item rendering.
- *
- * Wraps `AdwComboRow` with portal-based factories, providing a
- * preferences-style dropdown row with custom item templates and
- * section headers.
- */
-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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"}