@gjsify/adwaita-core 0.31.0 → 0.32.0

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

@@ -0,0 +1,97 @@
+import type { BottomSheetCloseOutcome, BottomSheetCloseSource, BottomSheetTeardownCallback } from '../dialog.js';
+/** One `resolveBottomSheetClose` expectation. */
+export interface BottomSheetCloseVector {
+    /** Which affordance asked to close. */
+    source: BottomSheetCloseSource;
+    /** `AdwBottomSheet:open` at the time of the request. */
+    open: boolean;
+    /** `AdwBottomSheet:can-close` at the time of the request. */
+    canClose: boolean;
+    /** What the C source does with it. */
+    outcome: BottomSheetCloseOutcome;
+    /** Why this row exists — the rule or corner it pins down. */
+    rule: string;
+    /** The C function + lines it is derived from. */
+    derivedFrom: string;
+}
+/**
+ * The full decision table — every `(source, open, canClose)` combination that is
+ * distinguishable, so a renderer cannot pass by implementing three of the four
+ * paths and aliasing the fourth.
+ */
+export declare const BOTTOM_SHEET_CLOSE_VECTORS: ReadonlyArray<BottomSheetCloseVector>;
+/** One step of a {@link BottomSheetPresentationVector}, in the order it is applied. */
+export type BottomSheetPresentationStep = 
+/** The programmatic path — `adw_bottom_sheet_set_open`, ignores `can-close`. */
+{
+    readonly kind: 'setOpen';
+    readonly open: boolean;
+}
+/** `adw_bottom_sheet_set_can_close`. */
+ | {
+    readonly kind: 'setCanClose';
+    readonly canClose: boolean;
+}
+/** The interactive path — runs the {@link BOTTOM_SHEET_CLOSE_VECTORS} gate. */
+ | {
+    readonly kind: 'requestClose';
+    readonly source: BottomSheetCloseSource;
+};
+/**
+ * One end-to-end presentation expectation.
+ *
+ * Every field except `callbacks`/`hasBeenOpen` is observable from a RENDERER too
+ * — `notifications` is the `notify::open` event stream, `outcomes` is what the
+ * widget's `requestClose()` returns — so the same row drives the core suite, the
+ * browser suite and the NativeScript suite. `callbacks` and `hasBeenOpen` are
+ * the core-only seam `AdwDialog` consumes.
+ */
+export interface BottomSheetPresentationVector {
+    /** Applied in order, through the surface every implementation exposes. */
+    steps: readonly BottomSheetPresentationStep[];
+    /** The outcome of each `requestClose` step, in order (other steps contribute nothing). */
+    outcomes: readonly BottomSheetCloseOutcome[];
+    /** Every `notify::open` payload, in order. A spurious notification makes this longer. */
+    notifications: readonly boolean[];
+    /** The `closing`/`closed` callback log — core-only (`adw_bottom_sheet_set_callbacks`). */
+    callbacks: readonly BottomSheetTeardownCallback[];
+    /** `open` after the last step. */
+    open: boolean;
+    /** `has_been_open` after the last step. */
+    hasBeenOpen: boolean;
+    /** Why this row exists. */
+    rule: string;
+    /** The C function + lines it is derived from. */
+    derivedFrom: string;
+}
+/**
+ * The three-method surface a {@link BottomSheetPresentationVector} is replayed
+ * against. Core implements it directly; each renderer implements it by driving
+ * its REAL widget (an attribute write, a property set, a `requestClose()` call),
+ * so the same script exercises the same behaviour on every side.
+ */
+export interface BottomSheetPresentationAdapter {
+    /** The programmatic path (`AdwBottomSheet:open`). */
+    setOpen(open: boolean): void;
+    /** `AdwBottomSheet:can-close`. */
+    setCanClose(canClose: boolean): void;
+    /** The interactive path — returns what the gate decided. */
+    requestClose(source: BottomSheetCloseSource): BottomSheetCloseOutcome;
+}
+/**
+ * Replay a vector's steps against `adapter`, collecting the outcome of each
+ * `requestClose` step in order. Shared by all three suites so no side can drift
+ * in HOW it replays a row.
+ */
+export declare function runBottomSheetSteps(adapter: BottomSheetPresentationAdapter, steps: readonly BottomSheetPresentationStep[]): BottomSheetCloseOutcome[];
+/**
+ * `adw_bottom_sheet_set_open`'s state machine as scripts: the idempotent guard,
+ * the never-been-open teardown replay, and which paths notify.
+ *
+ * The `notifications` column is the one that caught a live bug: the browser port
+ * emitted `notify::open` whenever the open ATTRIBUTE VALUE changed rather than
+ * when the open STATE changed, so `setAttribute('open','')` followed by
+ * `setAttribute('open','false')` fired a second notification carrying an
+ * unchanged payload.
+ */
+export declare const BOTTOM_SHEET_PRESENTATION_VECTORS: ReadonlyArray<BottomSheetPresentationVector>;

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

@@ -0,0 +1,185 @@
+import type { EntryRowActivation, EntryRowRenderState, PasswordEntryRowRenderState } from '../entry-row.js';
+/** One `entryTextLength` expectation. */
+export interface EntryTextLengthVector {
+    /** The entry contents. */
+    text: string;
+    /** `adw_entry_row_get_text_length` — "The current number of characters". */
+    length: number;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `adw_entry_row_get_text_length` (adw-entry-row.c:1304-1318), whose property is
+ * declared `0, G_MAXUINT16, 0` (C:666-669).
+ *
+ * The astral rows are the point: `'🔒é'.length` is 3 in JS because JS counts
+ * UTF-16 units, and GTK counts characters. A port that gets this wrong also
+ * truncates surrogate pairs in half at `max-length`.
+ */
+export declare const ENTRY_TEXT_LENGTH_VECTORS: ReadonlyArray<EntryTextLengthVector>;
+/** One `clampEntryText` / `setMaxLength` expectation. */
+export interface EntryMaxLengthVector {
+    /** The text handed to the entry. */
+    text: string;
+    /** `Adw.EntryRow:max-length` — `0` = unlimited. */
+    maxLength: number;
+    /** What the entry ends up holding. */
+    clamped: string;
+    /** {@link EntryTextLengthVector.length} of {@link clamped}. */
+    length: number;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `adw_entry_row_set_max_length` (adw-entry-row.c:1329-1343) read together with
+ * the property doc "Maximum number of characters for the entry" and its
+ * `0..GTK_ENTRY_BUFFER_MAX_SIZE` range with `0` as both default and floor
+ * (C:674, :678-682).
+ */
+export declare const ENTRY_MAX_LENGTH_VECTORS: ReadonlyArray<EntryMaxLengthVector>;
+/**
+ * One mutation in an entry-row scenario. A renderer maps each `op` onto its own
+ * platform gesture (focus/blur the field, type into it, toggle the property).
+ */
+export type EntryRowStep = {
+    op: 'setText';
+    value: string;
+} | {
+    op: 'setEditing';
+    value: boolean;
+} | {
+    op: 'setEditable';
+    value: boolean;
+} | {
+    op: 'setMaxLength';
+    value: number;
+} | {
+    op: 'setShowApplyButton';
+    value: boolean;
+} | {
+    op: 'setShowIndicator';
+    value: boolean;
+} | {
+    op: 'setActivatesDefault';
+    value: boolean;
+} | {
+    op: 'apply';
+};
+/** One `update_empty` truth-table row: a scenario and the FULL snapshot it lands on. */
+export interface EntryRowStateVector {
+    /** Human-readable scenario name (used as the test title). */
+    name: string;
+    /** Applied in order to a freshly-constructed entry row. */
+    steps: ReadonlyArray<EntryRowStep>;
+    /** Every output of the derivation afterwards. */
+    expected: EntryRowRenderState;
+    /** The C rule this row pins down. */
+    rule: string;
+}
+/**
+ * `update_empty` (adw-entry-row.c:147-161) plus the `text_changed` latch
+ * (C:170-172) and its two reset paths (the apply click C:237, the property
+ * turned off C:989-992).
+ *
+ * Defaults of a fresh row: no text, unlimited length, not editing, EDITABLE,
+ * no apply button, no indicator — plus the indicator and apply button starting
+ * child-invisible (`adw_entry_row_init`, C:764-765).
+ */
+export declare const ENTRY_ROW_STATE_VECTORS: ReadonlyArray<EntryRowStateVector>;
+/** One `text_activated_cb` expectation. */
+export interface EntryRowActivationVector {
+    /** Human-readable scenario name. */
+    name: string;
+    /** Applied in order to a freshly-constructed entry row before pressing Enter. */
+    steps: ReadonlyArray<EntryRowStep>;
+    /** What Enter resolves to — exactly ONE signal. */
+    activation: EntryRowActivation;
+    /** The latch afterwards (`apply` clears it; `entry-activated` leaves state alone). */
+    textChangedAfter: boolean;
+    /** The C rule this row pins down. */
+    rule: string;
+}
+/**
+ * `text_activated_cb` (adw-entry-row.c:243-266): the apply path when the apply
+ * button is child-visible, otherwise activate-the-default (C:253-254) followed
+ * by `entry-activated` (C:256) — in that order.
+ */
+export declare const ENTRY_ROW_ACTIVATION_VECTORS: ReadonlyArray<EntryRowActivationVector>;
+/** One setter-guard expectation: what each step returns, and how many re-derivations the sequence causes. */
+export interface EntryRowGuardVector {
+    /** Human-readable scenario name. */
+    name: string;
+    /** Applied in order to a freshly-constructed entry row. */
+    steps: ReadonlyArray<EntryRowStep>;
+    /** Per step: the setter's return value, or `null` for the `void` `setShowIndicator`. */
+    returns: ReadonlyArray<boolean | null>;
+    /** How many times subscribers are notified across the whole sequence. */
+    notifications: number;
+    /** The C rule this row pins down. */
+    rule: string;
+}
+/**
+ * The guards are NOT uniform, and the asymmetry is the point: every public
+ * setter early-outs on an unchanged value (C:984, :1198, :1247, :1339), while
+ * the private `adw_entry_row_set_show_indicator` (C:1281-1296) deliberately has
+ * NO equality check and re-derives unconditionally.
+ */
+export declare const ENTRY_ROW_GUARD_VECTORS: ReadonlyArray<EntryRowGuardVector>;
+/** One mutation in a password-entry-row scenario. */
+export type PasswordEntryRowStep = {
+    op: 'setRevealed';
+    value: boolean;
+} | {
+    op: 'togglePeek';
+} | {
+    op: 'setCapsLockOn';
+    value: boolean;
+}
+/** A step applied to the COMPOSED entry row (e.g. focusing the field). */
+ | {
+    op: 'entry';
+    step: EntryRowStep;
+};
+/** One password-entry-row expectation: the peek/caps-lock snapshot plus what it did to the parent row. */
+export interface PasswordEntryRowVector {
+    /** Human-readable scenario name. */
+    name: string;
+    /** Applied in order to a freshly-constructed password entry row. */
+    steps: ReadonlyArray<PasswordEntryRowStep>;
+    /** Every output of the password derivation afterwards. */
+    expected: PasswordEntryRowRenderState;
+    /** `indicatorVisible` on the composed entry row — the caps-lock warning the user actually sees. */
+    entryIndicatorVisible: boolean;
+    /** The C rule this row pins down. */
+    rule: string;
+}
+/**
+ * `notify_visibility_cb` (adw-password-entry-row.c:62-81) + `update_caps_lock`
+ * (C:52-60), and the two rules that make the caps-lock warning more than a
+ * boolean: it is suppressed while PEEKING (C:58, `!gtk_text_get_visibility`) and
+ * suppressed while UNFOCUSED (adw-entry-row.c:151, `editing && show_indicator`).
+ */
+export declare const PASSWORD_ENTRY_ROW_VECTORS: ReadonlyArray<PasswordEntryRowVector>;
+/** One peek-notification expectation — how often a reveal change is observable. */
+export interface PasswordRevealGuardVector {
+    /** Human-readable scenario name. */
+    name: string;
+    /** Reveal-only steps applied to a freshly-constructed password entry row. */
+    steps: ReadonlyArray<{
+        op: 'setRevealed';
+        value: boolean;
+    } | {
+        op: 'togglePeek';
+    }>;
+    /** How many reveal notifications the sequence produces. */
+    notifications: number;
+    /** The C rule this row pins down. */
+    rule: string;
+}
+/**
+ * The peek guard. Every settable property in this family early-outs on an
+ * unchanged value (adw-entry-row.c:984, :1198, :1247), so a redundant set is
+ * silent by house rule — which is what makes the web port's unguarded
+ * `notify::revealed` on a same-value `setAttribute` a defect.
+ */
+export declare const PASSWORD_REVEAL_GUARD_VECTORS: ReadonlyArray<PasswordRevealGuardVector>;

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

@@ -0,0 +1,44 @@
+export { ABOUT_DIALOG_CREDITS_LEGAL_VECTORS, ABOUT_DIALOG_DETAILS_VECTORS, ABOUT_DIALOG_HEADER_VECTORS, ABOUT_DIALOG_LABEL_VECTORS, ABOUT_DIALOG_SUPPORT_VECTORS, CREDITS_SECTIONS_VECTORS, CREDIT_PERSON_VECTORS, LEGAL_SECTION_VECTORS, LICENSE_INFO_VECTORS, LICENSE_SETTER_VECTORS, LICENSE_SPDX_VECTORS, LICENSE_TEXT_VECTORS, TRANSLATOR_CREDITS_VECTORS, } from './about-dialog.js';
+export type { AboutDialogCreditsLegalVector, AboutDialogDetailsVector, AboutDialogHeaderVector, AboutDialogLabelVector, AboutDialogSupportVector, CreditPersonVector, CreditsSectionsVector, LegalSectionVector, LicenseInfoVector, LicenseSetterStep, LicenseSetterVector, LicenseSpdxVector, LicenseTextVector, TranslatorCreditsVector, } from './about-dialog.js';
+export { AVATAR_COLOR_VECTORS, AVATAR_FONT_SIZE_VECTORS, AVATAR_INITIALS_VECTORS, AVATAR_MODE_VECTORS, } from './avatar.js';
+export type { AvatarColorVector, AvatarFontSizeVector, AvatarInitialsVector, AvatarModeVector } from './avatar.js';
+export { ACTION_ROW_ACTIVATION_VECTORS, BUTTON_ROW_ACTIVATABLE_VECTORS, BUTTON_ROW_ICON_VECTORS, LABEL_VISIBILITY_VECTORS, SWITCH_ROW_NOTIFY_VECTORS, WINDOW_TITLE_VECTORS, } from './action-row.js';
+export type { ActionRowActivationVector, ActionRowStep, ButtonRowActivatableVector, ButtonRowIconVector, LabelVisibilityVector, SwitchRowNotifyVector, SwitchRowStep, WindowTitleStep, WindowTitleVector, } from './action-row.js';
+export { BANNER_BUTTON_STYLE_PARSE_VECTORS, BANNER_BUTTON_STYLE_VECTORS, BANNER_BUTTON_TEXT_VECTORS, BANNER_BUTTON_VISIBLE_VECTORS, BANNER_DEFAULT_VECTORS, } from './banner.js';
+export type { BannerButtonStyleParseVector, BannerButtonStyleVector, BannerButtonTextVector, BannerButtonVisibleVector, BannerDefaultVector, } from './banner.js';
+export { BUTTON_CONTENT_DEFAULT_VECTORS, BUTTON_CONTENT_ELLIPSIZE_VECTORS, BUTTON_CONTENT_ICON_VECTORS, BUTTON_CONTENT_LABEL_VECTORS, BUTTON_CONTENT_STYLE_TARGET_VECTORS, BUTTON_CONTENT_TEXT_VECTORS, } from './button-content.js';
+export type { ButtonContentDefaultVector, ButtonContentEllipsizeVector, ButtonContentIconVector, ButtonContentLabelVector, ButtonContentStyleTargetVector, ButtonContentTextVector, } from './button-content.js';
+export { RADIO_GROUP_VECTORS } from './checks.js';
+export type { RadioGroupStep, RadioGroupVector } from './checks.js';
+export { COMBO_SELECTION_VECTORS } from './rows.js';
+export type { ComboSelectionStep, ComboSelectionVector } from './rows.js';
+export { VIEW_STACK_ICON_NAME_VECTORS, VIEW_STACK_PAGE_VECTORS, VIEW_STACK_VECTORS } from './view-stack.js';
+export type { ViewStackIconNameVector, ViewStackPageDescriptorVector, ViewStackVector, ViewStackVectorChange, ViewStackVectorOp, ViewStackVectorPage, } from './view-stack.js';
+export { NAVIGATION_VIEW_VECTORS, collectNavigationState, navigationEventLog, runNavigationSteps, } from './navigation-view.js';
+export type { ExpectedNavigationChange, ExpectedPageState, NavigationEventRecord, NavigationExpectation, NavigationPageId, NavigationStateCheck, NavigationStep, NavigationStepOutcome, NavigationVector, NavigationVectorAdapter, } from './navigation-view.js';
+export { SIDEBAR_ACTIVATION_VECTORS, SIDEBAR_CLAMP_VECTORS, SIDEBAR_FILTER_VECTORS, SIDEBAR_ITEMS_CHANGED_VECTORS, SIDEBAR_ITEM_FLAG_VECTORS, SIDEBAR_MODEL_VECTORS, SIDEBAR_MODE_VECTORS, } from './sidebar.js';
+export type { SidebarActivationVector, SidebarClampVector, SidebarFilterVector, SidebarItemFlagsVector, SidebarItemsChangedVector, SidebarModeVector, SidebarModelVector, } from './sidebar.js';
+export { ENTRY_MAX_LENGTH_VECTORS, ENTRY_ROW_ACTIVATION_VECTORS, ENTRY_ROW_GUARD_VECTORS, ENTRY_ROW_STATE_VECTORS, ENTRY_TEXT_LENGTH_VECTORS, PASSWORD_ENTRY_ROW_VECTORS, PASSWORD_REVEAL_GUARD_VECTORS, } from './entry-row.js';
+export type { EntryMaxLengthVector, EntryRowActivationVector, EntryRowGuardVector, EntryRowStateVector, EntryRowStep, EntryTextLengthVector, PasswordEntryRowStep, PasswordEntryRowVector, PasswordRevealGuardVector, } from './entry-row.js';
+export { ADW_LENGTH_UNIT_VECTORS, GLIB_CLAMP_VECTORS, NATURAL_SIDEBAR_WIDTH_VECTORS, NAVIGATION_ACTION_VECTORS, NAVIGATION_SPLIT_VIEW_LAYOUT_VECTORS, NAVIGATION_STACK_VECTORS, OVERLAY_COLLAPSE_VECTORS, OVERLAY_SPLIT_VIEW_LAYOUT_VECTORS, OVERLAY_SWIPE_AREA_VECTORS, OVERLAY_SWIPE_CANCEL_VECTORS, OVERLAY_SWIPE_RELEASE_VECTORS, OVERLAY_SWIPE_SNAP_POINT_VECTORS, OVERLAY_SWIPE_START_VECTORS, SIDEBAR_BOUNDS_VECTORS, SIDEBAR_WIDTH_VECTORS, SPLIT_VIEW_MEASURE_VECTORS, TAGS_CONFLICT_VECTORS, } from './split-view.js';
+export type { AdwLengthUnitVector, GlibClampVector, NaturalSidebarWidthVector, NavigationActionVector, NavigationLayoutVector, NavigationStackVector, OverlayCollapseVector, OverlayLayoutVector, OverlaySplitViewSnapshot, SidebarBoundsVector, SidebarWidthVector, SplitViewMeasureVector, SwipeAreaVector, SwipeCancelVector, SwipeReleaseVector, SwipeSnapPointVector, SwipeStartVector, TagsConflictVector, } from './split-view.js';
+export { MENU_BUTTON_DIRECTION_VECTORS, SPLIT_BUTTON_CONTENT_VECTORS, SPLIT_BUTTON_DIRECTION_VECTORS, SPLIT_BUTTON_DROPDOWN_VECTORS, SPLIT_BUTTON_MENU_ACTIVATION_VECTORS, SPLIT_BUTTON_MENU_PARSE_VECTORS, SPLIT_BUTTON_ROOT_STATE_VECTORS, SPLIT_BUTTON_STYLE_CLASS_VECTORS, SPLIT_BUTTON_TOOLTIP_VECTORS, } from './split-button.js';
+export type { SplitButtonContentStep, SplitButtonContentVector, SplitButtonDirectionVector, SplitButtonDropdownVector, SplitButtonMenuActivationVector, SplitButtonMenuParseVector, SplitButtonRootStateVector, SplitButtonStyleClassVector, SplitButtonTooltipVector, } from './split-button.js';
+export { INLINE_TOGGLE_VECTORS, INLINE_TOOLTIP_VECTORS, VIEW_SWITCHER_BADGE_VECTORS, VIEW_SWITCHER_BAR_REVEAL_VECTORS, VIEW_SWITCHER_BAR_VECTORS, VIEW_SWITCHER_BUTTON_VECTORS, VIEW_SWITCHER_BUTTON_VISIBILITY_VECTORS, VIEW_SWITCHER_DRAG_VECTORS, VIEW_SWITCHER_ICON_VECTORS, VIEW_SWITCHER_MNEMONIC_VECTORS, VIEW_SWITCHER_REBUILD_VECTORS, VIEW_SWITCHER_SELECTION_VECTORS, createViewSwitcherClock, } from './view-switcher.js';
+export type { ExpectedInlineToggle, ExpectedViewSwitcherButton, InlineToggleVector, InlineTooltipVector, MnemonicVector, ViewSwitcherBadgeVector, ViewSwitcherBarRevealVector, ViewSwitcherBarSnapshot, ViewSwitcherBarStep, ViewSwitcherBarVector, ViewSwitcherButtonVector, ViewSwitcherButtonVisibilityVector, ViewSwitcherClock, ViewSwitcherDragStep, ViewSwitcherDragVector, ViewSwitcherIconVector, ViewSwitcherRebuildVector, ViewSwitcherSelectionVector, ViewSwitcherVectorChange, ViewSwitcherVectorOp, ViewSwitcherVectorPage, } from './view-switcher.js';
+export { TABS_REVEALED_VECTORS, TAB_CLOSE_VISIBLE_VECTORS, TAB_DESCENDANT_VECTORS, TAB_ICON_STATE_VECTORS, TAB_PAGE_DESCRIPTOR_VECTORS, TAB_SUCCESSOR_VECTORS, TAB_TOOLTIP_VECTORS, TAB_VIEW_VECTORS, applyTabViewOp, seedTabViewPages, tabViewClosing, tabViewOrder, } from './tab-view.js';
+export type { TabCloseVisibleVector, TabDescendantVector, TabIconStateVector, TabPageDescriptorVector, TabSuccessorVector, TabTooltipVector, TabViewVector, TabViewVectorHandler, TabViewVectorOp, TabViewVectorPage, TabViewVectorPagesChange, TabViewVectorSelection, TabViewVectorTarget, TabsRevealedVector, } from './tab-view.js';
+export { CAROUSEL_CLAMP_VECTORS, CAROUSEL_NAVIGATE_VECTORS, CAROUSEL_PAGE_AT_POSITION_VECTORS, CAROUSEL_PAGE_LIST_VECTORS, CAROUSEL_PROPERTY_DEFAULT_VECTORS, CAROUSEL_RANGE_VECTORS, CAROUSEL_REORDER_SHIFT_VECTORS, CAROUSEL_REVEAL_VECTORS, CAROUSEL_SIZES_FROM_SNAP_POINTS_VECTORS, CAROUSEL_SNAP_POINT_VECTORS, CAROUSEL_WHEEL_LOCKOUT_VECTORS, CAROUSEL_WHEEL_VECTORS, } from './carousel.js';
+export type { CarouselClampVector, CarouselNavigateVector, CarouselPageAtPositionVector, CarouselPageListVector, CarouselPageOp, CarouselPropertyDefaultVector, CarouselRangeVector, CarouselReorderShiftVector, CarouselRevealOp, CarouselRevealVector, CarouselSizesFromSnapPointsVector, CarouselSnapPointVector, CarouselStateSnapshot, CarouselWheelLockoutStep, CarouselWheelLockoutVector, CarouselWheelVector, } from './carousel.js';
+export { DATA_GRID_CELL_TEXT_VECTORS, DATA_GRID_COLUMN_CLASS_VECTORS, DATA_GRID_COLUMN_NORMALIZE_VECTORS, DATA_GRID_INTERACTIVE_VECTORS, DATA_GRID_TRACK_VECTORS, DATA_GRID_VARIANT_VECTORS, } from './data-grid.js';
+export type { DataGridCellTextVector, DataGridColumnClassVector, DataGridColumnNormalizeVector, DataGridInteractiveVector, DataGridTrackVector, DataGridVariantVector, } from './data-grid.js';
+export { CASE_FOLD_VECTORS, MAKE_COMPARABLE_VECTORS, PREFERENCES_GROUP_HEADER_VECTORS, PREFERENCES_SEARCH_PAGES, PREFERENCES_SEARCH_VECTORS, ROW_MATCH_VECTORS, SEARCH_CORPUS_VECTORS, SEARCH_ROW_SUBTITLE_VECTORS, STRIP_MARKUP_VECTORS, STRIP_MNEMONIC_VECTORS, } from './preferences.js';
+export type { CaseFoldVector, MakeComparableVector, PreferencesGroupHeaderVector, PreferencesSearchExpectation, PreferencesSearchVector, RowMatchVector, SearchCorpusVector, SearchRowSubtitleVector, StripMarkupVector, StripMnemonicVector, } from './preferences.js';
+export { CLAMP_ALLOCATE_VECTORS, CLAMP_CHILD_SIZE_VECTORS, CLAMP_PROPERTY_VECTORS, CLAMP_SIZE_FROM_CHILD_VECTORS, CLAMP_THRESHOLD_VECTORS, SPINNER_GEOMETRY_VECTORS, SPINNER_SIZE_VECTORS, TOOLBAR_VIEW_ALLOCATE_VECTORS, TOOLBAR_VIEW_CLASS_VECTORS, TOOLBAR_VIEW_CONTENT_FOR_SIZE_VECTORS, TOOLBAR_VIEW_MEASURE_VECTORS, } from './chrome.js';
+export type { ClampAllocateVector, ClampChildSizeVector, ClampPropertyVector, ClampSizeFromChildVector, ClampThresholdsVector, SpinnerGeometryVector, SpinnerSizeVector, ToolbarViewAllocateVector, ToolbarViewClassVector, ToolbarViewContentForSizeVector, ToolbarViewMeasureVector, } from './chrome.js';
+export { BOTTOM_SHEET_CLOSE_VECTORS, BOTTOM_SHEET_PRESENTATION_VECTORS, runBottomSheetSteps } from './dialog.js';
+export type { BottomSheetCloseVector, BottomSheetPresentationAdapter, BottomSheetPresentationStep, BottomSheetPresentationVector, } from './dialog.js';
+export { POPOVER_KEY_VECTORS, POPOVER_SURFACE_VECTORS } from './popover.js';
+export type { PopoverKeyVector, PopoverSurfaceVariant, PopoverSurfaceVector } from './popover.js';
+export { ADW_WRAP_BOX_DEFAULT_ALIGN, ADW_WRAP_BOX_DEFAULT_JUSTIFY, ADW_WRAP_BOX_DEFAULT_JUSTIFY_LAST_LINE, ADW_WRAP_BOX_DEFAULT_SPACING, WRAP_BOX_LINE_VECTORS, WRAP_BOX_SPACING_NOTIFY_VECTORS, WRAP_BOX_SPACING_VECTORS, } from './wrap-box.js';
+export type { WrapBoxJustify, WrapBoxLineLayout, WrapBoxLineVector, WrapBoxSpacingNotifyVector, WrapBoxSpacingVector, } from './wrap-box.js';

package/lib/types/conformance/navigation-view.d.ts

@@ -0,0 +1,235 @@
+import type { AdwNavigationPageProps, NavigationChangeReason, NavigationDiagnostic, NavigationShortcutResult } from '../navigation-view.js';
+/** An opaque page label. A driver maps it to whatever page handle its renderer uses. */
+export type NavigationPageId = string;
+/** One mutation in a vector script. Mirrors the `NavigationViewState` surface 1:1. */
+export type NavigationStep = {
+    op: 'add';
+    page: NavigationPageId;
+    props?: AdwNavigationPageProps;
+    expect?: boolean;
+} | {
+    op: 'remove';
+    page: NavigationPageId;
+    expect?: boolean;
+} | {
+    op: 'push';
+    page: NavigationPageId;
+    props?: AdwNavigationPageProps;
+    expect?: boolean;
+} | {
+    op: 'pushByTag';
+    tag: string;
+    expect?: boolean;
+} | {
+    op: 'pop';
+    expect?: boolean;
+} | {
+    op: 'popToPage';
+    page: NavigationPageId;
+    expect?: boolean;
+} | {
+    op: 'popToTag';
+    tag: string;
+    expect?: boolean;
+} | {
+    op: 'replace';
+    pages: readonly (NavigationPageId | null)[];
+    /** Registration properties for pages the view has not seen yet. */
+    props?: Readonly<Record<NavigationPageId, AdwNavigationPageProps>>;
+} | {
+    op: 'replaceWithTags';
+    tags: readonly string[];
+} | {
+    op: 'setTag';
+    page: NavigationPageId;
+    tag: string | null;
+    expect?: boolean;
+} | {
+    op: 'setTitle';
+    page: NavigationPageId;
+    title: string;
+    expect?: boolean;
+} | {
+    op: 'setCanPop';
+    page: NavigationPageId;
+    canPop: boolean;
+    expect?: boolean;
+} | {
+    op: 'setAnimateTransitions';
+    value: boolean;
+} | {
+    op: 'setPopOnEscape';
+    value: boolean;
+} | {
+    op: 'popFromShortcut';
+    expect?: NavigationShortcutResult;
+} | {
+    op: 'popFromEscape';
+    expect?: NavigationShortcutResult;
+} | {
+    op: 'finishTransition';
+    expect?: readonly NavigationPageId[];
+};
+/** One emitted `NavigationStackChange`, with page handles written as ids. */
+export interface ExpectedNavigationChange {
+    reason: NavigationChangeReason;
+    stack: readonly NavigationPageId[];
+    visiblePage: NavigationPageId | null;
+    visiblePageTag: string | null;
+    previousVisiblePage: NavigationPageId | null;
+    popped: readonly NavigationPageId[];
+    removed: readonly NavigationPageId[];
+    removeAfterTransition: NavigationPageId | null;
+    animate: boolean;
+    pop: boolean;
+    tagNotify: boolean;
+}
+/** Per-page state a row may pin down. */
+export interface ExpectedPageState {
+    page: NavigationPageId;
+    /** Whether the view still knows the page at all. */
+    registered?: boolean;
+    tag?: string | null;
+    title?: string;
+    canPop?: boolean;
+    /** Core-only: whether the page is DYNAMIC (destroyed when popped). */
+    removeOnPop?: boolean;
+}
+/** What must hold once a script has run. Every field is optional. */
+export interface NavigationExpectation {
+    /** The navigation stack, bottom-first. */
+    stack?: readonly NavigationPageId[];
+    /** Every registered page, in registration order. */
+    pages?: readonly NavigationPageId[];
+    visiblePage?: NavigationPageId | null;
+    visiblePageTag?: string | null;
+    depth?: number;
+    animateTransitions?: boolean;
+    popOnEscape?: boolean;
+    /** `AdwBackButton` visibility. */
+    canGoBack?: boolean;
+    /** `AdwBackButton`'s tooltip, `null` when there is no back button. */
+    backButtonTooltip?: string | null;
+    /** `find_page(tag)` results, as `[tag, page-or-null]` pairs (`''` is a legal tag). */
+    findPage?: readonly (readonly [string, NavigationPageId | null])[];
+    /** `get_previous_page(page)` results, as `[page, previous-or-null]` pairs. */
+    previousPage?: readonly (readonly [NavigationPageId, NavigationPageId | null])[];
+    pageState?: readonly ExpectedPageState[];
+    /** Every diagnostic the script must have produced, in order. */
+    diagnostics?: readonly NavigationDiagnostic[];
+    /** Every change the script must have emitted, in order. */
+    changes?: readonly ExpectedNavigationChange[];
+}
+/** One conformance row. */
+export interface NavigationVector {
+    /** Stable name — also the test title. */
+    name: string;
+    /** What rule the row pins down. */
+    rule: string;
+    /** The mutations to run, in order. */
+    steps: readonly NavigationStep[];
+    /** What must hold afterwards. */
+    expect: NavigationExpectation;
+    /** The C function + line the row is derived from. */
+    derivedFrom: string;
+}
+/**
+ * The navigation-view conformance table.
+ *
+ * Grouped by the C entry point each row exercises: registry (`add`/`remove`/
+ * `find_page`), stack (`push`/`pop`/`pop_to_*`/`replace`), page properties
+ * (`set_tag`/`set_title`/`set_can_pop`), the transition lifecycle, and the
+ * `AdwBackButton` + shortcut derivations that live in `adw-back-button.c` and
+ * `pop_shortcut_cb`.
+ */
+export declare const NAVIGATION_VIEW_VECTORS: ReadonlyArray<NavigationVector>;
+/** Everything a suite must be able to do to its widget to run a vector. */
+export interface NavigationVectorAdapter<P> {
+    /** The handle for `id`, created on first mention and stable afterwards. */
+    page(id: NavigationPageId): P;
+    /** The id of a handle — `null` for `null`/`undefined`. */
+    idOf(page: P | null | undefined): NavigationPageId | null;
+    /**
+     * Whether this target actually DEFERS the destroy of the outgoing page to
+     * {@link finishTransition}. Only the core does; both renderers settle at once
+     * (their transition is CSS, or nothing at all), so their `finishTransition`
+     * has nothing left to hand back. The step still RUNS everywhere — it is what
+     * makes the final state comparable — but its return value is asserted only
+     * where deferral is real.
+     */
+    defersTransition: boolean;
+    add(page: P, props?: AdwNavigationPageProps): boolean;
+    remove(page: P): boolean;
+    push(page: P, props?: AdwNavigationPageProps): boolean;
+    pushByTag(tag: string): boolean;
+    pop(): boolean;
+    popToPage(page: P): boolean;
+    popToTag(tag: string): boolean;
+    replace(pages: readonly (P | null)[], props?: (page: P) => AdwNavigationPageProps | undefined): void;
+    replaceWithTags(tags: readonly string[]): void;
+    setTag(page: P, tag: string | null): boolean;
+    setTitle(page: P, title: string): boolean;
+    setCanPop(page: P, canPop: boolean): boolean;
+    setAnimateTransitions(value: boolean): void;
+    setPopOnEscape(value: boolean): void;
+    popFromShortcut(): NavigationShortcutResult;
+    popFromEscape(): NavigationShortcutResult;
+    finishTransition(): readonly P[];
+    stack(): readonly P[];
+    pages(): readonly P[];
+    visiblePage(): P | null;
+    visiblePageTag(): string | null;
+    depth(): number;
+    animateTransitions(): boolean;
+    popOnEscape(): boolean;
+    canGoBack(): boolean;
+    backButtonTooltip(): string | null;
+    findPage(tag: string): P | null;
+    getPreviousPage(page: P): P | null;
+    /**
+     * Per-page state. A renderer omits the fields it cannot report — `removeOnPop`
+     * is core-only, and the rows that pin it down are therefore checked by the core
+     * suite alone. Its renderer-visible consequence (the page disappearing from
+     * {@link pages}) is asserted everywhere.
+     */
+    pageState(page: P): Partial<Omit<ExpectedPageState, 'page'>>;
+}
+/** What one executed step produced, ready to be compared. */
+export interface NavigationStepOutcome {
+    /** Position in the script, for a readable failure. */
+    index: number;
+    step: NavigationStep;
+    /** The mutator's return value, with page handles reduced to ids. */
+    result: unknown;
+    /** What the row demands, or `undefined` when it does not care. */
+    expected: unknown;
+}
+/** Run a vector's script against `adapter`, returning one outcome per step. */
+export declare function runNavigationSteps<P>(steps: readonly NavigationStep[], adapter: NavigationVectorAdapter<P>): NavigationStepOutcome[];
+/** One state comparison a row asked for. */
+export interface NavigationStateCheck {
+    /** What is being compared, for the failure message. */
+    label: string;
+    actual: unknown;
+    expected: unknown;
+}
+/**
+ * Reduce a row's {@link NavigationExpectation} to the comparisons `adapter` can
+ * actually make, so every suite asserts the same fields in the same way.
+ */
+export declare function collectNavigationState<P>(expect: NavigationExpectation, adapter: NavigationVectorAdapter<P>): NavigationStateCheck[];
+/** A GObject-style signal a renderer re-emits, reduced to what a suite can observe. */
+export interface NavigationEventRecord {
+    /** The `AdwNavigationView` signal name, or the `visible-page` property notification. */
+    type: 'pushed' | 'popped' | 'replaced' | 'notify::visible-page';
+    /** The page the signal is about — `null` for `replaced` and for an emptied view. */
+    page: NavigationPageId | null;
+}
+/**
+ * The signal sequence a row's {@link NavigationExpectation.changes} must produce,
+ * so the renderer suites can assert their event log without re-deriving the
+ * mapping: `'add'`/`'push'` → `::pushed`, `'pop'` → one `::popped` per popped page
+ * (top-first), `'replace'` → `::replaced`, and `visible-page` notifies exactly when
+ * the visible page actually changed (switch_page:925).
+ */
+export declare function navigationEventLog(changes: readonly ExpectedNavigationChange[]): NavigationEventRecord[];

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

@@ -0,0 +1,56 @@
+import type { PopoverKeyContext, PopoverKeyResolution } from '../popover.js';
+/** Which popover surface a {@link PopoverSurfaceVector} describes. */
+export type PopoverSurfaceVariant = 
+/** A bare popover — `popover > contents`. */
+'plain'
+/** A menu popover — `popover.menu > contents` + its item box. */
+ | 'menu'
+/** One menu row — `modelbutton`. */
+ | 'menu-item';
+/** One popover surface expectation, derived from the vendored stylesheet. */
+export interface PopoverSurfaceVector {
+    /** The surface under test. */
+    variant: PopoverSurfaceVariant;
+    /** Inner inset in px — where the whitespace around the content actually comes from. */
+    padding: number;
+    /** Corner radius in px. */
+    borderRadius: number;
+    /**
+     * The `box-shadow` layers' GEOMETRY, in the spelling `getComputedStyle`
+     * returns (`0px`, not `0`) so a renderer can substring-match the computed
+     * value without re-implementing colour serialisation. Empty when the node
+     * casts no shadow.
+     *
+     * The COUNT is the load-bearing part: the split button shipped two layers
+     * where libadwaita has three.
+     */
+    shadow: readonly string[];
+    /** The libadwaita selector that WINS the cascade for these values. */
+    selector: string;
+    /** Where it is vendored, with lines. */
+    source: string;
+    /** Why this row exists. */
+    rule: string;
+}
+/** Popover surface metrics (_popovers.scss:13-21, _menus.scss:58-66, :134-138). */
+export declare const POPOVER_SURFACE_VECTORS: ReadonlyArray<PopoverSurfaceVector>;
+/** One `resolvePopoverKey` expectation. */
+export interface PopoverKeyVector {
+    /** `KeyboardEvent.key`. */
+    key: string;
+    /** The list state it is resolved against. */
+    context: PopoverKeyContext;
+    /** What the renderer must do. */
+    expected: PopoverKeyResolution;
+    /** Why this row exists. */
+    rule: string;
+}
+/**
+ * `resolvePopoverKey` — the wrap arithmetic `adw-menu-button.ts` and
+ * `adw-drop-down.ts` each carried a copy of, reconciled.
+ *
+ * The rows that matter are the ones where the copies were WRONG rather than
+ * merely duplicated: ArrowUp from an unfocused list (both computed `n - 2`), and
+ * Home/End while a search entry owns the caret (the drop-down stole both).
+ */
+export declare const POPOVER_KEY_VECTORS: ReadonlyArray<PopoverKeyVector>;