@gjsify/gtk-host 0.44.0 → 0.46.0

package/lib/types/adapters/solid.d.ts

@@ -1,5 +1,6 @@
 import type Gtk from '@girs/gtk-4.0';
 import { widgetOf } from '../host.js';
+import type { ListRowKey, ListRowSink } from '../list/index.js';
 import type { HostNode } from '../types.js';
 export declare const render: (code: () => HostNode, node: HostNode) => () => void, effect: <T>(fn: (prev?: T) => T, init?: T) => void, memo: <T>(fn: () => T, equal: boolean) => () => T, createComponent: <T>(Comp: (props: T) => HostNode, props: T) => HostNode, createElement: (tag: string) => HostNode, createTextNode: (value: string) => HostNode, insertNode: (parent: HostNode, node: HostNode, anchor?: HostNode) => void, insert: <T>(parent: any, accessor: T | (() => T), marker?: any | null, initial?: any) => HostNode, spread: <T>(node: any, accessor: (() => T) | T, skipChildren?: boolean) => void, setProp: <T>(node: HostNode, name: string, value: T, prev?: T) => T, mergeProps: (...sources: unknown[]) => unknown, use: <A, T>(fn: (element: HostNode, arg: A) => T, element: HostNode, arg: A) => T;
 /**
@@ -14,6 +15,40 @@ export declare const render: (code: () => HostNode, node: HostNode) => () => voi
  * disconnects the signal handlers.
  */
 export declare function mount(code: () => HostNode, container: Gtk.Widget): () => void;
+/**
+ * What `listRows` keeps for one ROW WIDGET: a way to show a row in it, and a way to
+ * let go. Opaque to the controller, which stores it and hands it back.
+ */
+export interface ListRowHandle<Row extends ListRowKey> {
+    show(row: Row | null, index: number): void;
+    dispose(): void;
+}
+/**
+ * Solid's half of a `Gtk.ListView`, for `ListController` in `@gjsify/gtk-host/list`.
+ *
+ * The controller owns the model, the factory and the key diff — none of which has a
+ * framework in it. This supplies the three callbacks it cannot have: what to put in a
+ * row widget, what to show there, and how to let go.
+ *
+ * ONE REACTIVE ROOT PER ROW WIDGET, created in `mountRow` and never again, for two
+ * reasons that are not the same kind of thing. The carrier is taken ONCE because taking
+ * it per bind is REFUSED: `adopt` snapshots what a container already held and cannot
+ * tell our own previous child from application chrome, and the same carrier comes back
+ * on the next show, so the second one reads our own row as someone else's and raises
+ * `occupied-slot` (measured against this seam; `host.spec.ts` pins the same refusal
+ * from the host's side). The row's signals live INSIDE the root rather than beside it
+ * for a documented reason rather than a measured one — Solid never disposes a
+ * computation created with no owner, which for a per-row memo would be one leak per
+ * row.
+ *
+ * What the row sees is an ACCESSOR, not a value, and that is the capability this seam
+ * buys over re-rendering: when `setRows` finds unchanged keys over changed content, the
+ * controller shows every live row again, this writes one signal, and Solid updates the
+ * properties that actually changed — the widgets stay. Only the transition between
+ * "holds a row" and "holds nothing" rebuilds the subtree, which is what `present`
+ * isolates.
+ */
+export declare function listRows<Row extends ListRowKey>(renderRow: (row: () => Row, index: () => number) => HostNode): ListRowSink<Row, ListRowHandle<Row>>;
 /** `<For each={items}>` — keyed by item identity, so a reorder MOVES nodes. */
 export declare const For: <T>(props: {
     each: readonly T[] | undefined | null | false;

package/lib/types/conformance/diagnostics.d.ts

@@ -31,7 +31,7 @@ export declare function isEnvironmentDiagnostic(message: string): boolean;
  * arrive without one. The first version answered `String(raw ?? '')`, so such a
  * record was counted and then described as nothing: a CI run failed with
  * `GTK reported 1 diagnostic(s) that would have passed at exit 0:` followed by a
- * BLANK LIST, over a test that had just constructed 164 widgets. A gate that can
+ * BLANK LIST, over a test that had just constructed the whole table. A gate that can
  * count a failure but not name it sends the reader back to guessing, which is the
  * state this whole module exists to end.
  *

package/lib/types/descriptors/index.d.ts

@@ -20,8 +20,8 @@ export declare const CURATED_DESCRIPTORS: readonly WidgetDescriptor[];
  * that merely LISTS such a tag hands a renderer a way to kill the process, and
  * `descriptorProblems()` cannot see it because it never instantiates anything.
  *
- * MEASURED bare-constructing all 164 generated rows on gjs 1.88.1 / GTK 4.22.4 /
- * libadwaita 1.9.3, resuming past each abort: **163 construct, one does not**, and not a
+ * MEASURED bare-constructing every generated row on gjs 1.88.1 / GTK 4.22.4 /
+ * libadwaita 1.9.3, resuming past each abort: **all but one construct**, and not a
  * single row throws. So this map is one entry rather than a policy — and
  * `constructsEveryDescriptor` in `generated.spec.ts` is what keeps it one entry.
  *
@@ -49,7 +49,7 @@ export declare const BUILTIN_DESCRIPTORS: readonly WidgetDescriptor[];
 export declare function registerBuiltinWidgets(): void;
 /** What the shipped table is made of, for a diagnostic or an about box. */
 export declare const tableProvenance: () => {
-    gir: "Gtk-4.0 Adw-1";
+    gir: "Gtk-4.0/4.23.3 Adw-1/1.10.0";
     curated: number;
     generated: number;
     total: number;

package/lib/types/errors.d.ts

@@ -43,6 +43,16 @@ export declare const err: {
     textNotAccepted: (tag: string, text: string) => GtkHostError;
     unclaimedChild: (parentTag: string, childTag: string) => GtkHostError;
     unknownSlot: (parentTag: string, slot: string, known: string[]) => GtkHostError;
+    /**
+     * An adder-backed slot with nothing that takes the child back out.
+     *
+     * `descriptorProblems()` rejects this shape up front, so a BUILT-IN descriptor can
+     * never reach here — but `registerWidget` takes descriptors from applications, which
+     * run no such check. Without this the unmount would be
+     * `TypeError: host[undefined] is not a function`, blaming the host for a claim the
+     * descriptor made.
+     */
+    slotNeedsRemove: (parentTag: string, slot: string, adder: string) => GtkHostError;
     rejectedChild: (parentTag: string, childTag: string, reason: string) => GtkHostError;
     uncuratedPlacement: (parentTag: string, childTag: string) => GtkHostError;
     siblingCycle: (parentTag: string) => GtkHostError;