@gjsify/adwaita-nativescript 0.31.0 → 0.33.0

package/lib/types/widgets/carousel-state.d.ts

@@ -0,0 +1,85 @@
+import type { Label } from '@nativescript/core';
+import { CarouselState } from '@gjsify/adwaita-core';
+import type { CarouselScrollRequest, CarouselStateChange } from '@gjsify/adwaita-core';
+/**
+ * Default page width (DIPs) used for offset math until the consumer sets
+ * `pageWidth`. libadwaita MEASURES its pages (adw-carousel.c:739-765); NS gives
+ * a widget no size before its first layout pass, so a plausible phone-width
+ * default keeps the offsets sane until the consumer supplies the real one.
+ */
+export declare const DEFAULT_CAROUSEL_PAGE_WIDTH = 320;
+/** Construction seams an `AdwCarousel` hands to its state machine. */
+export interface NsCarouselStateOptions {
+    /** Clock for the wheel lockout — injected so a spec can step past it. */
+    now?: () => number;
+    /** Invoked for every accepted scroll; the widget turns it into a `scrollToHorizontalOffset`. */
+    onScrollTo?: (request: CarouselScrollRequest) => void;
+}
+/**
+ * The state machine an `AdwCarousel` delegates to.
+ *
+ * `animateScroll` is FALSE: the `ScrollView` animates the pixels, but it reports
+ * nothing until it has, and on an untested platform it may report nothing at
+ * all. Keeping the model authoritative means a `scrollToPage` is correct the
+ * instant it is called, which is also what the port did before the lift —
+ * {@link CarouselScrollSync} is what keeps the two from fighting.
+ */
+export declare function createCarouselState(options?: NsCarouselStateOptions): CarouselState;
+/** A page width that can be divided by — anything else falls back to the default. */
+export declare function normalizeCarouselPageWidth(value: number): number;
+/** The horizontal scroll offset in DIPs for a position — `distance * position` (adw-carousel.c:797-801). */
+export declare function carouselScrollOffset(position: number, distance: number): number;
+/** The inverse: the position a `ScrollView` at `offset` is showing. */
+export declare function carouselPositionAtOffset(offset: number, distance: number): number;
+/**
+ * Keeps the model in step with a `ScrollView` that animates its own scrolls.
+ *
+ * Without this the two fight: the widget moves the model the moment
+ * `scrollToPage` is called, then the animation replays every intermediate offset
+ * back at it, so the dots would run backwards to where the scroll STARTED and
+ * crawl forward again, emitting a second `page-changed` on arrival.
+ *
+ * So a programmatic scroll declares its destination with {@link expect}, and
+ * every offset before that destination is ignored. A scroll nobody declared is a
+ * user swipe and drives the model directly — which is how a free flick gets a
+ * fractional position at all, something the port had no way to observe.
+ */
+export declare class CarouselScrollSync {
+    /** Position a programmatic scroll is animating towards, `null` while idle. */
+    private _expected;
+    /** Declare where a programmatic scroll is heading; its intermediate offsets are then ignored. */
+    expect(position: number): void;
+    /**
+     * Feed one `ScrollView` scroll event. Returns whether the model was updated
+     * — `false` while a programmatic scroll is still in flight.
+     */
+    apply(state: CarouselState, position: number, epsilon?: number): boolean;
+}
+/** The class string each dot `Label` must carry, in page order. */
+export declare function carouselDotClasses(state: CarouselState): string[];
+/**
+ * Push {@link carouselDotClasses} onto the real dot labels.
+ *
+ * The selected dot comes from `get_page_at_position` (adw-carousel.c:222-239),
+ * not from `Math.round`, so a carousel resting half-way between two pages marks
+ * the LOWER one — and, unlike the integer compare this replaces, it marks
+ * something at all while a swipe is in progress.
+ */
+export declare function applyCarouselDots(state: CarouselState, dots: readonly Label[]): void;
+/** The data half of the `notify::position` event (minus NS's `eventName`/`object`). */
+export interface CarouselNotifyPayload {
+    /** The clamped fractional scroll position. */
+    position: number;
+    /** The number of pages. */
+    nPages: number;
+    /** The page the position settles on, `-1` when the carousel is empty. */
+    page: number;
+    /** `true` for a user navigation (swipe, dot tap, keynav). */
+    interactive: boolean;
+}
+/**
+ * Project a core change onto the event payload. Kept as a function rather than
+ * spreading the change so the internal `reason` discriminator — which names a C
+ * notification site, not an NS event — never leaks into consumer code.
+ */
+export declare function carouselNotifyPayload(change: CarouselStateChange): CarouselNotifyPayload;

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

@@ -0,0 +1,161 @@
+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 RING diameter for a requested BOX size — 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.
+ *
+ * The two are different numbers, which is the whole point: `AdwSpinner` sizes
+ * its BOX to the request and its `ActivityIndicator` to this. They used to be
+ * one, so `size = 200` occupied 64 DIPs of layout where GTK occupies 200.
+ */
+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';