@gjsify/adwaita-nativescript 0.30.0 → 0.32.0

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

@@ -0,0 +1,159 @@
+import { ADW_BANNER_BUTTON_STYLE_CLASSES, ADW_BANNER_DEFAULTS, ADW_CLAMP_SIZE_CLASSES, ADW_SPINNER_MIN_SIZE, ADW_TOOLBAR_BAR_CLASSES, ADW_TOOLBAR_VIEW_CLASSES, ADW_TOOLBAR_VIEW_DEFAULTS, type AdwBannerButtonStyle, type AdwBannerProps, type AdwClampSizeClass, type AdwToolbarStyle } from '@gjsify/adwaita-core';
+export { ADW_BANNER_BUTTON_STYLE_CLASSES, ADW_BANNER_DEFAULTS, ADW_CLAMP_SIZE_CLASSES, ADW_SPINNER_MIN_SIZE, ADW_TOOLBAR_BAR_CLASSES, ADW_TOOLBAR_VIEW_CLASSES, ADW_TOOLBAR_VIEW_DEFAULTS, };
+export type { AdwBannerButtonStyle, AdwClampSizeClass, AdwToolbarStyle };
+/** `Adw.Clamp:maximum-size` default, in DIPs. */
+export declare const DEFAULT_CLAMP_MAX_SIZE: number;
+/** `Adw.Clamp:tightening-threshold` default, in DIPs. */
+export declare const DEFAULT_CLAMP_TIGHTENING_THRESHOLD: number;
+/** The two clamp properties, as the widget holds them. */
+export interface ClampProps {
+    /** How wide the child may ever get. Defaults to libadwaita's 600. */
+    maximumSize: number;
+    /** Where the eased tightening starts. Defaults to libadwaita's 400. */
+    tighteningThreshold: number;
+}
+/** The property defaults a fresh clamp starts with. */
+export declare function defaultClampProps(): ClampProps;
+/**
+ * Normalise one clamp property, keeping a nonsense value out of the layout.
+ *
+ * Delegates to core so the NativeScript widget and the browser element agree on
+ * the three inputs they used to answer differently — `0` (valid, and NOT the
+ * default), a non-numeric value (never reaches the layout, so the DEFAULT
+ * applies), and a negative (clamped to the range floor).
+ */
+export declare function normalizeClampProp(value: number | string | null | undefined, fallback: number): number;
+/** What one clamp layout pass tells the widget to do with its child. */
+export interface ClampAllocationForWidth {
+    /**
+     * The child's `width` — a DIP number, or `'auto'` while the clamp has not
+     * been laid out yet, which leaves the child at its natural size instead of
+     * pinning it to a width derived from a container of size zero.
+     */
+    width: number | 'auto';
+    /** The `small`/`medium`/`large` class the child carries, or `null` before the first layout. */
+    sizeClass: AdwClampSizeClass | null;
+}
+/**
+ * The child width and size class for a clamp `availableWidth` DIPs wide.
+ *
+ * `availableWidth <= 0` means NativeScript has not laid the view out yet — it
+ * reports a zero size before the first pass — and the honest answer there is
+ * "do not constrain", the same shape `sidebarWidthFor` uses for the same reason.
+ * Anything else runs libadwaita's curve, so a narrow container yields a narrow
+ * child rather than the maximum.
+ *
+ * `childMin`/`childNat` are 0: NativeScript does not expose a child's measured
+ * minimum before layout, and `lower = MAX (…, child_min)` only ever RAISES the
+ * child's width — an NS child whose own content is wider than the clamp already
+ * overflows rather than being cut, so nothing is lost by leaving it out.
+ */
+export declare function clampAllocationFor(availableWidth: number, props: ClampProps): ClampAllocationForWidth;
+/**
+ * Default spinner diameter in DIPs — `Adw.Spinner`'s measured natural size,
+ * which equals its minimum (adw-spinner.c:78-81).
+ *
+ * Replaces an invented 32: nothing in libadwaita produces that number.
+ */
+export declare const DEFAULT_SPINNER_SIZE = 16;
+/**
+ * The diameter an `ActivityIndicator` is sized to for a requested `size`.
+ *
+ * The platform indicator fills its view, so the view IS the ring: floored at the
+ * measured minimum 16 and capped at Adwaita's 64, with the odd-size flooring
+ * (`31` draws a 30 DIP ring) coming from the paintable rather than from here.
+ */
+export declare function spinnerDiameter(value: number | string | null | undefined): number;
+/** The four toolbar-view properties the style classes are derived from. */
+export interface ToolbarViewProps {
+    /** `top-bar-style`. */
+    topBarStyle: AdwToolbarStyle;
+    /** `bottom-bar-style`. */
+    bottomBarStyle: AdwToolbarStyle;
+    /** `extend-content-to-top-edge`. */
+    extendContentToTopEdge: boolean;
+    /** `extend-content-to-bottom-edge`. */
+    extendContentToBottomEdge: boolean;
+}
+/** The property defaults a fresh toolbar view starts with. */
+export declare function defaultToolbarViewProps(): ToolbarViewProps;
+/** The three `className` strings a toolbar view distributes over its own node and its two bar boxes. */
+export interface ToolbarViewClassNames {
+    /** `className` for the view. */
+    view: string;
+    /** `className` for the top-bar box. */
+    topBar: string;
+    /** `className` for the bottom-bar box. */
+    bottomBar: string;
+}
+/**
+ * Swap the classes a widget MANAGES on a NativeScript `className`, leaving every
+ * other token in place.
+ *
+ * NS views carry a space-separated string rather than a `classList`, so there is
+ * no `toggle`: the whole string is rewritten on every derivation. Composing from
+ * a fixed base instead would silently drop what a CONSUMER added — the storybook
+ * appends `sb-sidebar-pane` to an `AdwToolbarView`, and a re-style would have
+ * taken it away again.
+ */
+export declare function replaceClasses(current: string, managed: readonly string[], next: readonly string[]): string;
+/** The child `className` for a clamp allocation — the size class, and nothing else touched. */
+export declare function clampChildClassName(current: string, sizeClass: AdwClampSizeClass | null): string;
+/** The five banner properties, as the widget holds them. */
+export type BannerProps = AdwBannerProps;
+/**
+ * The property defaults a fresh banner starts with — libadwaita's, not this
+ * port's.
+ *
+ * This is the whole reason the banner is here. `AdwBanner` used to initialise
+ * `_revealed = true` AND never write `visibility` in its constructor, so a
+ * banner put itself on screen on a device while the same markup stayed hidden in
+ * the browser. `Adw.Banner:revealed` defaults to FALSE (adw-banner.c:456-459) —
+ * "Banners are hidden by default" (:47) — and `use-markup` to TRUE (:422-425),
+ * which the port had backwards as well.
+ */
+export declare function defaultBannerProps(): BannerProps;
+/**
+ * The text the NS title `Label` is given.
+ *
+ * `Adw.Banner`'s title is Pango markup by default (:422-425) and the NS CSS
+ * subset has no inline-markup layer at all, so the honest reduction is the
+ * markup's PLAIN TEXT: `<b>Metered</b>` reads `Metered`, which is what GTK
+ * paints minus the weight, where writing the raw string would paint the tags.
+ * Unparseable markup keeps the raw string, reproducing the C fallback that
+ * {@link stripMarkup} already models.
+ */
+export declare function bannerTitleText(title: string, useMarkup: boolean): string;
+/**
+ * The NS `visibility` for a `revealed` value.
+ *
+ * `Adw.Banner` reveals through a `GtkRevealer` (:817); the NS subset has no
+ * revealer, so `collapse` — which takes the view out of layout entirely — is the
+ * closest thing to a fully retracted one.
+ */
+export declare function bannerVisibility(revealed: boolean): 'visible' | 'collapse';
+/**
+ * The `className` for the banner button — the managed `button-style` class
+ * swapped in, every other token left alone.
+ *
+ * `adw_banner_set_button_style` only ever adds or removes `suggested-action`
+ * (:766, :769); it never rewrites the button's class list, and neither does
+ * this.
+ */
+export declare function bannerButtonClassName(current: string, style: AdwBannerButtonStyle): string;
+/**
+ * The `className` strings for a toolbar view, given its CURRENT ones, its
+ * properties and the measured bar heights.
+ *
+ * `topBarHeight`/`bottomBarHeight` are the ALLOCATED heights, exactly as
+ * `update_undershoots` reads `gtk_widget_get_height (self->top_bar)` — a bar box
+ * that was never given a height fades nothing, so it gets no undershoot.
+ */
+export declare function toolbarViewClassNames(current: {
+    view: string;
+    topBar: string;
+    bottomBar: string;
+}, props: ToolbarViewProps, heights: {
+    topBarHeight: number;
+    bottomBarHeight: number;
+}): ToolbarViewClassNames;

package/lib/types/widgets/data-grid-model.d.ts

@@ -0,0 +1,104 @@
+import type { AdwDataGridRowVariant, DataGridTrack } from '@gjsify/adwaita-core';
+import type { GridUnitType } from '@nativescript/core';
+/** The two numbers a NativeScript `ItemSpec` is constructed from. */
+export interface DataGridItemSpec {
+    /** The `ItemSpec` value: a star weight, a pixel length, or 1 for `auto`. */
+    value: number;
+    /** The `GridUnitType` — `'star'`, `'pixel'` or `'auto'`. */
+    type: GridUnitType;
+}
+/** The class the header row's background carries. */
+export declare const DATA_GRID_HEADER_ROW_CLASS = "adw-data-grid-row header";
+/** The class a section row's single spanning cell carries. */
+export declare const DATA_GRID_SECTION_CELL_CLASS = "adw-data-grid-cell align-start section-cell";
+/** The class a header CELL carries, on top of its column's own classes. */
+export declare const DATA_GRID_HEADER_CELL_CLASS = "header-cell";
+/**
+ * A fixed track's CSS length in device-independent pixels, or `null` when this
+ * renderer cannot resolve it.
+ *
+ * `DataGridTrack`'s `fixed` kind carries the author's `width` string verbatim,
+ * because only a CSS engine can resolve every unit CSS has. NativeScript has
+ * exactly one length unit — the DIP — and its own stylesheet subset writes it as
+ * a bare number (`min-height: 34`, `padding: 5 10 5 10`), so BOTH `'80px'` and
+ * `'80'` are read as 80 here and everything else (`6rem`, `50%`, `calc(...)`)
+ * is unresolvable and falls back to a content-sized track.
+ *
+ * That bare-number acceptance is a deliberate divergence from the browser, where
+ * `width: '80'` is not a valid CSS length and takes the WHOLE
+ * `grid-template-columns` declaration down with it. Falling back to `auto` for
+ * one column is the smaller failure, and refusing a spelling that is valid in
+ * this renderer's own stylesheet would be the surprising half.
+ *
+ * A negative or non-finite length is rejected rather than clamped: `ItemSpec`
+ * refuses one, and a column silently pinned to 0 reads as a missing column.
+ */
+export declare function parseDataGridWidth(css: string): number | null;
+/**
+ * The `ItemSpec` numbers for one column track.
+ *
+ * The four track kinds map onto the three `GridUnitType`s:
+ *   - `slack` → `1 star`. The slack column takes what the fixed and content
+ *     columns leave, which is what `minmax(0px, 1fr)` does in the browser.
+ *   - `flex` → `<weight> star`, the same proportional share `<weight>fr` gives.
+ *   - `fixed` → `<px> pixel` when {@link parseDataGridWidth} can read the length,
+ *     `auto` when it cannot.
+ *   - `auto` → `1 auto` (the value is ignored for an auto track).
+ *
+ * A `flex` weight of 0 becomes a ZERO-WIDTH PIXEL track rather than a star one:
+ * `0fr` collapses the column in the browser, and `ItemSpec(0, 'star')` is not a
+ * spelling for that — a star weight is a divisor. Same for a negative or
+ * non-finite weight, which cannot mean anything a layout can honour.
+ */
+export declare function dataGridItemSpec(track: DataGridTrack): DataGridItemSpec;
+/**
+ * A stable key for a track list — what the widget re-declares its columns on.
+ *
+ * The precedent is `AdwViewSwitcherBar`, which rebuilds its buttons only when the
+ * page COUNT moves so that a selection change cannot replace the button under
+ * the user's finger. The same discipline applies here, with one difference the
+ * grid forces: a column list can change WITHOUT changing length — pinning a
+ * column's `width` on a narrow screen is exactly that — and a count guard would
+ * keep painting against the old tracks. So the guard is the tracks themselves,
+ * which is a strict superset: whenever the count moves the key moves too, and a
+ * repaint (new rows, a toggled `interactive`) never touches the columns.
+ */
+export declare function dataGridTracksKey(tracks: ReadonlyArray<DataGridTrack>): string;
+/**
+ * A stable key for the grid's SHAPE — what the widget rebuilds its views on.
+ *
+ * Rows and columns only, deliberately: every row is built with one cell per
+ * column whatever its variant, and a `section` row spans its first cell over the
+ * rest instead of dropping them. So changing a row's variant is a repaint, not a
+ * rebuild, and the cell views survive a data change of the same size.
+ */
+export declare function dataGridShapeKey(columnCount: number, rowCount: number): string;
+/**
+ * The classes a data row's background carries.
+ *
+ * The row background is a NativeScript-only node and this is why it exists: the
+ * browser paints the fill, the hairline rules and the hover affordance on the
+ * row ELEMENT, which is a real element there because it is a subgrid. Here the
+ * cells are direct children of the one grid, so a full-width `StackLayout`
+ * placed first at the same row — below the cells, spanning every column — is
+ * what carries them, plus the tap target and the press feedback.
+ *
+ * `interactive` is a class rather than a widget flag so the press-darken keys off
+ * it: `attachRowPressFeedback` is wired on EVERY data row, and a non-interactive
+ * one gets a `highlighted` pseudo-class that no stylesheet rule claims.
+ */
+export declare function dataGridRowClass(variant: AdwDataGridRowVariant, interactive: boolean): string;
+/**
+ * The classes a body cell carries: its column's own, plus the row's variant.
+ *
+ * The variant is repeated onto the CELL because of the same structural
+ * difference: the browser bolds a subtotal's figures with
+ * `.variant-subtotal .adw-data-grid-cell`, a DESCENDANT selector, and here the
+ * cell is not inside the row background — the two are siblings in one grid. So
+ * the row class cannot reach the cells and the cell has to say it itself.
+ *
+ * `normal` adds nothing: it is every row in a statement but the handful that
+ * carry emphasis, and a class the stylesheet has no rule for is only noise in
+ * the one place a reader looks when the emphasis is wrong.
+ */
+export declare function dataGridCellClass(columnClasses: ReadonlyArray<string>, variant: AdwDataGridRowVariant): string;

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

@@ -0,0 +1,88 @@
+import type { EntryRowRenderState, PasswordEntryRowRenderState } from '@gjsify/adwaita-core';
+/** The two NS visibility values the Adwaita widgets use — `collapse` takes no space. */
+export type NsVisibility = 'visible' | 'collapse';
+/** A view the render state shows or hides. */
+export interface ToggleableView {
+    visibility: string;
+}
+/** A view whose CSS class list the render state drives. */
+export interface ClassedView {
+    className: string;
+}
+/** The views an entry row paints, narrowed to what the render state touches. */
+export interface EntryRowViews {
+    /** The row itself — carries the `focused` / `empty` state classes (C:183-186). */
+    row: ClassedView;
+    /** The large placeholder title (`empty_title` in adw-entry-row.ui). */
+    emptyTitle: ToggleableView;
+    /** The small label above the value (`title` in adw-entry-row.ui). */
+    title: ToggleableView;
+    /** The editable field. */
+    field: {
+        text: string;
+        editable: boolean;
+    };
+    /** The trailing pencil — hidden AND desensitized independently (C:149-150). */
+    editIcon: ToggleableView & ClassedView & {
+        opacity: number;
+    };
+    /** The caps-lock warning slot. */
+    indicator: ToggleableView;
+    /** The apply button. */
+    applyButton: ToggleableView;
+}
+/** The views a password entry row adds. */
+export interface PasswordEntryRowViews {
+    /** The masked field. */
+    field: {
+        secure: boolean;
+    };
+    /** The peek toggle, whose `icon` takes an Adwaita symbolic SVG string. */
+    peekButton: {
+        icon: string;
+    };
+}
+/** Base class list of an entry row, before the state classes. */
+export declare const NS_ENTRY_ROW_CLASS = "adw-row adw-action-row adw-entry-row";
+/** Base class list of a password entry row. */
+export declare const NS_PASSWORD_ENTRY_ROW_CLASS = "adw-row adw-action-row adw-entry-row adw-password-entry-row";
+/** Class list of the trailing pencil. */
+export declare const NS_EDIT_ICON_CLASS = "adw-icon adw-entry-edit";
+/**
+ * Marker class for a desensitized part. NS has no insensitive state, so the
+ * class is only a styling hook — {@link NS_INSENSITIVE_OPACITY} is what the user
+ * actually sees.
+ */
+export declare const NS_INSENSITIVE_CLASS = "adw-insensitive";
+/** Opacity of a desensitized part (`gtk_widget_set_sensitive (…, FALSE)`, C:150). */
+export declare const NS_INSENSITIVE_OPACITY = 0.4;
+/** Map a boolean onto NativeScript's `visibility`. */
+export declare function nsVisibility(visible: boolean): NsVisibility;
+/**
+ * The row's class list for one render snapshot.
+ *
+ * `focused` is libadwaita's own class name — `text_state_flags_changed_cb` adds
+ * and removes it on the ROW node (adw-entry-row.c:183-186). `empty` has no C
+ * counterpart (GTK animates instead of styling), but the NS CSS subset cannot
+ * express `:focus-within` at all, so both states have to be reachable as classes
+ * or they are not reachable at all on this port.
+ */
+export declare function entryRowClassName(base: string, state: EntryRowRenderState): string;
+/**
+ * Paint one entry-row render snapshot.
+ *
+ * The two titles are the endpoints of libadwaita's cross-fade (C:433-439): GTK
+ * lerps between them over `EMPTY_ANIMATION_DURATION_MS`, NS swaps at
+ * `emptyTarget` because its CSS subset has no transform/animation.
+ */
+export declare function applyEntryRowState(views: EntryRowViews, state: EntryRowRenderState, base: string): void;
+/**
+ * The Adwaita symbolic SVG for a canonical peek icon name.
+ *
+ * The core names the icon the way the C does (`view-reveal-symbolic` /
+ * `view-conceal-symbolic`, adw-password-entry-row.c:68,73); this is the one
+ * place that maps a name onto the asset `@gjsify/adwaita-icons` ships.
+ */
+export declare function peekIconSvg(iconName: PasswordEntryRowRenderState['peekIconName']): string;
+/** Paint one password-entry-row render snapshot — `notify_visibility_cb` (C:62-81). */
+export declare function applyPasswordEntryRowState(views: PasswordEntryRowViews, state: PasswordEntryRowRenderState): void;

package/lib/types/widgets/icon-path.d.ts

@@ -31,6 +31,26 @@ export declare function extractIconPaths(svg: string): IconPath[];
  * `''` when the SVG carries no path data.
  */
 export declare function extractPathData(svg: string): string;
+/** A colour split into the 0..1 components UIKit and CoreGraphics take. */
+export interface IconColorComponents {
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+}
+/**
+ * Parse `#RGB` / `#RRGGBB` / `#AARRGGBB` into 0..1 components.
+ *
+ * Android does not need this — `android.graphics.Color.parseColor` takes the
+ * string directly — but UIKit has no hex constructor, so the iOS backend has to
+ * do the arithmetic. Note the ALPHA-FIRST order in the 8-digit form: that is the
+ * Android convention {@link SymbolicIconOptions.color} is documented in, and the
+ * two backends must read the same string the same way.
+ *
+ * Returns opaque black for anything unparsable, so a typo in a caller's colour
+ * yields a visible icon rather than an invisible one.
+ */
+export declare function parseHexColor(hex: string): IconColorComponents;
 /**
  * Space-separate the two single-digit ARC FLAGS (large-arc, sweep) in every
  * elliptical-arc command (`A`/`a`) of an SVG path-data string.

package/lib/types/widgets/icons.ios.d.ts

@@ -0,0 +1,13 @@
+import { ImageSource } from '@nativescript/core';
+import { type SymbolicIconOptions } from './icon-path.js';
+/**
+ * Render an Adwaita symbolic SVG to a native {@link ImageSource} on iOS, or
+ * `null` when the SVG has no path data / UIKit is unavailable.
+ *
+ * Drawn at `size` points × the screen scale so it stays crisp on Retina; place
+ * it in an `Image` sized `size`×`size` with `stretch:'aspectFit'`, exactly as on
+ * Android.
+ */
+export declare function renderSymbolicIcon(svg: string, options?: SymbolicIconOptions): ImageSource | null;
+export { ADWAITA_ICON_GRID, DEFAULT_ICON_COLOR, DEFAULT_ICON_COLOR_DARK, extractIconPaths, extractPathData, } from './icon-path.js';
+export type { IconPath, SymbolicIconOptions } from './icon-path.js';

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

@@ -6,8 +6,12 @@ export type { NotifyActiveEventData } from './adw-switch-row.js';
 export { AdwEntryRow, NOTIFY_TEXT } from './adw-entry-row.js';
 export type { NotifyTextEventData } from './adw-entry-row.js';
 export { AdwPasswordEntryRow } from './adw-password-entry-row.js';
+export { AdwEntry, ACTIVATE as ENTRY_ACTIVATE, NOTIFY_TEXT as NOTIFY_ENTRY_TEXT } from './adw-entry.js';
+export type { NotifyEntryTextEventData } from './adw-entry.js';
 export { AdwComboRow, ComboState, NOTIFY_SELECTED } from './adw-combo-row.js';
 export type { AdwComboOption, ComboStateChange, ComboStateListener, NotifySelectedEventData } from './adw-combo-row.js';
+export { AdwDropDown, NOTIFY_SELECTED as NOTIFY_DROP_DOWN_SELECTED } from './adw-drop-down.js';
+export type { NotifyDropDownSelectedEventData } from './adw-drop-down.js';
 export { AdwSpinRow, NOTIFY_VALUE, SpinState } from './adw-spin-row.js';
 export type { NotifyValueEventData, SpinStateChange, SpinStateListener } from './adw-spin-row.js';
 export { AdwSliderRow, NOTIFY_SLIDER_VALUE } from './adw-slider-row.js';
@@ -27,6 +31,10 @@ export { AdwClamp, DEFAULT_CLAMP_MAX_SIZE } from './adw-clamp.js';
 export { AdwHeaderBar } from './adw-header-bar.js';
 export { AdwToolbarView } from './adw-toolbar-view.js';
 export { AdwWrapBox } from './adw-wrap-box.js';
+export { AdwDataGrid, ROW_ACTIVATED } from './adw-data-grid.js';
+export type { RowActivatedEventData } from './adw-data-grid.js';
+export { DATA_GRID_HEADER_CELL_CLASS, DATA_GRID_HEADER_ROW_CLASS, DATA_GRID_SECTION_CELL_CLASS, dataGridCellClass, dataGridItemSpec, dataGridRowClass, dataGridShapeKey, dataGridTracksKey, parseDataGridWidth, } from './data-grid-model.js';
+export type { DataGridItemSpec } from './data-grid-model.js';
 export { AdwSpinner, DEFAULT_SPINNER_SIZE } from './adw-spinner.js';
 export { AdwStatusPage } from './adw-status-page.js';
 export { AdwButtonRow, ACTIVATED } from './adw-button-row.js';
@@ -42,18 +50,25 @@ export type { AdwViewPage, NotifyViewSelectedEventData } from './view-switcher-b
 export { AdwViewSwitcher } from './adw-view-switcher.js';
 export { AdwViewSwitcherBar } from './adw-view-switcher-bar.js';
 export { AdwInlineViewSwitcher } from './adw-inline-view-switcher.js';
-export { AdwTabView } from './adw-tab-view.js';
-export { AdwCarousel, DEFAULT_CAROUSEL_PAGE_WIDTH, NOTIFY_POSITION } from './adw-carousel.js';
-export type { NotifyPositionEventData } from './adw-carousel.js';
+export { AdwTabView, CLOSE_PAGE, NOTIFY_SELECTED_PAGE, PAGES_CHANGED } from './adw-tab-view.js';
+export type { ClosePageEventData, NotifySelectedPageEventData, PagesChangedEventData } from './adw-tab-view.js';
+export { applyTabViewVisibility, createTabViewState, tabBarVisibility, tabCloseVisibilities, tabLabelText, tabPageVisibilities, tabTooltipText, tabViewNotifyPayload, } from './tab-view-state.js';
+export type { AdwTabPage, NsVisibility, TabViewNotifyPayload } from './tab-view-state.js';
+export { AdwCarousel, DEFAULT_CAROUSEL_PAGE_WIDTH, NOTIFY_N_PAGES, NOTIFY_POSITION, PAGE_CHANGED, } from './adw-carousel.js';
+export type { NotifyPositionEventData, PageChangedEventData } from './adw-carousel.js';
+export { CarouselScrollSync, applyCarouselDots, carouselDotClasses, carouselNotifyPayload, carouselPositionAtOffset, carouselScrollOffset, createCarouselState, normalizeCarouselPageWidth, } from './carousel-state.js';
+export type { CarouselNotifyPayload, NsCarouselStateOptions } from './carousel-state.js';
 export { AdwNavigationView, NOTIFY_VISIBLE_PAGE } from './adw-navigation-view.js';
 export type { NotifyVisiblePageEventData } from './adw-navigation-view.js';
-export { AdwSplitViewBase, DEFAULT_SIDEBAR_WIDTH, NOTIFY_SHOW_SIDEBAR } from './split-view-base.js';
+export { AdwSplitViewBase, NOTIFY_SHOW_SIDEBAR } from './split-view-base.js';
 export type { NotifyShowSidebarEventData } from './split-view-base.js';
 export { AdwNavigationSplitView } from './adw-navigation-split-view.js';
 export { AdwOverlaySplitView } from './adw-overlay-split-view.js';
+export { NsNavigationSplitViewState, NsOverlaySplitViewState, splitViewColumns } from './split-view-state.js';
+export type { NsShowSidebarNotification, NsSplitViewHost, NsSplitViewState } from './split-view-state.js';
 export { AdwSidebar, NOTIFY_SELECTED as NOTIFY_SIDEBAR_SELECTED } from './adw-sidebar.js';
 export type { NotifySidebarSelectedEventData } from './adw-sidebar.js';
-export { AdwBottomSheet, NOTIFY_OPEN } from './adw-bottom-sheet.js';
+export { AdwBottomSheet, CLOSE_ATTEMPT, NOTIFY_OPEN, SHEET_CLOSE } from './adw-bottom-sheet.js';
 export type { NotifyOpenEventData } from './adw-bottom-sheet.js';
 export { AdwToast, AdwToastOverlay, AdwToastQueue, DEFAULT_TOAST_TIMEOUT, TOAST_BUTTON_CLICKED, } from './adw-toast-overlay.js';
 export type { AdwToastOptions, AdwToastQueueHandlers, AdwToastQueueOptions, ToastScheduler, ToastTimerHandle, } from './adw-toast-overlay.js';

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

@@ -0,0 +1,153 @@
+import type { AdwNavigationPageProps, NavigationDiagnosticListener, NavigationShortcutResult } from '@gjsify/adwaita-core';
+import type { View } from '@nativescript/core';
+/** Event name emitted when the visible page changes. Mirrors GObject `notify::visible-page`. */
+export declare const NOTIFY_VISIBLE_PAGE = "notify::visible-page";
+/** Emitted after a page has been pushed. Mirrors `AdwNavigationView::pushed`. */
+export declare const PUSHED = "pushed";
+/** Emitted after a page has been popped — once per popped page, top-first. Mirrors `AdwNavigationView::popped`. */
+export declare const POPPED = "popped";
+/** Emitted after the whole stack has been replaced. Mirrors `AdwNavigationView::replaced`. */
+export declare const REPLACED = "replaced";
+/** The NS visibility values a navigation page is toggled between. */
+export type NsPageVisibility = 'visible' | 'collapse';
+/** The CSS class every managed page carries, so `_navigation-view.scss` applies. */
+export declare const NS_NAVIGATION_PAGE_CLASS = "adw-navigation-page";
+/** Append the navigation-page class to a view's existing class list. */
+export declare function navigationPageClassName(existing: string | null | undefined): string;
+/** One signal the widget must re-emit, already reduced to its payload. */
+export interface NsNavigationEvent {
+    /** {@link PUSHED}, {@link POPPED}, {@link REPLACED} or {@link NOTIFY_VISIBLE_PAGE}. */
+    name: string;
+    /** The page the signal is about — `null` for `replaced` and for an emptied view. */
+    page: View | null;
+    /**
+     * That page's tag, or `null`. A page destroyed by the SAME mutation has already
+     * left the registry, so its tag reads `null` — the page handle is the reliable
+     * identity in an event payload.
+     */
+    tag: string | null;
+    /** The stack depth after the change. */
+    depth: number;
+}
+/** The NativeScript side of the adapter: child management + signal emission. */
+export interface NsNavigationHost {
+    /** Add `view` as an overlaying child of the navigation grid. */
+    attachPage(view: View): void;
+    /** Remove `view` from the grid — the page has been destroyed. */
+    detachPage(view: View): void;
+    /** Show or hide a page. Instant: the NS CSS subset has no transition. */
+    setPageVisibility(view: View, visibility: NsPageVisibility): void;
+    /** Re-emit a GObject-style signal on the widget. */
+    emit(event: NsNavigationEvent): void;
+}
+/** Construction seams. */
+export interface NsNavigationStackOptions {
+    /** Where rejected mutations go — the widget logs them; a test collects them. */
+    onDiagnostic?: NavigationDiagnosticListener;
+}
+/**
+ * `Adw.NavigationView` bound to a NativeScript view tree.
+ *
+ * Holds a `NavigationViewState` and keeps the grid's children in step with its
+ * registry: a page enters the tree when it is registered and leaves when it is
+ * destroyed, and the top of the stack is the only visible one. The widget keeps
+ * ZERO navigation state.
+ */
+export declare class NsNavigationStack {
+    private readonly _state;
+    private readonly _host;
+    /** The views currently in the grid — the mirror of the core's registry. */
+    private readonly _attached;
+    private readonly _onDiagnostic;
+    private _pending;
+    constructor(host: NsNavigationHost, options?: NsNavigationStackOptions);
+    /** The currently-visible page view, or `null`. */
+    get visiblePage(): View | null;
+    /** The currently-visible page tag, or `null`. */
+    get visiblePageTag(): string | null;
+    /** The current navigation stack depth. */
+    get depth(): number;
+    /** The navigation stack, bottom-first. */
+    get stack(): readonly View[];
+    /** Every registered page — static and dynamically pushed. */
+    get pages(): readonly View[];
+    /**
+     * `Adw.NavigationView:animate-transitions`. Stored and honoured by the shared
+     * change payload, but NativeScript paints the swap instantly either way — the
+     * CSS subset has no transition, so a real app animates with `View.animate()`.
+     */
+    get animateTransitions(): boolean;
+    /** `Adw.NavigationView:pop-on-escape` — consulted by {@link popFromEscape}. */
+    get popOnEscape(): boolean;
+    /** Whether `view` is known to this navigation view. */
+    isRegistered(view: View): boolean;
+    /** `view`'s tag, or `null`. */
+    tagOf(view: View): string | null;
+    /** `view`'s title (`''` when untitled). */
+    titleOf(view: View): string;
+    /** Whether `view` may be popped by a shortcut or a back button. */
+    canPopOf(view: View): boolean;
+    /** The page with this tag, or `null`. */
+    findPage(tag: string): View | null;
+    /** The page popping `view` would reveal, or `null`. */
+    getPreviousPage(view: View): View | null;
+    /** Whether a back button belongs on the visible page. */
+    canGoBack(): boolean;
+    /** The back button's tooltip — the previous page's title, or `null` when there is no button. */
+    backButtonTooltip(fallback?: string): string | null;
+    /**
+     * Register a page (optionally with a tag for `push(tag)`). A page added while
+     * the stack is EMPTY is pushed automatically, so the view is never blank.
+     */
+    add(view: View, tag?: string | null, options?: Omit<AdwNavigationPageProps, 'tag'>): boolean;
+    /** Remove a page. One that is on the stack is removed when it is POPPED. */
+    remove(view: View): boolean;
+    /** Push a page (a previously-registered tag, or a fresh view) onto the stack. */
+    push(viewOrTag: View | string, options?: AdwNavigationPageProps): boolean;
+    /** Push the page carrying `tag`. */
+    pushByTag(tag: string): boolean;
+    /** Pop the top page. `can-pop` does NOT gate this — it gates the shortcuts. */
+    pop(): boolean;
+    /** Pop until `view` is visible, in ONE transition. */
+    popToPage(view: View): boolean;
+    /** Pop until the page carrying `tag` is visible. */
+    popToTag(tag: string): boolean;
+    /**
+     * Replace the whole stack. String entries are resolved BEFORE anything is
+     * mutated, so replacing the stack with the tag of a dynamically-pushed page
+     * keeps that page (replace_with_tags:3136-3147).
+     */
+    replace(entries: ReadonlyArray<View | string | null>, props?: (view: View) => AdwNavigationPageProps | undefined): void;
+    /** Replace the stack with the pages carrying `tags`. */
+    replaceWithTags(tags: readonly string[]): void;
+    /** Set a page's tag. Rejected when another page already owns it. */
+    setTag(view: View, tag: string | null): boolean;
+    /** Set a page's title — the NEXT page's back-button tooltip. */
+    setTitle(view: View, title: string): boolean;
+    /** Set a page's `can-pop`: gates the shortcuts and a back button, not `pop()`. */
+    setCanPop(view: View, canPop: boolean): boolean;
+    /** Set `animate-transitions`. */
+    setAnimateTransitions(value: boolean): boolean;
+    /** Set `pop-on-escape`. */
+    setPopOnEscape(value: boolean): boolean;
+    /** The `can-pop`-aware pop behind a hardware back button or Alt+Left. */
+    popFromShortcut(): NavigationShortcutResult;
+    /** Escape-to-pop, gated on `pop-on-escape`. */
+    popFromEscape(): NavigationShortcutResult;
+    /**
+     * Settle the transition (a no-op here beyond what {@link _flush} already did):
+     * NativeScript never defers, so this exists only so the widget exposes the
+     * whole `Adw.NavigationView` surface.
+     */
+    finishTransition(): readonly View[];
+    /**
+     * Apply the change the last mutation produced: bring the view tree in step,
+     * then re-emit the signals. The tree is synced FIRST so a listener reading
+     * `visiblePage` from the event sees a mounted page.
+     */
+    private _flush;
+    private _emit;
+    private _notify;
+    /** Mirror the core's registry into the grid, then raise the top of the stack. */
+    private _sync;
+}

package/lib/types/widgets/preferences-group-state.d.ts

@@ -0,0 +1,52 @@
+import type { PreferencesGroupHeaderState } from '@gjsify/adwaita-core';
+/** The two `View.visibility` values a preferences group ever assigns. */
+export type NsVisibility = 'visible' | 'collapse';
+/** The header box's base style class. */
+export declare const PREFERENCES_GROUP_HEADER_CLASS = "adw-preferences-group-header";
+/**
+ * The style class libadwaita toggles for a one-line header. Not cosmetic: the
+ * stylesheet gives `.single-line` a `min-height` and everything else a bottom
+ * margin, so a header without it is laid out as if it had two lines.
+ */
+export declare const PREFERENCES_GROUP_SINGLE_LINE_CLASS = "single-line";
+/** What a group knows about itself when it re-derives its visuals. */
+export interface NsPreferencesGroupInput {
+    /** `AdwPreferencesGroup:title`. */
+    title?: string | null;
+    /** `AdwPreferencesGroup:description`. */
+    description?: string | null;
+    /** Whether a `header-suffix` view is set. */
+    hasHeaderSuffix?: boolean;
+    /** How many children the boxed list holds. */
+    rowCount?: number;
+}
+/** The NativeScript form of {@link PreferencesGroupHeaderState}. */
+export interface NsPreferencesGroupVisuals {
+    /** `visibility` for the title label. */
+    titleVisibility: NsVisibility;
+    /** `visibility` for the description label. */
+    descriptionVisibility: NsVisibility;
+    /** `visibility` for the whole header box. */
+    headerVisibility: NsVisibility;
+    /** `className` for the header box, carrying `single-line` when it applies. */
+    headerClassName: string;
+    /** `visibility` for the `.boxed-list` container. */
+    listboxVisibility: NsVisibility;
+}
+/**
+ * The five derived states for a group.
+ *
+ * `useMarkup: false` is deliberate and is the same choice the browser renderer
+ * makes: an NS `Label` shows the string verbatim (it has no Pango markup), so
+ * visibility must be judged on the string that is actually painted. Rendering
+ * markup is a separate, still-open gap; closing it flips this one flag.
+ */
+export declare function preferencesGroupHeaderState(input: NsPreferencesGroupInput): PreferencesGroupHeaderState;
+/**
+ * `visibility` / `className` a group must apply for the given inputs.
+ *
+ * `'collapse'` rather than `'hidden'`: a hidden NS view still occupies its
+ * space, which would leave the header's padding behind on a group that has no
+ * header — the very thing `update_header_visibility` exists to avoid.
+ */
+export declare function preferencesGroupVisuals(input: NsPreferencesGroupInput): NsPreferencesGroupVisuals;