@gtkx/react 0.21.0 → 1.0.0-rc.2

package/src/utils/variant.ts

@@ -0,0 +1,368 @@
+import * as GLib from "@gtkx/gi/glib";
+
+type BasicValueMap = {
+    b: boolean;
+    y: number;
+    n: number;
+    q: number;
+    i: number;
+    u: number;
+    h: number;
+    d: number;
+    x: bigint;
+    t: bigint;
+    s: string;
+    o: string;
+    g: string;
+    v: GLib.Variant;
+};
+
+type BasicCode = keyof BasicValueMap;
+type ParseArray<S extends string> = Parse<S> extends [infer V, infer R extends string] ? [V[], R] : never;
+type ParseMaybe<S extends string> = Parse<S> extends [infer V, infer R extends string] ? [V | null, R] : never;
+
+type ParseTuple<S extends string, Acc extends unknown[]> = S extends `)${infer Rest}`
+    ? [Acc, Rest]
+    : [Parse<S>] extends [never]
+            ? never
+            : Parse<S> extends [infer V, infer R extends string]
+                ? ParseTuple<R, [...Acc, V]>
+                : never;
+
+type DictKey = string | number | bigint | boolean;
+
+type ParsePair<S extends string> =
+    Parse<S> extends [infer K, infer R1 extends string]
+        ? Parse<R1> extends [infer V, infer R2 extends string]
+            ? R2 extends `}${infer R3}`
+                ? [K] extends [DictKey]
+                        ? [K, V, R3]
+                        : never
+                : never
+            : never
+        : never;
+
+type ParseDict<S extends string> =
+    ParsePair<S> extends [infer K, infer V, infer R extends string]
+        ? [[K] extends [string] ? Record<string, V> : Map<K, V>, R]
+        : never;
+
+type ParseEntry<S extends string> =
+    ParsePair<S> extends [infer K, infer V, infer R extends string] ? [[K, V], R] : never;
+
+type ParseArrayOrDict<S extends string> = S extends `{${infer Rest}` ? ParseDict<Rest> : ParseArray<S>;
+
+type Parse<S extends string> = S extends `a${infer Rest}`
+    ? ParseArrayOrDict<Rest>
+    : S extends `m${infer Rest}`
+        ? ParseMaybe<Rest>
+        : S extends `(${infer Rest}`
+            ? ParseTuple<Rest, []>
+            : S extends `{${infer Rest}`
+                ? ParseEntry<Rest>
+                : S extends `${infer C}${infer Rest}`
+                    ? C extends BasicCode
+                        ? [BasicValueMap[C], Rest]
+                        : never
+                    : never;
+
+type VariantValue<S extends string> = [Parse<S>] extends [never]
+    ? unknown
+    : Parse<S> extends [infer V, ""]
+        ? V
+        : unknown;
+
+type VariantTypeNode =
+    | { kind: "basic"; code: BasicCode } |
+    { kind: "array"; elementTypeString: string; element: VariantTypeNode } |
+    { kind: "dict"; entryTypeString: string; key: VariantTypeNode; value: VariantTypeNode } |
+    { kind: "entry"; key: VariantTypeNode; value: VariantTypeNode } |
+    { kind: "tuple"; items: VariantTypeNode[] } |
+    { kind: "maybe"; elementTypeString: string; element: VariantTypeNode };
+
+const BASIC_CODES = "bynqiuxthdsogv";
+const STRING_KEY_CODES: Set<string> = new Set(["s", "o", "g"]);
+
+const CONTAINER_PARSERS: Record<string, (source: string, start: number) => [VariantTypeNode, number]> = {
+    a: parseArrayNode,
+    m: parseMaybeNode,
+    "(": parseTupleNode,
+    "{": parseEntryNode,
+};
+
+const parsedTypes: Map<string, VariantTypeNode> = new Map();
+
+const unpackBasic: Record<BasicCode, (variant: GLib.Variant) => unknown> = {
+    b: (variant) => variant.getBoolean(),
+    y: (variant) => variant.getByte(),
+    n: (variant) => variant.getInt16(),
+    q: (variant) => variant.getUint16(),
+    i: (variant) => variant.getInt32(),
+    u: (variant) => variant.getUint32(),
+    h: (variant) => variant.getHandle(),
+    d: (variant) => variant.getDouble(),
+    x: (variant) => variant.getInt64(),
+    t: (variant) => variant.getUint64(),
+    s: (variant) => variant.getString()[0],
+    o: (variant) => variant.getString()[0],
+    g: (variant) => variant.getString()[0],
+    v: (variant) => variant.getVariant(),
+};
+
+const packBasic: Record<BasicCode, (value: unknown) => GLib.Variant> = {
+    b: (value) => GLib.Variant.newBoolean(value as boolean),
+    y: (value) => GLib.Variant.newByte(value as number),
+    n: (value) => GLib.Variant.newInt16(value as number),
+    q: (value) => GLib.Variant.newUint16(value as number),
+    i: (value) => GLib.Variant.newInt32(value as number),
+    u: (value) => GLib.Variant.newUint32(value as number),
+    h: (value) => GLib.Variant.newHandle(value as number),
+    d: (value) => GLib.Variant.newDouble(value as number),
+    x: (value) => GLib.Variant.newInt64(value as bigint),
+    t: (value) => GLib.Variant.newUint64(value as bigint),
+    s: (value) => GLib.Variant.newString(value as string),
+    o: packObjectPath,
+    g: packSignature,
+    v: (value) => GLib.Variant.newVariant(value as GLib.Variant),
+};
+
+const isBasicCode = (code: string): code is BasicCode => BASIC_CODES.includes(code);
+const isStringKeyed = (key: VariantTypeNode): boolean => key.kind === "basic" && STRING_KEY_CODES.has(key.code);
+const invalidType = (source: string): Error => new Error(`Invalid GVariant type string "${source}"`);
+
+const parsePair = (source: string, start: number): [VariantTypeNode, VariantTypeNode, number] => {
+    const [key, keyEnd] = parseNode(source, start);
+
+    if (key.kind !== "basic" || key.code === "v") {
+        throw invalidType(source);
+    }
+
+    const [value, valueEnd] = parseNode(source, keyEnd);
+
+    if (source[valueEnd] !== "}") {
+        throw invalidType(source);
+    }
+
+    return [key, value, valueEnd + 1];
+};
+
+function parseArrayNode(source: string, start: number): [VariantTypeNode, number] {
+    if (source[start] === "{") {
+        const [key, value, end] = parsePair(source, start + 1);
+
+        return [{ kind: "dict", entryTypeString: source.slice(start, end), key, value }, end];
+    }
+
+    const [element, end] = parseNode(source, start);
+
+    return [{ kind: "array", elementTypeString: source.slice(start, end), element }, end];
+}
+
+function parseMaybeNode(source: string, start: number): [VariantTypeNode, number] {
+    const [element, end] = parseNode(source, start);
+
+    return [{ kind: "maybe", elementTypeString: source.slice(start, end), element }, end];
+}
+
+function parseTupleNode(source: string, start: number): [VariantTypeNode, number] {
+    const items: VariantTypeNode[] = [];
+    let position = start;
+
+    while (source[position] !== ")") {
+        if (position >= source.length) {
+            throw invalidType(source);
+        }
+
+        const [item, end] = parseNode(source, position);
+        items.push(item);
+        position = end;
+    }
+
+    return [{ kind: "tuple", items }, position + 1];
+}
+
+function parseEntryNode(source: string, start: number): [VariantTypeNode, number] {
+    const [key, value, end] = parsePair(source, start);
+
+    return [{ kind: "entry", key, value }, end];
+}
+
+const parseNode = (source: string, start: number): [VariantTypeNode, number] => {
+    const code = source[start];
+
+    if (code === undefined) {
+        throw invalidType(source);
+    }
+
+    const container = CONTAINER_PARSERS[code];
+
+    if (container !== undefined) {
+        return container(source, start + 1);
+    }
+
+    if (isBasicCode(code)) {
+        return [{ kind: "basic", code }, start + 1];
+    }
+
+    throw invalidType(source);
+};
+
+const parseVariantType = (typeString: string): VariantTypeNode => {
+    const cached = parsedTypes.get(typeString);
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const [node, end] = parseNode(typeString, 0);
+
+    if (end !== typeString.length) {
+        throw invalidType(typeString);
+    }
+
+    parsedTypes.set(typeString, node);
+
+    return node;
+};
+
+const unpackChildren = (variant: GLib.Variant, unpackChild: (child: GLib.Variant) => unknown): unknown[] => {
+    const children: unknown[] = [];
+    const count = variant.nChildren();
+
+    for (let index = 0; index < count; index += 1) {
+        children.push(unpackChild(variant.getChildValue(index)));
+    }
+
+    return children;
+};
+
+const unpackPair = (key: VariantTypeNode, value: VariantTypeNode, entry: GLib.Variant): [unknown, unknown] => [
+    unpackVariant(key, entry.getChildValue(0)),
+    unpackVariant(value, entry.getChildValue(1)),
+];
+
+const unpackDict = (
+    node: { key: VariantTypeNode; value: VariantTypeNode },
+    variant: GLib.Variant,
+): Record<string, unknown> | Map<unknown, unknown> => {
+    const entries = unpackChildren(variant, (entry) => unpackPair(node.key, node.value, entry)) as [unknown, unknown][];
+
+    if (!isStringKeyed(node.key)) {
+        return new Map(entries);
+    }
+
+    const stringEntries: [string, unknown][] = entries.map(([key, value]) => [key as string, value]);
+
+    return Object.fromEntries(stringEntries);
+};
+
+const unpackMaybe = (element: VariantTypeNode, variant: GLib.Variant): unknown => {
+    const child = variant.getMaybe();
+
+    return child === null ? null : unpackVariant(element, child);
+};
+
+const unpackVariant = (node: VariantTypeNode, variant: GLib.Variant): unknown => {
+    switch (node.kind) {
+        case "basic": {
+            return unpackBasic[node.code](variant);
+        }
+        case "array": {
+            return unpackChildren(variant, (child) => unpackVariant(node.element, child));
+        }
+        case "dict": {
+            return unpackDict(node, variant);
+        }
+        case "entry": {
+            return unpackPair(node.key, node.value, variant);
+        }
+        case "tuple": {
+            return node.items.map((item, index) => unpackVariant(item, variant.getChildValue(index)));
+        }
+        case "maybe": {
+            return unpackMaybe(node.element, variant);
+        }
+    }
+};
+
+const packValidatedString = (
+    value: unknown,
+    isValid: (value: string) => boolean,
+    description: string,
+    construct: (value: string) => GLib.Variant,
+): GLib.Variant => {
+    if (typeof value !== "string" || !isValid(value)) {
+        throw new Error(`"${String(value)}" is not a valid GVariant ${description}`);
+    }
+
+    return construct(value);
+};
+
+function packObjectPath(value: unknown): GLib.Variant {
+    return packValidatedString(
+        value,
+        (path) => GLib.Variant.isObjectPath(path),
+        "object path",
+        (path) => GLib.Variant.newObjectPath(path),
+    );
+}
+
+function packSignature(value: unknown): GLib.Variant {
+    return packValidatedString(
+        value,
+        (signature) => GLib.Variant.isSignature(signature),
+        "type signature",
+        (signature) => GLib.Variant.newSignature(signature),
+    );
+}
+
+const packEntry = (key: VariantTypeNode, value: VariantTypeNode, pair: [unknown, unknown]): GLib.Variant =>
+    GLib.Variant.newDictEntry(packVariant(key, pair[0]), packVariant(value, pair[1]));
+
+const dictEntries = (value: unknown): [unknown, unknown][] =>
+    value instanceof Map ? [...value] : Object.entries(value as Record<string, unknown>);
+
+const packDict = (
+    node: { entryTypeString: string; key: VariantTypeNode; value: VariantTypeNode },
+    value: unknown,
+): GLib.Variant =>
+    GLib.Variant.newArray(
+        GLib.VariantType.new(node.entryTypeString),
+        dictEntries(value).map((pair) => packEntry(node.key, node.value, pair)),
+    );
+
+const packMaybe = (node: { elementTypeString: string; element: VariantTypeNode }, value: unknown): GLib.Variant =>
+    GLib.Variant.newMaybe(
+        GLib.VariantType.new(node.elementTypeString),
+        value === null ? null : packVariant(node.element, value),
+    );
+
+const packVariant = (node: VariantTypeNode, value: unknown): GLib.Variant => {
+    switch (node.kind) {
+        case "basic": {
+            return packBasic[node.code](value);
+        }
+        case "array": {
+            return GLib.Variant.newArray(
+                GLib.VariantType.new(node.elementTypeString),
+                (value as unknown[]).map((item) => packVariant(node.element, item)),
+            );
+        }
+        case "dict": {
+            return packDict(node, value);
+        }
+        case "entry": {
+            return packEntry(node.key, node.value, value as [unknown, unknown]);
+        }
+        case "tuple": {
+            return GLib.Variant.newTuple(
+                node.items.map((item, index) => packVariant(item, (value as unknown[])[index])),
+            );
+        }
+        case "maybe": {
+            return packMaybe(node, value);
+        }
+    }
+};
+
+export { parseVariantType, unpackVariant, packVariant, type VariantValue, type VariantTypeNode };

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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"}

package/dist/components/list.js

@@ -1,81 +0,0 @@
-import { createElement, Fragment, useReducer, useRef } from "react";
-import { createPortal } from "../portal.js";
-import { createMenuChild } from "./compound.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);
-}
-/**
- * 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 function GtkListView(props) {
-    return renderListElement("GtkListView", useListHandle(), props);
-}
-/**
- * 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 function GtkGridView(props) {
-    return renderListElement("GtkGridView", useListHandle(), props);
-}
-/** @internal */
-function GtkColumnViewBase(props) {
-    return renderListElement("GtkColumnView", useListHandle(), props);
-}
-/**
- * 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 const GtkColumnView = Object.assign(GtkColumnViewBase, {
-    Column: (props) => createElement("ColumnViewColumn", props, props.children),
-    MenuItem: createMenuChild("MenuItem"),
-    MenuSection: createMenuChild("MenuSection"),
-    MenuSubmenu: createMenuChild("MenuSubmenu"),
-});
-/**
- * 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 function GtkDropDown(props) {
-    return renderListElement("GtkDropDown", useListHandle(), props);
-}
-/**
- * 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 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":"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"}

package/dist/components/slot-widget.d.ts

@@ -1,15 +0,0 @@
-import { type ReactNode } from "react";
-/**
- * Creates a function component for a widget that has named property slots.
- *
- * The returned component extracts slot props (ReactNode values), forwards
- * remaining props to the underlying intrinsic element, and appends internal
- * Slot children for each non-null slot prop.
- *
- * @param intrinsicName - The intrinsic element name (e.g., "GtkWindow")
- * @param slotNames - Array of camelCase slot prop names (e.g., ["titlebar", "startChild"])
- */
-export declare function createSlotWidget<P = any>(intrinsicName: string, slotNames: readonly string[]): (props: P & {
-    children?: ReactNode;
-}) => ReactNode;
-//# sourceMappingURL=slot-widget.d.ts.map

package/dist/components/slot-widget.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slot-widget.d.ts","sourceRoot":"","sources":["../../src/components/slot-widget.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAItD;;;;;;;;;GASG;AAEH,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EACpC,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,SAAS,MAAM,EAAE,GAC7B,CAAC,KAAK,EAAE,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,KAAK,SAAS,CA2BpD"}