@gjsify/adwaita-web 0.41.0 → 0.43.0

package/lib/types/adw-fonts.spec.d.ts

@@ -0,0 +1,2 @@
+import '@gjsify/adwaita-web';
+export declare const AdwFontsTest: () => Promise<void>;

package/lib/types/breakpoints.d.ts

@@ -13,8 +13,17 @@ export declare function addBreakpoints(element: Element, breakpoints: readonly A
  * of an `Adw.Breakpoint` with one `add_setter()` call. Returns a dispose function; call it
  * before re-binding and on disconnect.
  *
+ * `applied` is what the binding being REPLACED had last set, and it is not optional
+ * bookkeeping: an element rebinds on every connect, and a fresh `AdwBreakpoint` starts
+ * at `false` while firing on transitions only. Without carrying it over, a view the
+ * breakpoint had collapsed and that then moves into a WIDE parent evaluates
+ * `matches === applied === false` and never hears `onUnapply` — measured stuck at
+ * `collapsed` after 800px → 500px → 900px. Pass what the setter last received, never
+ * what the attribute currently says: markup that declares the state itself was never
+ * this breakpoint's doing and must not be undone by it.
+ *
  * A missing or unparsable condition binds nothing and returns a no-op, leaving whatever
  * the attribute already says untouched — an element must not silently flip state because
  * its condition had a typo.
  */
-export declare function bindBreakpointSetter(element: Element, condition: string | null, setValue: (active: boolean) => void): () => void;
+export declare function bindBreakpointSetter(element: Element, condition: string | null, setValue: (active: boolean) => void, applied?: boolean): () => void;

package/lib/types/connect-lifecycle.spec.d.ts

@@ -0,0 +1 @@
+export declare const AdwConnectLifecycleTest: () => Promise<void>;

package/lib/types/elements/adw-about-dialog.d.ts

@@ -2,6 +2,7 @@ export declare class AdwAboutDialog extends HTMLElement {
     private _initialized;
     private _scrimEl;
     private _sheetEl;
+    private _modal;
     private _navView;
     private _scrollEl;
     private _mainToolbarEl;

package/lib/types/elements/adw-action-row.d.ts

@@ -8,6 +8,8 @@ export declare class AdwActionRow extends HTMLElement {
     /** Watches the activatable widget's `disabled`/`aria-disabled` — the live binding. */
     private _sensitivityObserver;
     private _initialized;
+    /** Tab stop + Enter/Space, re-derived whenever `activatable` moves. */
+    private _activation?;
     static get observedAttributes(): string[];
     /** The end (suffix) section — append controls here imperatively. */
     get suffixSection(): HTMLDivElement;

package/lib/types/elements/adw-alert-dialog.d.ts

@@ -18,6 +18,7 @@ export declare class AdwAlertDialog extends HTMLElement {
     private _bodyEl;
     private _childEl;
     private _responseAreaEl;
+    private _modal;
     /** The headless response registry + default/close semantics + resolution (ADR 0004). */
     private _model;
     /** The rendered button per registered response id (the DOM half of the model). */
@@ -63,7 +64,18 @@ export declare class AdwAlertDialog extends HTMLElement {
     /** Dismissal (Escape / scrim) — close, then emit the close-response. */
     private _dismiss;
     private _emitResponse;
-    /** Move focus to the default response button (or the first enabled one). */
-    private _focusInitial;
+    /**
+     * Where a presented alert puts focus, in the three steps `adw_alert_dialog_grab_focus`
+     * takes (refs/libadwaita/src/adw-alert-dialog.c:382): the CONTENT first
+     * (`adw_widget_grab_focus_child (priv->scrolled_window)`, :397), then the default
+     * widget (:406), then the first response whose `enabled` is set (:413). The default
+     * response is rarely the first button — a destructive alert opens on Cancel — and
+     * content beats it: an alert carrying an entry is answered by typing into it.
+     *
+     * `focusables` is the surface's own list, so what "focusable" means is decided once.
+     */
+    private _initialFocusTarget;
+    /** The default response button, or the first enabled one. */
+    private _defaultResponseButton;
     private _render;
 }

package/lib/types/elements/adw-carousel.d.ts

@@ -34,6 +34,8 @@ export declare class AdwCarousel extends HTMLElement implements CarouselHost {
      * index while the target page stays the target.
      */
     private _scrollTargetId;
+    /** The pointer-drag gesture, asked whether it owns the strip. See `_onWheel`. */
+    private _drag;
     static get observedAttributes(): string[];
     constructor();
     get nPages(): number;
@@ -47,6 +49,12 @@ export declare class AdwCarousel extends HTMLElement implements CarouselHost {
      */
     set position(value: number);
     get currentPage(): number;
+    /**
+     * `AdwCarousel:allow-mouse-drag` — whether the strip can be dragged with the pointer.
+     * Defaults to TRUE, as in libadwaita, where FALSE leaves dragging to touch only.
+     */
+    get allowMouseDrag(): boolean;
+    set allowMouseDrag(value: boolean);
     /** Whether the scroll wheel navigates between pages. Defaults to TRUE, as in libadwaita. */
     get allowScrollWheel(): boolean;
     set allowScrollWheel(value: boolean);

package/lib/types/elements/adw-dialog.d.ts

@@ -8,7 +8,7 @@ export declare class AdwDialog extends HTMLElement {
     private _titleEl;
     private _closeBtn;
     private _contentEl;
-    private _previouslyFocused;
+    private _modal;
     static get observedAttributes(): string[];
     /** Whether the dialog is currently revealed. */
     get open(): boolean;
@@ -40,12 +40,7 @@ export declare class AdwDialog extends HTMLElement {
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     /** A dismissal was requested: honour `can-close`, else raise close-attempt. */
     private _attemptClose;
-    /** Focus trap + Escape while the box has focus. */
-    private _onBoxKeyDown;
-    private _focusables;
-    /** On present: remember focus, then move it into the dialog. */
-    private _onPresented;
-    /** On close: emit `closed` and return focus to where it was before present. */
+    /** On close: emit `closed`, then let the surface return focus to where it was. */
     private _onClosed;
     private _render;
 }

package/lib/types/elements/adw-icon.d.ts

@@ -1,3 +1,15 @@
+/**
+ * The generated mask-class prefix — the one place the `--` spelling appears. `icon-registry`
+ * builds the same class for a runtime registration and imports it from here rather than
+ * spelling it twice.
+ */
+export declare const MASK_CLASS_PREFIX = "adw-icon--";
+/**
+ * The glyph an icon falls back to — the same name `_icon.scss` masks with, the same one
+ * libadwaita's C substitutes for a NULL icon-name, and the same one GTK's icon theme
+ * returns for a name it cannot find.
+ */
+export declare const MISSING_ICON_NAME = "image-missing";
 export declare class AdwIcon extends HTMLElement {
     static get observedAttributes(): string[];
     /** The declared symbolic name, `-symbolic` suffix optional. */
@@ -6,7 +18,11 @@ export declare class AdwIcon extends HTMLElement {
     /**
      * The name that actually reached the mask class — `''` when the icon-name is
      * absent, empty, or not usable as one CSS token. Consumers that need to know
-     * whether an icon is being drawn ask this, not the raw attribute.
+     * whether the DECLARED name is drawable ask this, not the raw attribute.
+     *
+     * `''` does NOT mean the box draws nothing: an unusable name that was given still
+     * draws {@link MISSING_ICON_NAME}. Whether an icon was ASKED FOR is the raw
+     * attribute's emptiness, which is the predicate a host's visibility follows.
      */
     get resolvedIconName(): string;
     /** The rendered edge length in px, or `null` when the stylesheet decides. */

package/lib/types/elements/adw-navigation-split-view.d.ts

@@ -11,6 +11,12 @@ export declare class AdwNavigationSplitView extends HTMLElement {
     private _contentEl;
     private _initialized;
     private _disposeBreakpoint;
+    /**
+     * What the breakpoint last SET, carried across every rebind. Not read off the
+     * attribute: a `collapsed` the markup declared was never this breakpoint's doing,
+     * and unapplying it at connect would undo the author.
+     */
+    private _breakpointApplied;
     /** The ordering table, the tag guard and the action routing (ADR 0004). */
     private _state;
     /** Re-entrancy guard for the `show-content` reflection. */
@@ -38,6 +44,7 @@ export declare class AdwNavigationSplitView extends HTMLElement {
     /** `navigation.pop` — `navigation_pop_cb`. */
     pop(): NavigationActionResult;
     connectedCallback(): void;
+    private _buildOnce;
     /** `Adw.NavigationPage:tag` off the slotted pane, or `null` when untagged. */
     private _tagOf;
     /**

package/lib/types/elements/adw-overlay-split-view.d.ts

@@ -4,6 +4,12 @@ export declare class AdwOverlaySplitView extends HTMLElement {
     private _contentEl;
     private _backdropEl;
     private _disposeBreakpoint;
+    /**
+     * What the breakpoint last SET, carried across every rebind. Not read off the
+     * attribute: a `collapsed` the markup declared was never this breakpoint's doing,
+     * and unapplying it at connect would undo the author.
+     */
+    private _breakpointApplied;
     /**
      * The property interplay, shared with the NativeScript renderer (ADR 0004): the
      * element owns the attributes and the painting, core owns what `collapsed` +

package/lib/types/elements/adw-popover.d.ts

@@ -35,6 +35,7 @@ export declare class AdwPopover extends HTMLElement {
     /** Subscribe to open-state changes. Returns an unsubscribe function. */
     subscribe(listener: (open: boolean) => void): () => void;
     connectedCallback(): void;
+    private _buildOnce;
     disconnectedCallback(): void;
     attributeChangedCallback(name: string, _previous: string | null, value: string | null): void;
     private _onStateChange;

package/lib/types/elements/adw-preferences-dialog.d.ts

@@ -28,6 +28,7 @@ export declare class AdwPreferencesDialog extends HTMLElement {
     private _bodyEl;
     private _pagesEl;
     private _closeBtn;
+    private _modal;
     static get observedAttributes(): string[];
     get open(): boolean;
     set open(value: boolean);

package/lib/types/elements/adw-switch.d.ts

@@ -3,6 +3,16 @@ export declare class AdwSwitch extends HTMLElement {
     private _slider;
     private _initialized;
     static get observedAttributes(): string[];
+    /**
+     * `Gtk.Widget:can-focus` on the slider, inverted so the default stays "yes".
+     *
+     * `adw_switch_row_init` does `gtk_widget_set_can_focus (self->slider, FALSE)`
+     * (adw-switch-row.c:159) and makes the ROW activatable instead, so a switch row is ONE
+     * tab stop announced as its own title — not a bare checkbox followed by a label that
+     * cannot be reached. A standalone `<adw-switch>` keeps its checkbox focusable.
+     */
+    get unfocusable(): boolean;
+    set unfocusable(value: boolean);
     /** Whether the switch is on. */
     get active(): boolean;
     set active(value: boolean);

package/lib/types/elements/adw-toggle-group.d.ts

@@ -8,6 +8,8 @@ export declare class AdwToggleGroup extends HTMLElement {
     /** The headless segment list + guarded selection state machine (ADR 0004). */
     private readonly _state;
     private _initialized;
+    /** `aria-checked` under `radio`, `aria-selected` under `tab` — decided at connect. */
+    private _stateAttr;
     static get observedAttributes(): string[];
     /** Zero-based index of the active toggle. */
     get active(): number;

package/lib/types/elements/modal-surface.d.ts

@@ -0,0 +1,59 @@
+/** The two roles a modal surface in this package declares. */
+export type AdwModalRole = 'dialog' | 'alertdialog';
+export interface AdwModalSurfaceInit {
+    /**
+     * The custom element itself. It receives the keydown listener, because a dialog that
+     * moves focus to its HOST — `<adw-preferences-dialog>` does — would otherwise press
+     * Tab against a listener on a descendant that never sees the event.
+     */
+    host: HTMLElement;
+    /** The element carrying the role, `aria-modal`, and the boundary focus may not cross. */
+    surface: HTMLElement;
+    /** The WAI-ARIA role for {@link AdwModalSurfaceInit.surface}. */
+    role: AdwModalRole;
+    /** Whether the dialog is presented right now. */
+    isOpen: () => boolean;
+    /** Escape while open. Dismissal is the element's own business (`can-close`, close-response). */
+    onEscape: () => void;
+    /**
+     * Where focus goes on present, when the element wants something other than the first
+     * focusable control — `<adw-alert-dialog>` starts on its DEFAULT response, not on the
+     * leftmost button. It is handed {@link AdwModalSurface.focusables}, so a rule like
+     * "the first control in the content area" is a `find` over that list rather than a
+     * second copy of the filter.
+     *
+     * Returning nothing — or an element that is not in that list — falls back to the
+     * first focusable, then to the surface itself.
+     */
+    initialFocus?: (focusables: readonly HTMLElement[]) => HTMLElement | null | undefined;
+}
+/**
+ * A modal surface: it declares `aria-modal`, keeps Tab inside itself, and gives focus
+ * back to whatever had it when the dialog appeared.
+ *
+ * The element drives it with two calls — {@link present} when it opens and
+ * {@link dismiss} when it closes — and keeps its own dismissal rules.
+ */
+export declare class AdwModalSurface {
+    private readonly _init;
+    /** Focused before `present()`, restored by `dismiss()`. */
+    private _previouslyFocused;
+    constructor(init: AdwModalSurfaceInit);
+    /** The controls inside the surface, in tab order, that a `focus()` can actually reach. */
+    focusables(): HTMLElement[];
+    /**
+     * Remember where focus was, then move it inside.
+     *
+     * SYNCHRONOUS, and that was measured rather than assumed. `<adw-about-dialog>` used to
+     * defer this by a `requestAnimationFrame`, which reads as "the sheet is not laid out
+     * yet" — it is not. Every element here toggles its `open` class before calling this,
+     * so the surface is already displayed; reading `document.activeElement` in the same
+     * task that sets `open` finds it inside the dialog for all four. A retry frame would
+     * be a branch nothing can reach, and a spec asserting focus one frame late would pass
+     * over a dialog that never focused anything at all.
+     */
+    present(): void;
+    /** Give focus back to whatever had it before `present()`. */
+    dismiss(): void;
+    private _onKeyDown;
+}

package/lib/types/elements/roving-focus.d.ts

@@ -0,0 +1,26 @@
+/** Which axis the items are laid out along — it decides which arrow keys move. */
+export type AdwRovingOrientation = 'horizontal' | 'vertical';
+export interface AdwRovingFocusInit {
+    /**
+     * The element the listener sits on — the custom element itself, so items rebuilt at
+     * any time are still covered.
+     */
+    host: HTMLElement;
+    orientation: AdwRovingOrientation;
+    /**
+     * The items a key may land on, in visual order. The widget filters: a `hidden` or
+     * `disabled` item is not navigable, and leaving one in would strand the user on a
+     * `focus()` the browser refuses.
+     */
+    items: () => readonly HTMLElement[];
+    /**
+     * Select `item`. Whether the selection actually MOVED is the widget's own business:
+     * focus travels with the key either way ({@link attachRovingFocus}).
+     */
+    select: (item: HTMLElement) => void;
+}
+/**
+ * Make a roving tabindex navigable: arrows step, Home/End jump, and focus travels with
+ * the selection so the next keypress has somewhere to start from.
+ */
+export declare function attachRovingFocus(init: AdwRovingFocusInit): void;

package/lib/types/elements/row-activation.d.ts

@@ -0,0 +1,26 @@
+/** What a row needs to become the keyboard's idea of one activatable thing. */
+export interface AdwRowActivationInit {
+    /** The element that becomes the tab stop and receives the keys. */
+    row: HTMLElement;
+    /** Re-read on every {@link AdwRowActivation.sync}: is the row activatable right now? */
+    activatable: () => boolean;
+    /**
+     * What Enter and Space do. Defaults to `row.click()` so a row keeps ONE activation
+     * path — the click handler it already has — rather than growing a second one that can
+     * drift from it.
+     */
+    activate?: () => void;
+}
+export interface AdwRowActivation {
+    /** Re-derive the tab stop after anything that can change `activatable()`. */
+    sync(): void;
+}
+/**
+ * Make `row` a tab stop while it is activatable, and activate it on Enter and Space.
+ *
+ * The listener is the element's OWN and is bound once, without teardown: it survives a
+ * re-parent and is collected with the element, so there is nothing here for
+ * `check-adwaita-connect-rebind.mjs` to hold. Only bindings that reach outside the element
+ * need releasing and re-arming.
+ */
+export declare function attachRowActivation(init: AdwRowActivationInit): AdwRowActivation;

package/lib/types/elements/swipe-drag.d.ts

@@ -0,0 +1,63 @@
+/** Which way the widget pages, and therefore which axis claims a drag. */
+export type AdwSwipeOrientation = 'horizontal' | 'vertical';
+export interface AdwSwipeDragInit {
+    /** The element the listeners sit on. Items rebuilt under it stay covered. */
+    host: HTMLElement;
+    orientation: AdwSwipeOrientation;
+    /** Re-read on every press: may a mouse drag start right now? */
+    enabled: () => boolean;
+    /** Page pitch in px. The raw pixel delta is divided by it to reach progress. */
+    pitch: () => number;
+    /** Snap points, ascending, as `adw_swipeable_get_snap_points` returns them. */
+    points: () => readonly number[];
+    /** Progress now — the gesture is seeded from it and bounded by it. */
+    progress: () => number;
+    /** `AdwCarousel:allow-long-swipes`. */
+    allowLongSwipes: () => boolean;
+    /**
+     * `adw_swipeable_get_cancel_progress` — where a CANCELLED gesture goes.
+     *
+     * Not optional by accident: the tracker's own fallback is where the gesture began,
+     * and `AdwCarousel`'s answer is `get_closest_snap_point` — the point nearest where
+     * the finger is NOW (adw-carousel.c:1294-1299). The two differ for exactly the
+     * gesture that matters, one cancelled past the halfway mark: upstream commits to the
+     * page under the cursor, the fallback yanks it back.
+     */
+    cancelProgress: () => number;
+    /** Show this progress. Called on every move that the gesture owns. */
+    onUpdate: (progress: number) => void;
+    /**
+     * Whether a gesture may be claimed at all right now, on top of the refusals this
+     * module makes itself. `AdwCarousel` needs none — its `interactive` and
+     * `allow-mouse-drag` are {@link enabled} — but `is_in_swipe_area` lives here for the
+     * widgets that implement `get_swipe_area`, which the carousel does not.
+     */
+    claimable?: (start: {
+        x: number;
+        y: number;
+    }) => boolean;
+    /** Settle on this progress. `velocity` is raw px/ms, for an animation duration. */
+    onEnd: (progress: number, velocity: number) => void;
+}
+/**
+ * Make `host` draggable with a mouse, deciding where it lands the way `AdwSwipeTracker`
+ * does.
+ *
+ * The listener is the element's own and is bound once, without teardown: it survives a
+ * re-parent and is collected with the element.
+ */
+/** What a caller gets back, so it can tell whether a gesture owns the widget. */
+export interface AdwSwipeDrag {
+    /**
+     * Whether a gesture is currently claimed.
+     *
+     * A widget needs this to keep its OTHER inputs out of the offset while a drag owns
+     * it. Measured on `<adw-carousel>`: one wheel notch during a claimed drag ran the
+     * whole wheel path and jumped `scrollLeft` 80 → 440 in a frame, which the next move
+     * then yanked back. Upstream's `scroll_cb` is ungated too, but there the external
+     * request is a spring the next frame quietly overrides — here `claim()` sets
+     * `scroll-behavior: auto`, which turns it into an instant jump.
+     */
+    readonly dragging: boolean;
+}
+export declare function attachSwipeDrag(init: AdwSwipeDragInit): AdwSwipeDrag;

package/lib/types/empty-sections.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Hide each of `sections` exactly while it holds no element children — now, and one
+ * MICROTASK after every later childList change.
+ *
+ * The deferral is what a MutationObserver is; it matters because the derivation used to
+ * run synchronously inside `_render()`. It lands before paint, so layout is never wrong,
+ * but a caller that appends and measures in the SAME task still reads the old answer —
+ * `<adw-toolbar-view>._syncClasses` does exactly that via `offsetHeight`, and its
+ * undershoot classes are corrected by the ResizeObserver on the next frame.
+ *
+ * Element children, not child NODES: whitespace between two slotted bars is a text node
+ * and an empty bar full of indentation is still an empty bar — which is also why the
+ * CSS `:empty` this looks like cannot express it.
+ */
+export declare function bindEmptySections(...sections: readonly HTMLElement[]): void;

package/lib/types/empty-sections.spec.d.ts

@@ -0,0 +1 @@
+export declare const AdwEmptySectionsTest: () => Promise<void>;

package/lib/types/fonts.d.ts

@@ -0,0 +1 @@
+export { ADWAITA_FONTS_CSS, ADWAITA_FONTS_STYLE_ID, applyAdwaitaFonts } from '@gjsify/adwaita-fonts/embedded';

package/lib/types/icon-registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Make `name` drawable by every `.adw-icon` in the document, from an Adwaita symbolic SVG
+ * source string (what `@gjsify/adwaita-icons` exports).
+ *
+ * BOTH arguments are checked and a wrong one THROWS rather than registering nothing: unlike
+ * a render, this is an explicit call with a wrong argument, and silently doing nothing is
+ * the failure mode this whole area exists to end. The name is normalized exactly as
+ * `<adw-icon icon-name>` normalizes it — a single `-symbolic` suffix comes off, and the rest
+ * must be one CSS token; the SVG has to parse to an `<svg>` root. `<adw-icon>` draws
+ * `image-missing` for the same unusable name instead — there it came from markup, and
+ * taking the page down over a typo is not proportionate.
+ *
+ * Registering a name the stylesheet already compiles is allowed and REPLACES the glyph:
+ * the property is set on the document element, so it wins over the `:root` rule.
+ *
+ * CLIENT-SIDE ONLY: this touches `document.documentElement` and `document.head`, so at
+ * module top level in an SSR/SSG build it throws before a page is rendered.
+ */
+export declare function registerIcon(name: string, svg: string): void;
+/**
+ * Whether `name` has a glyph — compiled into the stylesheet, or registered at runtime.
+ *
+ * Reads the live cascade rather than a generated list, so it answers for a glyph that
+ * arrived by any route, including a consumer's own `--icon-<name>` declaration. It is
+ * deliberately the CUSTOM PROPERTY that is read and not the rendered `mask-image` of a
+ * probe element: since `_icon.scss` gives every icon box the `image-missing` fallback,
+ * a rendered mask is never `none`, and comparing against the fallback would answer
+ * `false` for `image-missing` itself — the one name where being drawn and having fallen
+ * back look identical.
+ *
+ * Narrowing worth knowing: a consumer who writes `.adw-icon--x { mask-image: url(…) }`
+ * with no matching `--icon-x` gets `false` here and a drawn icon anyway. The generator and
+ * {@link registerIcon} are the two things that create the pair, and both create both.
+ */
+export declare function isIconAvailable(name: string): boolean;

package/lib/types/icon-registry.spec.d.ts

@@ -0,0 +1,18 @@
+/**
+ * What an icon box actually draws. Exported because the vector-driven icon specs
+ * (`adw-action-rows`, `adw-button-content`, `split-button`) need the same discriminator:
+ * they used to read `classList` alone, which is green on a correctly-applied class over
+ * a glyph nobody has.
+ */
+export declare const maskOf: (el: HTMLElement) => string;
+/**
+ * The `--icon-image-missing` the stylesheet compiles, as the cascade resolves it.
+ *
+ * Compared by EXACT equality against a computed `mask-image` throughout, which is sound
+ * because Firefox serializes both identically — measured, 1336 characters each, byte for
+ * byte. A substring test would not be sound: every icon's data URI opens with the same
+ * `url("data:image/svg+xml,%3Csvg%20height…` prefix, so a leading slice matches ALL of
+ * them, and the first version of this file passed that way while asserting nothing.
+ */
+export declare function fallbackMask(): string;
+export declare const AdwIconRegistryTest: () => Promise<void>;

package/lib/types/index.d.ts

@@ -1,9 +1,9 @@
-import '@gjsify/adwaita-fonts';
 export { addBreakpoints, bindBreakpointSetter } from './breakpoints.js';
 export { ACCENT_BG_PROPERTY, ACCENT_PROPERTY, applyAdwaitaAccent, clearAdwaitaAccent, isAdwaitaDark, } from './accent.js';
 export type { ApplyAccentOptions } from './accent.js';
 export { AdwScrollShading } from './scroll-shading.js';
 export type { AdwUndershootEdges } from './scroll-shading.js';
+export { isIconAvailable, registerIcon } from './icon-registry.js';
 export { AdwAvatar } from './elements/adw-avatar.js';
 export { AdwBanner } from './elements/adw-banner.js';
 export { AdwCard } from './elements/adw-card.js';

package/lib/types/keyboard-operable.spec.d.ts

@@ -0,0 +1 @@
+export declare const AdwKeyboardOperableTest: () => Promise<void>;