@gjsify/adwaita-react-native 0.45.0 → 0.46.0

package/lib/types/row-shell.native.d.ts

@@ -0,0 +1,25 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import { type ViewStyle } from 'react-native';
+import { type AdwRowLabelInput } from '@gjsify/adwaita-core';
+/** A boxed-list row: the label column, then whatever trails it. */
+export declare const ADW_ROW_STYLE: ViewStyle;
+/** The title/subtitle column — it takes the width the trailing control does not. */
+export declare const ADW_ROW_TEXT_COLUMN_STYLE: ViewStyle;
+/**
+ * A part that is present and not drawn.
+ *
+ * `string_is_not_empty` said `false` for a label, or the apply latch is down for a
+ * button: the node stays in the tree and stops drawing, which is what the sibling
+ * renderers do and what lets a suite say WHICH part is hidden.
+ */
+export declare const ADW_ROW_HIDDEN_STYLE: ViewStyle;
+/**
+ * The two labels of a boxed-list row, with libadwaita's own visibility rule.
+ *
+ * The rule is `@gjsify/adwaita-core`'s `deriveRowLabels`, not a local `title !== ''`:
+ * it is the closure `adw-action-row.ui` binds to BOTH labels — the title's too, which is
+ * the half a hand-written port drops — and it is the same call `@gjsify/adwaita-web`'s
+ * `<adw-switch-row>` and `@gjsify/adwaita-nativescript`'s `rowLabelVisuals` make.
+ */
+export declare function AdwRowLabels({ title, subtitle }: AdwRowLabelInput): ReactElement;

package/lib/types/testing/gtk.spec.d.ts

@@ -0,0 +1,73 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import Gdk from 'gi://Gdk?version=4.0';
+import Gtk from 'gi://Gtk?version=4.0';
+import { type Runtime } from '@gjsify/unit';
+import { type CaptureWidget } from '@gjsify/gtk-host';
+/** Named identities, not a capability probe: a suite that ran zero tests reports success. */
+export declare const GTK_HOSTS: Runtime[];
+/** The frame every suite that does not care about width is laid out in. */
+export declare const FRAME_WIDTH = 1000;
+/** …and its height. */
+export declare const FRAME_HEIGHT = 200;
+/**
+ * The three calls `@gjsify/devtools`' `captureWidgetPng` makes, inlined.
+ *
+ * `null` means "no renderer or no size yet" and is what `blankReason` reads as "measured
+ * before it was ever on screen" — never "the image is empty".
+ */
+export declare const capture: CaptureWidget;
+/** The GType name a widget actually has, for an assertion that names the class. */
+export declare const typeOf: (widget: Gtk.Widget) => string;
+/**
+ * Mount into a REALISED, sized window and let GTK lay out, then run the body.
+ *
+ * A `Gtk.Box` that is not in a window is never allocated, so every size read off it is 0.
+ * The window is `present()`ed and the main context pumped until the container has a
+ * width; without the pump the first `get_width()` is 0 and the assertion would be
+ * measuring the scheduler.
+ *
+ * `title` is on the window because `Adw.HeaderBar` RESOLVES its derived title from the
+ * root window (`update_title`, adw-header-bar.c:475) — the one thing a header-bar suite
+ * cannot set up any other way.
+ *
+ * `rerender` is the THIRD argument because an update is a different claim from a mount,
+ * and the same root has to serve both: a second `createRoot` over the same container
+ * builds a second tree beside the first, so the suite would read a widget nothing
+ * updated. It pumps too — an assertion straight after a render measures the scheduler.
+ */
+export declare function laidOut(element: React.ReactNode, body: (container: Gtk.Widget, window: Gtk.Window, rerender: (next: React.ReactNode) => void) => void, options?: {
+    frameWidth?: number;
+    frameHeight?: number;
+    title?: string;
+}): void;
+/** First strict descendant of a GType, breadth-first over the REAL tree. */
+export declare function find(root: Gtk.Widget, gtype: string): Gtk.Widget;
+/**
+ * Is `child` inside a node carrying `cssClass`, up to `root`?
+ *
+ * THE ONLY WAY TO ASSERT A SLOT, for the slots whose adder is write-only. `add_top_bar`
+ * has no getter and `Adw.HeaderBar`'s two ends have none either, so a presence-based
+ * assertion passes with the child authored into the WRONG slot — measured in gtk-host's
+ * own conformance vectors, where every such assertion passed with a top bar authored
+ * into `bottom`. What separates them is the style class libadwaita puts on the internal
+ * box it packs into: `top-bar`/`bottom-bar` on the toolbar view (`_toolbars.scss`),
+ * `start`/`end` on the header bar's two `GtkBox`es (measured on libadwaita 1.9.3).
+ */
+export declare function insideClass(child: Gtk.Widget, root: Gtk.Widget, cssClass: string): boolean;
+/** What {@link withGtk} hands a suite. */
+export interface GtkHarness {
+    /** `describe`, with the diagnostics gate reset before and asserted after every test. */
+    gated: (name: string, run: () => Promise<void>) => Promise<void>;
+    /** The default display, or `null` where there is none — a photograph needs one. */
+    display: Gdk.Display | null;
+}
+/**
+ * Initialise GTK once, register the widget table, install the diagnostics gate, and run
+ * the suite inside it.
+ *
+ * `installDiagnosticsGate` is not optional decoration. Writing `css-classes` clobbers an
+ * orientation class, a generic `insert_before` on a `Gtk.ListBox` emitted 1 230 783
+ * `Gtk-WARNING` lines, and both are exit 0 — so every test in this package asserts zero
+ * GTK diagnostics as well as its own numbers.
+ */
+export declare function withGtk(suite: (harness: GtkHarness) => Promise<void>): Promise<void>;

package/lib/types/testing/react-native.d.ts

@@ -1,4 +1,4 @@
-import type { View as RealView } from 'react-native';
+import type { Pressable as RealPressable, Switch as RealSwitch, Text as RealText, TextInput as RealTextInput, View as RealView } from 'react-native';
 /**
  * The host element name `View` renders as.
  *
@@ -7,6 +7,32 @@ import type { View as RealView } from 'react-native';
  * reads the same as one written against the real thing.
  */
 export declare const RCT_VIEW = "RCTView";
+/**
+ * The host element name `Text` renders as.
+ *
+ * `RCTText` is React Native's own — `TextNativeComponent.js:57` registers the top-level
+ * text view under `uiViewClassName: 'RCTText'`, with `RCTVirtualText` for a NESTED one.
+ * This double never nests, so the outer name is the whole of what a tree assertion here
+ * can see; a widget that starts nesting text needs the second name and a reason.
+ */
+export declare const RCT_TEXT = "RCTText";
+/**
+ * `Switch`'s host element.
+ *
+ * PLATFORM-SPLIT UPSTREAM: `SwitchNativeComponent` declares `paperComponentName:
+ * 'RCTSwitch'` and `AndroidSwitchNativeComponent` declares `'AndroidSwitch'`, so there is
+ * no single true answer and this is the iOS one. Nothing in this package depends on which
+ * — the suites read this constant.
+ */
+export declare const RCT_SWITCH = "RCTSwitch";
+/**
+ * `TextInput`'s host element, single-line.
+ *
+ * PLATFORM-SPLIT the same way: `RCTSingelineTextInputNativeComponent` declares
+ * `uiViewClassName: 'RCTSinglelineTextInputView'` and `AndroidTextInputNativeComponent`
+ * declares `'AndroidTextInput'`.
+ */
+export declare const RCT_TEXT_INPUT = "RCTSinglelineTextInputView";
 /**
  * `react-native`'s `View`, as a host component.
  *
@@ -16,3 +42,32 @@ export declare const RCT_VIEW = "RCTView";
  * against React's intrinsic elements and knows nothing about React Native's.
  */
 export declare const View: typeof RealView;
+/**
+ * `react-native`'s `Text`, as a host component.
+ *
+ * Same contract as {@link View} and for the same reason: the `typeof RealText`
+ * annotation is what stops the double from growing a surface of its own, and
+ * `react-native.spec.ts` falsifies it rather than restating it.
+ *
+ * The real `Text` additionally wires `onPress` through the press responder and reads an
+ * inherited text context, neither of which is reproduced — so a spec here asserts that a
+ * widget ASKS for a press, never that a tap arrives. Same class of gap as Yoga, and the
+ * README carries it too.
+ */
+export declare const Text: typeof RealText;
+/**
+ * `react-native`'s `Pressable`, as a host component rendering a view.
+ *
+ * REAL `Pressable` DOES RENDER A `View` — it is a wrapper that turns press props into
+ * responder handlers — but it does NOT forward `onPress` to the host node, and this
+ * double does. That is why every assertion about press behaviour in this package reads
+ * the props off the COMPOSITE (`renderer.root.findByType(Pressable)`) and only the
+ * nesting off `toJSON()`: what a widget hands to `Pressable` is a fact about the widget,
+ * and what `Pressable` then does with it is React Native's business and is not measured
+ * here.
+ */
+export declare const Pressable: typeof RealPressable;
+/** `react-native`'s `Switch`, as a host component. Same contract as {@link View}. */
+export declare const Switch: typeof RealSwitch;
+/** `react-native`'s `TextInput`, as a host component. Same contract as {@link View}. */
+export declare const TextInput: typeof RealTextInput;

package/lib/types/testing/react-native.spec.d.ts

@@ -1,6 +1,6 @@
-import type { View as RealView } from 'react-native';
+import type { Pressable as RealPressable, Switch as RealSwitch, Text as RealText, TextInput as RealTextInput, View as RealView } from 'react-native';
 import type { Assert, SameKeys } from '../parity.spec.js';
-import { View } from './react-native.js';
+import { Pressable, Switch, Text, TextInput, View } from './react-native.js';
 /**
  * The double accepts EXACTLY React Native's `View` props — same names, no more, no
  * fewer.
@@ -29,5 +29,27 @@ import { View } from './react-native.js';
  * reason one level up: the package's own props are all-optional too.
  */
 export type DoublePropsMatchReactNative = Assert<SameKeys<Parameters<typeof View>[0], Parameters<typeof RealView>[0]>>;
+/**
+ * The same contract for `Text`, which most of this package's widgets render.
+ *
+ * A SECOND PRIMITIVE IS A SECOND CHANCE TO INVENT ONE. `View` was pinned from the day it
+ * existed and `Text` arrived later, with widgets already leaning on it — which is exactly
+ * the order in which a double acquires a prop React Native does not have. And it is not
+ * redundant with the assertion above: `ViewProps` and `TextProps` are different key sets
+ * — `numberOfLines`, `ellipsizeMode` and `onPress` are on one and not the other — so a
+ * `Text` double annotated `typeof RealView` by a copy-paste would satisfy every assertion
+ * about `View` and none about the component the widgets actually use.
+ */
+export type TextPropsMatchReactNative = Assert<SameKeys<Parameters<typeof Text>[0], Parameters<typeof RealText>[0]>>;
+/**
+ * The same instrument for the three primitives the boxed-list rows added.
+ *
+ * One alias per primitive rather than a mapped type over them: `SameKeys` is a
+ * CONSTRAINT violation when it fails, and the diagnostic then names the alias — which
+ * names the primitive. A mapped type would report one error naming the map.
+ */
+export type PressablePropsMatchReactNative = Assert<SameKeys<Parameters<typeof Pressable>[0], Parameters<typeof RealPressable>[0]>>;
+export type SwitchPropsMatchReactNative = Assert<SameKeys<Parameters<typeof Switch>[0], Parameters<typeof RealSwitch>[0]>>;
+export type TextInputPropsMatchReactNative = Assert<SameKeys<Parameters<typeof TextInput>[0], Parameters<typeof RealTextInput>[0]>>;
 declare const _default: () => Promise<void>;
 export default _default;

package/lib/types/testing/render.spec.d.ts

@@ -0,0 +1,49 @@
+import { type ReactTestRenderer, type ReactTestRendererJSON } from 'react-test-renderer';
+/** A host node's style, as the widget asked for it. */
+export type Style = Record<string, unknown> | undefined;
+/**
+ * Mount and keep the RENDERER, for a suite that has to drive a state transition.
+ *
+ * ONE renderer, read twice. Creating a second one for the post-transition read hands back
+ * a pre-transition snapshot — the state lives in the first — and the suite then asserts
+ * the untouched tree while claiming to assert the settled one.
+ */
+export declare function mount(element: React.ReactElement): ReactTestRenderer;
+/** Mount and read the tree. */
+export declare const mounted: (element: React.ReactElement) => ReactTestRendererJSON;
+/**
+ * Deliver ONE `onLayout` at `width` to the tree a MOUNTED renderer is showing, and read
+ * back what it settled on.
+ *
+ * Every size-aware widget in this package binds to the size of the VIEW rather than of
+ * the window, so its root node carries the `onLayout` and nothing downstream knows a size
+ * until one arrives. The missing-handler case is a THROW and not a skip: a widget that
+ * stopped emitting `onLayout` would otherwise leave every assertion below it reading the
+ * pre-layout tree and passing.
+ *
+ * Separate from {@link settled} because an UPDATE needs the same delivery on a renderer
+ * that is already mounted — a widget re-reads no size on its own, so a tree read straight
+ * after `renderer.update` is still the pre-layout one.
+ */
+export declare function deliverLayout(renderer: ReactTestRenderer, width: number, height?: number): ReactTestRendererJSON;
+/**
+ * Mount, deliver ONE `onLayout` at `width`, and read the tree the widget settled on.
+ *
+ * ONE renderer, read twice — the reason is on {@link mount}.
+ */
+export declare const settled: (element: React.ReactElement, width: number, height?: number) => ReactTestRendererJSON;
+/** A node's element children, with text children refused rather than silently skipped. */
+export declare function childrenOf(node: ReactTestRendererJSON): ReactTestRendererJSON[];
+/**
+ * The child at `index`, or a failure naming the count.
+ *
+ * An index into a `ReactTestRendererJSON[]` is `| undefined`, and the two ways out of
+ * that in an assertion are both worse than a throw: `?.` turns a missing node into a
+ * comparison against `undefined` that some matcher will accept, and a cast asserts the
+ * thing the test was supposed to check.
+ */
+export declare function at(nodes: ReactTestRendererJSON[], index: number): ReactTestRendererJSON;
+/** The one element child, or a failure naming what was there instead. */
+export declare function onlyChild(node: ReactTestRendererJSON): ReactTestRendererJSON;
+/** The text a `Text` node holds, joined — `toJSON` reports it as a child array. */
+export declare function textOf(node: ReactTestRendererJSON): string;

package/lib/types/widgets/action-row.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from 'react';
+import type { AdwActionRowProps } from '../props.js';
+/**
+ * A boxed-list row with a title, a subtitle and a trailing slot.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE THEIR LABEL RULE AND NOTHING ELSE. libadwaita binds
+ * `string_is_not_empty` onto both labels, so an empty title hides its label rather than
+ * leaving a blank line; on GTK the real `Adw.ActionRow` applies that binding in C, and on
+ * React Native `@gjsify/adwaita-core`'s `deriveRowLabels` — the same call
+ * `@gjsify/adwaita-web` and `@gjsify/adwaita-nativescript` make — applies it in
+ * TypeScript. Both suites assert the same four outputs of it rather than each side's own
+ * idea of "the subtitle is empty".
+ */
+export declare function AdwActionRow(_props: AdwActionRowProps): ReactElement | null;

package/lib/types/widgets/action-row.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwActionRowProps } from '../props.js';
+/** {@link import('./action-row.js').AdwActionRow} on GTK. */
+export declare function AdwActionRow({ title, subtitle, activatable, onActivated, children, }: AdwActionRowProps): ReactElement | null;

package/lib/types/widgets/action-row.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwActionRowProps } from '../props.js';
+/** {@link import('./action-row.js').AdwActionRow} on React Native. */
+export declare function AdwActionRow({ title, subtitle, activatable, onActivated, children, }: AdwActionRowProps): ReactElement | null;

package/lib/types/widgets/avatar.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwAvatarProps } from '../props.js';
+/**
+ * A round avatar showing initials derived from a name, or a fallback icon.
+ *
+ * BOTH HALVES DERIVE THE SAME TWO THINGS FROM THE SAME PORT. The initials and the
+ * palette entry come from `@gjsify/adwaita-core`'s `avatarInitials` / `avatarColor` —
+ * `extract_initials_from_text` and `set_class_color` in TypeScript, hashing UTF-8 bytes
+ * as `g_str_hash` does. On GTK the real `Adw.Avatar` runs the C original and stamps
+ * `color11` on its internal gizmo; the React Native half paints the same palette entry.
+ * The suites assert that pair by NAME, not by "an avatar appeared".
+ */
+export declare function AdwAvatar(_props: AdwAvatarProps): ReactElement | null;

package/lib/types/widgets/avatar.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwAvatarProps } from '../props.js';
+/** {@link import('./avatar.js').AdwAvatar} on GTK. */
+export declare function AdwAvatar({ size, text, showInitials, iconName }: AdwAvatarProps): ReactElement | null;

package/lib/types/widgets/avatar.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwAvatarProps } from '../props.js';
+/** {@link import('./avatar.js').AdwAvatar} on React Native. */
+export declare function AdwAvatar({ size, text, showInitials }: AdwAvatarProps): ReactElement | null;

package/lib/types/widgets/avatar.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/banner.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwBannerProps } from '../props.js';
+/**
+ * A full-width strip carrying one in-context message and an optional action button.
+ *
+ * `Adw.Banner` HAS NO ARITHMETIC — its whole specification is five property defaults
+ * and three derivations, all of them in `@gjsify/adwaita-core`. The two that are easy to
+ * get backwards are the button's visibility (`label && label[0]`, a FIRST-CHARACTER test,
+ * so a label of spaces still draws a button) and its mnemonic marker (the template pins
+ * the button to `use-underline=True` with no property to turn it off, and pins the TITLE
+ * to False, so exactly one of the two strings is stripped).
+ */
+export declare function AdwBanner(_props: AdwBannerProps): ReactElement | null;

package/lib/types/widgets/banner.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwBannerProps } from '../props.js';
+/** {@link import('./banner.js').AdwBanner} on GTK. */
+export declare function AdwBanner({ title, buttonLabel, revealed, useMarkup, buttonStyle, onButtonClicked, }: AdwBannerProps): ReactElement | null;

package/lib/types/widgets/banner.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwBannerProps } from '../props.js';
+/** {@link import('./banner.js').AdwBanner} on React Native. */
+export declare function AdwBanner({ title, buttonLabel, revealed, useMarkup, buttonStyle, onButtonClicked, }: AdwBannerProps): ReactElement | null;

package/lib/types/widgets/banner.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/button-content.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from 'react';
+import type { AdwButtonContentProps } from '../props.js';
+/**
+ * An icon paired with a label, for the inside of a button.
+ *
+ * THE DERIVATIONS ARE THE WIDGET. There is no layout arithmetic here — there are four
+ * questions (`buttonContentIconName`, `buttonContentIconExpands`,
+ * `buttonContentLabelVisible`, `buttonContentEllipsize`) and both halves ask
+ * `@gjsify/adwaita-core` all four. Two of them are places a renderer guesses wrong:
+ * an empty `icon-name` DRAWS `image-missing` rather than hiding the icon (libadwaita's
+ * own doc comments say otherwise and its code disagrees with them), and the icon takes
+ * the free space exactly when there is no label.
+ */
+export declare function AdwButtonContent(_props: AdwButtonContentProps): ReactElement | null;

package/lib/types/widgets/button-content.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwButtonContentProps } from '../props.js';
+/** {@link import('./button-content.js').AdwButtonContent} on GTK. */
+export declare function AdwButtonContent({ iconName, label, useUnderline, canShrink, }: AdwButtonContentProps): ReactElement | null;

package/lib/types/widgets/button-content.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwButtonContentProps } from '../props.js';
+/** {@link import('./button-content.js').AdwButtonContent} on React Native. */
+export declare function AdwButtonContent({ label, useUnderline, canShrink }: AdwButtonContentProps): ReactElement | null;

package/lib/types/widgets/button-content.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/button-row.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwButtonRowProps } from '../props.js';
+/**
+ * A boxed-list row that behaves like a button.
+ *
+ * ALWAYS ACTIVATABLE, and that is a fact both halves read out of
+ * `@gjsify/adwaita-core`'s `BUTTON_ROW_ACTIVATABLE` rather than each writing `true`:
+ * the upstream template hardcodes `activatable=True`, the class documentation says
+ * "AdwButtonRow is always activatable", and the sibling `<AdwActionRow>` reads
+ * `activatable` as an ordinary prop — so one surface carrying two opposite meanings for
+ * the same word is exactly what the shared constant prevents.
+ */
+export declare function AdwButtonRow(_props: AdwButtonRowProps): ReactElement | null;

package/lib/types/widgets/button-row.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwButtonRowProps } from '../props.js';
+/** {@link import('./button-row.js').AdwButtonRow} on GTK. */
+export declare function AdwButtonRow({ title, onActivated }: AdwButtonRowProps): ReactElement | null;

package/lib/types/widgets/button-row.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwButtonRowProps } from '../props.js';
+/** {@link import('./button-row.js').AdwButtonRow} on React Native. */
+export declare function AdwButtonRow({ title, onActivated }: AdwButtonRowProps): ReactElement | null;

package/lib/types/widgets/combo-row.d.ts

@@ -0,0 +1,13 @@
+import type { ReactElement } from 'react';
+import type { AdwComboRowProps } from '../props.js';
+/**
+ * A row that picks one item out of a list.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE THE SELECTION MODEL AND NOTHING ELSE. On GTK the real
+ * `Adw.ComboRow` drives a `GtkSingleSelection` over a `Gtk.StringList`; on React Native
+ * `@gjsify/adwaita-core`'s `ComboState` — the same index↔value mapping, the same autoselect
+ * on a replaced model, the same `n_items > 1` chooser rule — runs in TypeScript. Both sides
+ * are asked the same questions with the same options: how many items, which one is
+ * selected, and whether the row presents itself as a chooser at all.
+ */
+export declare function AdwComboRow(_props: AdwComboRowProps): ReactElement | null;

package/lib/types/widgets/combo-row.gtk.d.ts

@@ -0,0 +1,15 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwComboRowProps } from '../props.js';
+/**
+ * `GTK_INVALID_LIST_POSITION` — `G_MAXUINT`, which GIR gives no constant for.
+ *
+ * Exported so the spec can assert the translation against the number libadwaita actually
+ * stores rather than against itself; `parity.spec.ts` allows a platform-only export beside
+ * the widget for exactly this.
+ */
+export declare const GTK_INVALID_LIST_POSITION = 4294967295;
+/** `AdwComboRow:selected` as `@gjsify/adwaita-core` spells it. */
+export declare const comboSelectedIndex: (selected: number) => number;
+/** {@link import('./combo-row.js').AdwComboRow} on GTK. */
+export declare function AdwComboRow({ title, subtitle, model, selected, useSubtitle, onNotifySelected, }: AdwComboRowProps): ReactElement | null;

package/lib/types/widgets/combo-row.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwComboRowProps } from '../props.js';
+/** {@link import('./combo-row.js').AdwComboRow} on React Native. */
+export declare function AdwComboRow({ title, subtitle, model, selected, useSubtitle, onNotifySelected, }: AdwComboRowProps): ReactElement | null;

package/lib/types/widgets/content.gtk.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/entry-row.d.ts

@@ -0,0 +1,14 @@
+import type { ReactElement } from 'react';
+import type { AdwEntryRowProps } from '../props.js';
+/**
+ * A boxed-list row that is itself a text entry.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE A TRUTH TABLE. `Adw.EntryRow` looks like layout and is
+ * almost none: `update_empty` is a five-output derivation over four inputs (text length ·
+ * editing · editable · the `text_changed` apply latch), and Enter dispatches to exactly
+ * one of two signals depending on that latch. On GTK the real widget computes it in C; on
+ * React Native `@gjsify/adwaita-core`'s `EntryRowState` — the same state machine
+ * `@gjsify/adwaita-web` and `@gjsify/adwaita-nativescript` compose — computes it in
+ * TypeScript. So the suites assert the same rows of the same table on both sides.
+ */
+export declare function AdwEntryRow(_props: AdwEntryRowProps): ReactElement | null;

package/lib/types/widgets/entry-row.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwEntryRowProps } from '../props.js';
+/** {@link import('./entry-row.js').AdwEntryRow} on GTK. */
+export declare function AdwEntryRow({ title, text, maxLength, editable, showApplyButton, onNotifyText, onApply, onEntryActivated, }: AdwEntryRowProps): ReactElement | null;

package/lib/types/widgets/entry-row.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwEntryRowProps } from '../props.js';
+/** {@link import('./entry-row.js').AdwEntryRow} on React Native. */
+export declare function AdwEntryRow({ title, text, maxLength, editable, showApplyButton, onNotifyText, onApply, onEntryActivated, }: AdwEntryRowProps): ReactElement | null;

package/lib/types/widgets/expander-row.d.ts

@@ -0,0 +1,19 @@
+import type { ReactElement } from 'react';
+import type { AdwExpanderRowProps } from '../props.js';
+/**
+ * A boxed-list row that discloses further rows beneath itself.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE ONE DISCLOSURE MACHINE. `expanded` is idempotent — a set
+ * to the value already held changes nothing and notifies nobody — and that is GObject's
+ * own property gate on GTK and `@gjsify/adwaita-core`'s `ExpanderState` on React Native,
+ * the same state machine `@gjsify/adwaita-web`'s `<adw-expander-row>` and
+ * `@gjsify/adwaita-nativescript`'s `AdwExpanderRow` compose. So both suites assert the
+ * same three transitions rather than each side's own idea of "toggled".
+ *
+ * AND BOTH KEEP THE COLLAPSED CHILDREN IN THE TREE. GTK puts them under a
+ * `Gtk.Revealer`, which leaves them parented and UNMAPPED; the React Native half gives
+ * the disclosure `display: 'none'`, which is what the sibling renderers do. Unmounting
+ * them instead would look identical on screen and lose every child's state on a
+ * collapse.
+ */
+export declare function AdwExpanderRow(_props: AdwExpanderRowProps): ReactElement | null;

package/lib/types/widgets/expander-row.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import { type ReactElement } from 'react';
+import type { AdwExpanderRowProps } from '../props.js';
+/** {@link import('./expander-row.js').AdwExpanderRow} on GTK. */
+export declare function AdwExpanderRow({ title, subtitle, expanded, onNotifyExpanded, children, }: AdwExpanderRowProps): ReactElement | null;

package/lib/types/widgets/expander-row.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwExpanderRowProps } from '../props.js';
+/** {@link import('./expander-row.js').AdwExpanderRow} on React Native. */
+export declare function AdwExpanderRow({ title, subtitle, expanded, onNotifyExpanded, children, }: AdwExpanderRowProps): ReactElement | null;

package/lib/types/widgets/header-bar.d.ts

@@ -0,0 +1,30 @@
+import type { ReactElement } from 'react';
+import type { AdwHeaderBarProps } from '../props.js';
+/**
+ * The start / centre / end bar at the top of a window.
+ *
+ * THE PHONE QUESTION IS THE CENTRE, and this package answers it the way
+ * `@gjsify/adwaita-nativescript` already did rather than inventing a third answer:
+ * `Adw.HeaderBar` has NO `title` property — its derived centre is a plain
+ * `gtk_label_new (NULL)` over a title RESOLVED from the navigation page, the dialog, the
+ * window and then the application name (`update_title`, adw-header-bar.c:475) — and both
+ * existing renderers instead expose `title`/`subtitle` on the bar and put an
+ * `AdwWindowTitle` in the centre. That is a DIVERGENCE, recorded as
+ * `HeaderBarRenderState.derivedSubtitle` in `@gjsify/adwaita-core`, and it is kept here
+ * because a declarative surface has no widget handoff to offer instead.
+ *
+ * WHAT THE TWO HALVES DO NOT SHARE is what happens when nothing is authored. On GTK the
+ * chain is REAL and free: authoring neither `title` nor `subtitle` installs no title
+ * widget at all, so libadwaita resolves the window's own title into its own label, which
+ * `header-bar.gtk.spec.tsx` reads back. React Native has no such ancestry to resolve
+ * from, so an unauthored title there is blank. Named in the README.
+ *
+ * `HeaderBarState` IS DELIBERATELY NOT USED. It is an imperative model over an
+ * identity-keyed child list — `packStart`, `packEnd`, `remove` — and a props object is
+ * already the whole state, recomputed on every render. Of the three rules it holds, two
+ * do not arise on this surface: `pack_end`'s prepend is invisible where the slot is
+ * written in draw order, and the "taking the centre back rebuilds the derived title"
+ * transition is just the next render. The third — the title-widget either/or — is one
+ * expression, and both halves below write the same one.
+ */
+export declare function AdwHeaderBar(_props: AdwHeaderBarProps): ReactElement | null;

package/lib/types/widgets/header-bar.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwHeaderBarProps } from '../props.js';
+/** {@link import('./header-bar.js').AdwHeaderBar} on GTK. */
+export declare function AdwHeaderBar({ titleWidget, title, subtitle, start, end }: AdwHeaderBarProps): ReactElement | null;

package/lib/types/widgets/header-bar.gtk.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/header-bar.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwHeaderBarProps } from '../props.js';
+/** {@link import('./header-bar.js').AdwHeaderBar} on React Native. */
+export declare function AdwHeaderBar({ titleWidget, title, subtitle, start, end }: AdwHeaderBarProps): ReactElement | null;

package/lib/types/widgets/header-bar.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/navigation-page.d.ts

@@ -0,0 +1,12 @@
+import type { ReactElement } from 'react';
+import type { AdwNavigationPageProps } from '../props.js';
+/**
+ * One page of a navigation view, or one pane of a navigation split view.
+ *
+ * IT CARRIES THREE VALUES AND DRAWS NONE OF THEM. `title`, `tag` and `can-pop` are
+ * read by whatever holds the page — the view's stack machine on both halves — and the
+ * page itself is a container. That is libadwaita's own shape: `AdwNavigationPage` is an
+ * `AdwBin` with three properties, and the title appears on screen only because the
+ * view puts it in a header bar.
+ */
+export declare function AdwNavigationPage(_props: AdwNavigationPageProps): ReactElement | null;

package/lib/types/widgets/navigation-page.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwNavigationPageProps } from '../props.js';
+/** {@link import('./navigation-page.js').AdwNavigationPage} on GTK. */
+export declare function AdwNavigationPage({ children, title, tag, canPop }: AdwNavigationPageProps): ReactElement | null;

package/lib/types/widgets/navigation-page.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwNavigationPageProps } from '../props.js';
+/** {@link import('./navigation-page.js').AdwNavigationPage} on React Native. */
+export declare function AdwNavigationPage({ children }: AdwNavigationPageProps): ReactElement | null;

package/lib/types/widgets/navigation-page.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;