@skra/ui 0.2.0

package/types/skra-ui-multi-select.d.ts

@@ -0,0 +1,47 @@
+import * as _skra_ui_core from '@skra/ui/core';
+import { _SkraSelectBase, SkraListboxKeyboardItem } from '@skra/ui/core';
+export { SkraOption, SkraOptionDetail, SkraOptionLeading, SkraSelectTrigger } from '@skra/ui/core';
+import * as _angular_core from '@angular/core';
+
+/**
+ * SkraMultiSelect — a custom MULTI-select listbox: the WAI-ARIA APG multi-selectable listbox combobox.
+ * The multi-cardinality sibling of `skra-select` over the shared `_SkraSelectBase` (**ADR 0046** —
+ * cardinality split: a separate component with an HONEST `readonly T[]` value contract, NOT a `multiple`
+ * flag). The trigger (`role="combobox"`) opens a top-layer listbox panel (`popover="auto"`, ADR 0044,
+ * `aria-multiselectable="true"`) of the SAME projected `skra-option` children — reused verbatim; the
+ * option swaps its indicator to a checkbox via the `SkraListboxPanel.multiple` hint.
+ *
+ * - **Value (ADR 037):** `value = input<readonly T[]>([])` + `valueChange = output<readonly T[]>()` —
+ *   consumer-owned, no `@angular/forms`. Selection is membership (`compareWith` per element).
+ * - **Toggle (ADR 0046):** picking an option toggles its membership and KEEPS THE PANEL OPEN (the one
+ *   behavioural divergence from single-select, which closes).
+ * - **Trigger summary (ADR 0045 / 033):** comma-joined `getLabel()` of selected options — the VALUE
+ *   display, never the accessible name. Count-style / chips → the opt-in `[skraSelectTrigger]` recipe.
+ *
+ * Full contract: adr/specs/component-multi-select-spec.md.
+ */
+declare class SkraMultiSelect<T = unknown> extends _SkraSelectBase<T> {
+    /** Consumer-owned ARRAY value channel (ADR 037) — default `[]` (never undefined). */
+    readonly value: _angular_core.InputSignal<readonly T[]>;
+    /** Fires ONLY on user toggle — emits a NEW array; never on a programmatic `value()` change (ADR 037). */
+    readonly valueChange: _angular_core.OutputEmitterRef<readonly T[]>;
+    /** Cardinality hint (ADR 0046) — multi-select (drives the option checkbox indicator + aria-multiselectable). */
+    readonly multiple = true;
+    /** The options whose value is a member of `value()` — feeds the trigger summary + seed. */
+    protected readonly selectedOptions: _angular_core.Signal<_skra_ui_core.SkraOption<any>[]>;
+    /** Comma-joined identity labels of the selected options (value display, ADR 0045 — language-neutral). */
+    protected readonly summary: _angular_core.Signal<string>;
+    protected readonly triggerContext: _angular_core.Signal<{
+        $implicit: readonly T[];
+        options: _skra_ui_core.SkraOption<any>[];
+    }>;
+    constructor();
+    isSelected(value: unknown): boolean;
+    selectValue(value: unknown): void;
+    protected activeSeedItem(): SkraListboxKeyboardItem | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraMultiSelect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraMultiSelect<any>, "skra-multi-select", ["skraMultiSelect"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+
+export { SkraMultiSelect };
+//# sourceMappingURL=skra-ui-multi-select.d.ts.map

package/types/skra-ui-multi-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-multi-select.d.ts","sources":["../../../../libs/ui/multi-select/src/lib/multi-select/multi-select.ts"],"mappings":";;;;;AAmBA;;;;;;;;;;;;;;;;AAgBG;AACH,cAyDa,eAAe,sBAAsB,eAAe;;oBAEjD,aAAA,CAAA,WAAA;;0BAEM,aAAA,CAAA,gBAAA;;;;AAKpB,wCAAkC,aAAA,CAAA,MAAA,CAAA,aAAA,CAAA,UAAA;;AAKlC,gCAA0B,aAAA,CAAA,MAAA;uCAMO,aAAA,CAAA,MAAA;;;AAG7B;;AA0BJ;AAIA;AASA,gCAA4B,uBAAuB;oDA9DxC,eAAe;sDAAf,eAAe;AAiE3B;;;;","names":[]}

package/types/skra-ui-native-select.d.ts

@@ -0,0 +1,74 @@
+import { SkraFieldContext } from '@skra/ui/field';
+import * as i0 from '@angular/core';
+
+/**
+ * Wires a native `<select>` inside `<skra-field>` to SkraFieldContext (ADR 013).
+ * Tier 1 Foundations primitive — **single-select only**: a dropdown, or a
+ * single-select scrolling listbox via the native `[size]` attribute.
+ *
+ * Native `[multiple]` is deliberately NOT supported (the directive rejects it,
+ * see below). Native `<select multiple>` UX is not production-grade and cannot
+ * be fixed at the native-`<select>` tier: selection requires modifier keys or
+ * drag, the plain-click-toggle affordance exists only for a bare `<select
+ * multiple>` in some engines (and breaks with an explicit `[size]`), and the
+ * option markers are UA-drawn / unstylable cross-browser. Multi-select — chip
+ * display, search, custom option templates, and a styleable per-row checkbox —
+ * is wholly a Tier 2 `skra-select` (CDK listbox) concern per
+ * `adr/specs/0039-select-directive-spec.md` §1.1 / §4.1.
+ *
+ *   <skra-field>
+ *     <label skraLabelFor>Country</label>
+ *     <select skraSelect [value]="country()" (change)="country.set($any($event.target).value)">
+ *       <option value="pl">Poland</option>
+ *       <option value="de">Germany</option>
+ *     </select>
+ *   </skra-field>
+ *
+ * Native `<select>` is the only web-platform widget whose dropdown renders in
+ * the OS / browser top-layer, above modal `<dialog>`, above Shadow DOM
+ * boundaries, above z-index stacking contexts. By staying native at Tier 1 we
+ * inherit that for free — Tier 2 custom listbox will solve the same problem
+ * via CDK overlay + Top Layer API.
+ *
+ * Value channel stays consumer-owned per ADR 037: bind via native `[value]` +
+ * `(change)`, Reactive Forms `formControlName`, Signal Forms `[formField]`,
+ * or `[(ngModel)]` — all work orthogonally.
+ *
+ * `readonly` is ARIA-only because HTML spec does not apply native `[readonly]`
+ * to `<select>` (same gotcha as `<input type="checkbox|radio">`). Unlike a text
+ * input, though, a native `<select>` is an *uncontrolled* widget: if the listbox
+ * opens and the user picks an option, the displayed value changes regardless of
+ * the consumer's binding — so "consumer prevents change" cannot actually hold a
+ * native select readonly. The directive therefore enforces readonly behaviourally
+ * (blocks the picker from opening / the value from changing — see
+ * `blockWhenReadonly` / `blockKeyWhenReadonly`), mirroring the imperative
+ * `el.disabled` enforcement below. Both states are made non-interactive; only
+ * readonly stays focusable + un-greyed and presents as the bare value. This is
+ * interaction integrity for the control's own state — NOT a value channel, so the
+ * ADR 037 no-`@angular/forms` / no-CVA boundary is untouched.
+ */
+declare class SkraNativeSelect {
+    private readonly el;
+    readonly context: SkraFieldContext;
+    constructor();
+    /**
+     * Readonly: suppress the pointer affordance that opens the native listbox.
+     * `preventDefault` on `mousedown` stops the picker from opening (and, on a
+     * native select, focus-on-click — Tab focus still works, which is the right
+     * trade-off for a value-display control).
+     */
+    protected blockWhenReadonly(event: Event): void;
+    /**
+     * Readonly: suppress every keyboard affordance that opens or mutates the
+     * select, while letting Tab through for focus traversal. Space / Enter /
+     * Alt+ArrowDown open the listbox; bare Arrows + first-letter typeahead change
+     * the value inline without opening it — all are value-changing on a native
+     * select, so all are blocked in readonly.
+     */
+    protected blockKeyWhenReadonly(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraNativeSelect, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraNativeSelect, "select[skraSelect]", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { SkraNativeSelect };
+//# sourceMappingURL=skra-ui-native-select.d.ts.map

package/types/skra-ui-native-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-native-select.d.ts","sources":["../../../../libs/ui/native-select/src/lib/select/select.ts"],"mappings":";;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CG;AACH,cAwBa,gBAAgB;AAC3B;sBACgB,gBAAA;;AA2BhB;;;;;AAKG;AACH,uCAAmC,KAAK;AAIxC;;;;;;AAMG;AACH,0CAAsC,aAAa;yCA9CxC,gBAAgB;2CAAhB,gBAAgB;AAmD5B;;;;","names":[]}

package/types/skra-ui-popover.d.ts

@@ -0,0 +1,57 @@
+import * as i0 from '@angular/core';
+import { SkraPlacement } from '@skra/ui/core';
+export { SkraPlacement } from '@skra/ui/core';
+
+/**
+ * SkraPopover — a NON-MODAL, anchored panel of arbitrary (interactive) content, rendered in the
+ * browser TOP LAYER via the native Popover API (`popover="auto"`), per ADR 0044. It is the middle
+ * ground between Tooltip (supplementary, non-interactive, hover/focus) and the page-blocking modal
+ * Dialog.
+ *
+ * SHAPE (scope 2026-06-06): a Component on the PANEL with projected content — NOT a directive on the
+ * trigger + `TemplateRef`. The trigger is the consumer's own button linked by the native
+ * `popovertarget` attribute (zero Forge trigger API); toggle, light-dismiss (pointer-outside),
+ * Escape and invocation-order stacking are ALL platform-owned (contrast Tooltip's `popover="manual"`,
+ * which hand-wires Escape). The consumer MUST give `<skra-popover>` an `id` so `popovertarget` can
+ * reference it.
+ *
+ *   <button skraButton popovertarget="user-menu">Account</button>
+ *   <skra-popover id="user-menu"> …interactive content… </skra-popover>
+ *
+ * Forge owns only: the token-driven surface (see `popover.scss`), positioning via `SkraPositioner`
+ * (geometry-only inline; ADR 0044 §3 rules 4–5), and the disclosure ARIA on the trigger
+ * (`aria-expanded` / `aria-controls`). Focus is NOT trapped and NOT force-moved (non-modal — ADR 0044
+ * §3 rule 8); reachability + focus-return are native to the Popover API. Panel naming is the
+ * consumer's `aria-labelledby` → projected heading (ADR 033 container carve-out — no `ariaLabel`
+ * input). A right-click context menu is NOT a Popover concern (→ `skra-menu` + recipe; SRP + WCAG).
+ *
+ * Full contract: adr/specs/component-popover-spec.md.
+ */
+declare class SkraPopover {
+    /** Placement intent; `flip`/`shift` adjust at runtime. */
+    readonly placement: i0.InputSignal<SkraPlacement>;
+    private readonly host;
+    private readonly renderer;
+    /** The consumer's `[popovertarget]` button, resolved once (lazily-idempotent via `resolved`). */
+    private trigger;
+    private resolved;
+    private positioner?;
+    constructor();
+    private readonly onToggleNative;
+    private onOpen;
+    private onClose;
+    /**
+     * Resolve the `[popovertarget]` trigger and establish the disclosure ARIA on it (sanctioned a11y
+     * wiring, ADR 013-style — not style mutation). Idempotent: runs at most once. Returns the trigger
+     * (or null for an orphan popover, dev-warned once).
+     */
+    private ensureTrigger;
+    /** Read a length comp token (px/rem) off the host computed style for the positioner. */
+    private cssLenPx;
+    private teardown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraPopover, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraPopover, "skra-popover", ["skraPopover"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SkraPopover };
+//# sourceMappingURL=skra-ui-popover.d.ts.map

package/types/skra-ui-popover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-popover.d.ts","sources":["../../../../libs/ui/popover/src/lib/popover/popover.ts"],"mappings":";;;;AAoBA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACH,cAkBa,WAAW;;wBAEJA,EAAA,CAAA,WAAA,CAAA,aAAA;AAElB;AACA;;;;;;AAqBA;AAKA;AAoBA;AAQA;;;;AAIG;AACH;;AAyCA;AAaA;yCAtHW,WAAW;2CAAX,WAAW;AA8HvB;;;;","names":["_angular_core"]}

package/types/skra-ui-progress.d.ts

@@ -0,0 +1,41 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * `progress[skraProgress]` — a determinate, horizontal task-completion bar (Wave 2,
+ * `libs/ui/indicators`). Shows the known progress of a finite task (file upload, wizard
+ * "step 3 of 5", import job) as a fill from 0 → `value` / `max`.
+ *
+ * SRP-distinct from `[skraLoadingIndicator]` (ADR 028): that primitive is the
+ * *indeterminate* "host is busy" spinner injected into another component's `loading()`
+ * slot; SkraProgress is the *determinate* "task is N% complete" standalone bar. The two
+ * are complementary — see `adr/specs/component-progress-spec.md` § SRP boundary.
+ *
+ * **Why a Component on the native `<progress>` host** (ADR 040), not a `<div role="progressbar">`:
+ *  1. ADR 021 (CSP): the fill width is a continuous `value/max` length. A custom element would
+ *     force `[style.--progress-value]` (forbidden) or a class/`data-*`-per-percent hack. Native
+ *     `<progress value max>` lets the BROWSER compute the fill width on its
+ *     `::-webkit-progress-value` / `::-moz-progress-bar` pseudo — zero author inline-style.
+ *  2. Free a11y: the native host carries `role="progressbar"` + `aria-valuenow`/`-valuemin`/
+ *     `-valuemax` with no author ARIA (native-attr-first, boundary #9).
+ *
+ * Non-interactive: `<progress>` is non-focusable, so the State Surface is all-N/A (no
+ * `disabled`/`loading`/`severity` in MVP — those are deferred / belong to other atoms).
+ *
+ * Naming (ADR 033): the consumer associates a `<label for>` / `aria-labelledby` (passed through
+ * to the host). No `SkraFieldContext` injection (a progress bar is a read-only display, not a
+ * form field); no `ariaLabel` input.
+ *
+ * `value`/`max` are plain consumer-driven inputs (ADR 037 — agnostic; wire the source from any
+ * signal/form strategy). Native `<progress>` clamps `value` to `[0, max]`, so no author clamp.
+ */
+declare class SkraProgress {
+    /** Current completion, reflected to the native `value` attribute (native clamps to [0, max]). */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Upper bound, reflected to the native `max` attribute. Drives native `aria-valuemax`. */
+    readonly max: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraProgress, "progress[skraProgress]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SkraProgress };
+//# sourceMappingURL=skra-ui-progress.d.ts.map

package/types/skra-ui-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-progress.d.ts","sources":["../../../../libs/ui/progress/src/lib/progress/progress.ts"],"mappings":";;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACH,cAgBa,YAAY;;oBAET,aAAA,CAAA,WAAA;;kBAGF,aAAA,CAAA,WAAA;oDALD,YAAY;sDAAZ,YAAY;AAMxB;;;;","names":[]}

package/types/skra-ui-radio.d.ts

@@ -0,0 +1,54 @@
+import { SkraFieldContext } from '@skra/ui/field';
+import * as i0 from '@angular/core';
+
+/**
+ * Wires a native `<input type="radio">` to SkraFieldContext when inside
+ * `<skra-field>`, or stands alone with no cascade. Per ADR 039/040, Forge ships
+ * no `<skra-radio>` / `<skra-radio-group>` wrappers — this is a Component-on-
+ * the-native-host (`<input>` is void → `template: ''`, ADR 040 §2) carrying its
+ * own `radio.scss` via Emulated encapsulation. Radios are
+ * grouped via native `<fieldset skraFieldset>` + `<legend skraLegend>`,
+ * coordination happens through the shared `name` attribute (HTML-native), and
+ * one-of-N value selection is consumer-owned per ADR 037.
+ *
+ *   <fieldset skraFieldset>
+ *     <legend skraLegend>Choose plan</legend>
+ *     <skra-field>
+ *       <input type="radio" skraRadio name="plan" value="free"
+ *              [checked]="plan() === 'free'" (change)="plan.set('free')" />
+ *       <label skraLabelFor>Free</label>
+ *     </skra-field>
+ *     <skra-field>
+ *       <input type="radio" skraRadio name="plan" value="pro"
+ *              [checked]="plan() === 'pro'" (change)="plan.set('pro')" />
+ *       <label skraLabelFor>Pro</label>
+ *     </skra-field>
+ *   </fieldset>
+ *
+ * Toggle state (`checked`) is NOT reflected as `data-skra-*` — slice CSS uses
+ * the native `:checked` pseudo-class. Browser handles `aria-checked` natively.
+ */
+declare class SkraRadio {
+    private readonly el;
+    readonly context: SkraFieldContext | null;
+    constructor();
+    /**
+     * Readonly enforcement — native radio has no `[readonly]`, so without this the
+     * `aria-readonly` we announce would be a lie (the user could still change the
+     * selection). `preventDefault` on `click` blocks the selection change from both
+     * pointer and Space/Enter (keyboard activation dispatches a click on form
+     * controls). Mirrors the `<select skraSelect>` readonly guard.
+     */
+    protected blockWhenReadonly(event: Event): void;
+    /**
+     * Arrow keys move selection between radios in a `name` group WITHOUT a click,
+     * so they need a separate guard. Block every key except `Tab` (focus traversal)
+     * when readonly.
+     */
+    protected blockKeyWhenReadonly(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraRadio, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraRadio, "input[type=\"radio\"][skraRadio]", never, {}, {}, never, never, true, never>;
+}
+
+export { SkraRadio };
+//# sourceMappingURL=skra-ui-radio.d.ts.map

package/types/skra-ui-radio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-radio.d.ts","sources":["../../../../libs/ui/radio/src/lib/radio/radio.ts"],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACH,cAqBa,SAAS;AACpB;sBACgB,gBAAA;;AAehB;;;;;;AAMG;AACH,uCAAmC,KAAK;AAIxC;;;;AAIG;AACH,0CAAsC,aAAa;yCAjCxC,SAAS;2CAAT,SAAS;AAsCrB;;;;","names":[]}

package/types/skra-ui-rating-display.d.ts

@@ -0,0 +1,56 @@
+import * as _angular_core from '@angular/core';
+
+type RatingDisplaySize = 'sm' | 'md' | 'lg';
+/**
+ * `<skra-rating-display>` — a static, non-interactive **fractional** rating display
+ * ("4.3 out of 5 stars"). The read-only counterpart to `skra-star-rating` (the
+ * interactive whole-star INPUT in `libs/ui/forms`); a SEPARATE atom by atom-granularity
+ * (opposite a11y contract `role="img"` vs `radiogroup`; float vs int; no interaction).
+ * Third resident of `libs/ui/data-display`, beside Avatar + StatusDot. See
+ * `adr/specs/component-rating-display-spec.md`.
+ *
+ * **Element, not a decorated native (ADR 012):** there is no native rating element, like
+ * StatusDot/Avatar. NOT a Web Component (ADR 000).
+ *
+ * **Value consumer-owned (ADR 037):** `value` is a plain `input<number>()` (float). The atom
+ * owns no value, no `ControlValueAccessor`, no `@angular/forms`.
+ *
+ * **Fractional fill is CSP-clean (ADR 021):** the fill is QUANTIZED to a `data-skra-fill`
+ * bucket reflected on the host (`{0,5,…,100}`); the SCSS maps each bucket to the fill-overlay
+ * width. Zero `[style.--var]`, zero inline style — a bounded value is quantizable, so no
+ * geometry exception is taken. State Surface all-N/A (non-focusable display; Badge/StatusDot
+ * precedent).
+ *
+ * **Accessible name (ADR 033 Path 3 — the StatusDot/Avatar contract):** the host carries NO
+ * default ARIA. The consumer declares semantics:
+ *   - decorative (Mode A, beside a visible value like "4.3") → `aria-hidden="true"`;
+ *   - meaningful (Mode B, the stars are the sole carrier) → `role="img"` + `aria-label`
+ *     TOGETHER (e.g. `aria-label="Rated 4.3 out of 5"`).
+ * The inner star glyphs are always decorative. NO `ariaLabel` input (boundary #8) — the label
+ * is consumer-owned + localizable (the agnostic doctrine; Forge does not hard-code "out of N").
+ *
+ * **Look is skin-owned:** glyph colours + sizes come from the shared family surface
+ * (`comp/star-rating.json`). NO `intent`/`emphasis`/`color`/`variant` look-inputs.
+ */
+declare class SkraRatingDisplay {
+    /** The rating to display — FLOAT (e.g. 4.3). Consumer-owned (ADR 037); clamped to [0, max]. */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Number of stars (semantic count). */
+    readonly max: _angular_core.InputSignal<number>;
+    /** ADR 035 size axis — the only variant axis. */
+    readonly size: _angular_core.InputSignal<RatingDisplaySize>;
+    /** Star slots [1..max] — both layers render the same count. */
+    readonly stars: _angular_core.Signal<number[]>;
+    /**
+     * Fill percentage quantized to 5% buckets (`{0,5,…,100}`) — reflected as `data-skra-fill`,
+     * mapped to the overlay width by the SCSS. 4.3/5 → 86% → bucket 85 (visually exact-enough).
+     * A bounded, quantizable value is exactly what ADR 021 reflection is for — no style exception.
+     */
+    readonly fillBucket: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraRatingDisplay, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraRatingDisplay, "skra-rating-display", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SkraRatingDisplay };
+export type { RatingDisplaySize };
+//# sourceMappingURL=skra-ui-rating-display.d.ts.map

package/types/skra-ui-rating-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-rating-display.d.ts","sources":["../../../../libs/ui/rating-display/src/lib/rating-display/rating-display.ts"],"mappings":";;AAQM,KAAM,iBAAiB;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACH,cAca,iBAAiB;;oBAEd,aAAA,CAAA,WAAA;;kBAEF,aAAA,CAAA,WAAA;;mBAEC,aAAA,CAAA,WAAA,CAAA,iBAAA;;oBAGC,aAAA,CAAA,MAAA;AAKd;;;;AAIG;yBACgB,aAAA,CAAA,MAAA;oDAnBR,iBAAiB;sDAAjB,iBAAiB;AA0B7B;;;;","names":[]}

package/types/skra-ui-select.d.ts

@@ -0,0 +1,43 @@
+import * as _skra_ui_core from '@skra/ui/core';
+import { _SkraSelectBase, SkraListboxKeyboardItem } from '@skra/ui/core';
+export { SkraOption, SkraOptionDetail, SkraOptionLeading, SkraSelectTrigger } from '@skra/ui/core';
+import * as _angular_core from '@angular/core';
+
+/**
+ * SkraSelect — a custom single-select listbox: the WAI-ARIA APG **Select-Only Combobox** pattern. A
+ * value-display **trigger** (`role="combobox"`) opens a top-layer **listbox** panel (Popover API,
+ * `popover="auto"`, ADR 0044) of projected `skra-option` children. The thin single-select concrete
+ * over `_SkraSelectBase` (ADR 0046 — cardinality split): it adds the honest `value: T` channel + the
+ * replace-and-close selection model; everything else (overlay/keyboard/field substrate) lives in the
+ * shared base, shared verbatim with `skra-multi-select`.
+ *
+ * - **Value (ADR 037):** `value` is a consumer-owned `input<T>()` + `valueChange` output — NO
+ *   `@angular/forms`, no CVA. Selection is signal-derived; equality is a strategy seam (`Object.is`
+ *   default + opt-in `compareWith`).
+ * - **Trigger content (ADR 0045):** default = the selected option's `getLabel()` text (emoji/glyph
+ *   leading free); rich non-text triggers opt in via `<ng-template skraSelectTrigger>`.
+ *
+ * Full contract: adr/specs/component-select-spec.md.
+ */
+declare class SkraSelect<T = unknown> extends _SkraSelectBase<T> {
+    /** Consumer-owned value channel (ADR 037). */
+    readonly value: _angular_core.InputSignal<T | undefined>;
+    /** Fires ONLY on user selection — never on a programmatic `value()` change (ADR 037). */
+    readonly valueChange: _angular_core.OutputEmitterRef<T>;
+    /** Cardinality hint (ADR 0046) — single-select. */
+    readonly multiple = false;
+    /** The option whose value matches `value()` (ADR 037 selection model) — feeds the trigger. */
+    protected readonly selectedOption: _angular_core.Signal<_skra_ui_core.SkraOption<any> | null>;
+    protected readonly triggerContext: _angular_core.Signal<{
+        $implicit: T | undefined;
+        option: _skra_ui_core.SkraOption<any> | null;
+    }>;
+    isSelected(value: unknown): boolean;
+    selectValue(value: unknown): void;
+    protected activeSeedItem(): SkraListboxKeyboardItem | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraSelect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraSelect<any>, "skra-select", ["skraSelect"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+
+export { SkraSelect };
+//# sourceMappingURL=skra-ui-select.d.ts.map

package/types/skra-ui-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-select.d.ts","sources":["../../../../libs/ui/select/src/lib/select/select.ts"],"mappings":";;;;;AAgBA;;;;;;;;;;;;;;;AAeG;AACH,cAwDa,UAAU,sBAAsB,eAAe;;oBAE5C,aAAA,CAAA,WAAA;;0BAEM,aAAA,CAAA,gBAAA;;;;AAKpB,uCAAiC,aAAA,CAAA,MAAA,CAAA,aAAA,CAAA,UAAA;uCAIA,aAAA,CAAA,MAAA;;;AAG7B;AAGJ;AAKA;AAKA,gCAA4B,uBAAuB;oDA7BxC,UAAU;sDAAV,UAAU;AAgCtB;;;;","names":[]}

package/types/skra-ui-skeleton.d.ts

@@ -0,0 +1,42 @@
+import * as _angular_core from '@angular/core';
+
+type SkraSkeletonShape = 'text' | 'block' | 'circle';
+/**
+ * `<skra-skeleton>` — a decorative content placeholder (Wave 2, `libs/ui/indicators`).
+ * Occupies the place of not-yet-loaded content with an animated, layout-shaped placeholder so
+ * the layout does not shift on load (CLS) and the user perceives that content is coming.
+ *
+ * Third resident of the loading family, with a distinct SRP: `[skraLoadingIndicator]` (ADR 028)
+ * is the *indeterminate* "host is busy" spinner; `SkraProgress` is the *determinate* "task is
+ * N% complete" bar; **SkraSkeleton is the *content placeholder*** ("the content hasn't arrived —
+ * here is its shape"). See `adr/specs/component-skeleton-spec.md` § SRP boundary.
+ *
+ * **A custom element, NOT a Component-on-native-host** (ADR 040): a skeleton has no semantic
+ * native equivalent and is purely presentational, so it follows the custom-element atom model
+ * (Badge/Chip/Alert precedent). The host is a layout container that renders its own inner
+ * `.skra-skeleton__bar` element(s) — which is why a void-host directive was rejected: the
+ * multi-line `text` shape needs internal structure.
+ *
+ * **Decorative a11y (ADR 033):** the host is `aria-hidden="true"` — a skeleton conveys no
+ * information to assistive tech (the decorative-icon exemption). The "loading" announcement
+ * belongs to the consumer's content **container** (`aria-busy="true"`), never to the skeleton.
+ *
+ * **Sizing is container/`em`-driven (ADR 021 — the CSP reason there are no `width`/`height`
+ * inputs):** `text` line bars are `em`-relative (they inherit the surrounding font-size) at full
+ * container width; `block`/`circle` fill a host the **consumer** sizes (e.g. via `[skraBox]`).
+ * The host therefore never carries an inline `style`. State Surface all-N/A (non-interactive).
+ */
+declare class SkraSkeleton {
+    /** The kind of content faked — selects placeholder geometry, never colour/theme (not a look-input). */
+    readonly shape: _angular_core.InputSignal<SkraSkeletonShape>;
+    /** `text` only — number of line bars (multi-line paragraph). Ignored for `block`/`circle`. */
+    readonly lines: _angular_core.InputSignal<number>;
+    /** The bars to render: `lines` bars for text (≥1), a single bar for block/circle. */
+    protected readonly bars: _angular_core.Signal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraSkeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraSkeleton, "skra-skeleton", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SkraSkeleton };
+export type { SkraSkeletonShape };
+//# sourceMappingURL=skra-ui-skeleton.d.ts.map

package/types/skra-ui-skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-skeleton.d.ts","sources":["../../../../libs/ui/skeleton/src/lib/skeleton/skeleton.ts"],"mappings":";;AAQM,KAAM,iBAAiB;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACH,cAkBa,YAAY;;oBAET,aAAA,CAAA,WAAA,CAAA,iBAAA;;oBAGA,aAAA,CAAA,WAAA;;AAGd,6BAAuB,aAAA,CAAA,MAAA;oDARZ,YAAY;sDAAZ,YAAY;AAaxB;;;;","names":[]}

package/types/skra-ui-star-rating.d.ts

@@ -0,0 +1,71 @@
+import * as _angular_core from '@angular/core';
+import { SkraFieldContext } from '@skra/ui/field';
+
+type StarRatingSize = 'sm' | 'md' | 'lg';
+/**
+ * `<skra-star-rating>` — a whole-star rating **input**. An APG Rating composite
+ * (`role="radiogroup"`) rendered as stars: internally N `(input[type=radio] + label)`
+ * pairs sharing one `name`, where the label IS the star glyph (inline SVG) and the
+ * input is sr-only but focusable.
+ *
+ * Governed by the **ADR 039 §7 note (2026-06-24)**: a composite widget MAY render
+ * internal native radios — this is NOT the §3.3-forbidden `<skra-radio-group>` —
+ * because (1) value is consumer-owned (`[value]` / `(valueChange)`, controlled-only
+ * per ADR 037, the Tabs `[selected]` precedent — no internal value-of-record signal),
+ * (2) there is no `SkraRadioGroupContext`, (3) it is a distinct APG composite (like
+ * `skra-select`), not a generic radio-group wrapper. Custom element justified per
+ * ADR 012 — there is no native single host for a rating.
+ *
+ *   <skra-field [hasError]="!form.rating()">
+ *     <label skraLabelFor>Rate your experience</label>
+ *     <skra-star-rating [value]="form.rating()" (valueChange)="form.rating.set($event)" />
+ *     <skra-error>Please pick a rating</skra-error>
+ *   </skra-field>
+ *
+ * Keyboard is the **native radio group** (arrows move + select, wrap, single tab stop)
+ * — ZERO CDK. The fill + hover-preview are **pure CSS** (`:checked`/`:hover` sibling
+ * combinators) — CSP-clean (ADR 021), no `[style.--var]`, no TS for the preview. The
+ * committed `aria-checked` is the only thing AT observes; hover-preview is visual-only.
+ *
+ * Optional `SkraFieldContext` (ADR 013): the radiogroup is named via `aria-labelledby`
+ * → the field label (`SkraFieldContext.labelId`, since a radiogroup is not labelable by
+ * `for`/`id`); `disabled`/`required`/`readonly`/`invalid`/`describedby` cascade. Value is
+ * NEVER in the context (ADR 037). The `readonly` state shows a committed whole-star rating
+ * without allowing change ("show my 4★").
+ *
+ * Whole-star only (half-step input deferred). Fractional aggregate display ("4.3★") is the
+ * separate `skra-rating-display` atom (`libs/ui/data-display`).
+ */
+declare class SkraStarRating {
+    private readonly idGen;
+    readonly context: SkraFieldContext | null;
+    /** Committed rating; 0 (or out of [1,max]) = unrated. Consumer-owned, controlled (ADR 037). */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Number of stars. Semantic count, not a look-input. */
+    readonly max: _angular_core.InputSignal<number>;
+    /** ADR 035 size axis — the only variant axis. */
+    readonly size: _angular_core.InputSignal<StarRatingSize>;
+    /** Fires on USER selection only (never on programmatic [value] changes). */
+    readonly valueChange: _angular_core.OutputEmitterRef<number>;
+    private readonly fallbackName;
+    /** Unique radio-group name so multiple ratings on a page don't merge. */
+    readonly groupName: _angular_core.Signal<string>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    readonly isReadonly: _angular_core.Signal<boolean>;
+    /**
+     * Star values HIGH→LOW (`[max, …, 1]`) so the CSS sibling combinator
+     * `input:checked ~ label` fills the checked star and every lower one. The visual
+     * order is restored left-to-right via `flex-direction: row-reverse` in the SCSS.
+     */
+    readonly stars: _angular_core.Signal<number[]>;
+    protected starLabel(star: number): string;
+    protected onSelect(star: number): void;
+    protected blockWhenReadonly(event: Event): void;
+    protected blockKeyWhenReadonly(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraStarRating, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraStarRating, "skra-star-rating", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { SkraStarRating };
+export type { StarRatingSize };
+//# sourceMappingURL=skra-ui-star-rating.d.ts.map

package/types/skra-ui-star-rating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-star-rating.d.ts","sources":["../../../../libs/ui/star-rating/src/lib/star-rating/star-rating.ts"],"mappings":";;;AAYM,KAAM,cAAc;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACH,cAwBa,cAAc;AACzB;sBACgB,gBAAA;;oBAGF,aAAA,CAAA,WAAA;;kBAEF,aAAA,CAAA,WAAA;;mBAEC,aAAA,CAAA,WAAA,CAAA,cAAA;;0BAEO,aAAA,CAAA,gBAAA;AAEpB;;wBAEkB,aAAA,CAAA,MAAA;yBAIC,aAAA,CAAA,MAAA;yBACA,aAAA,CAAA,MAAA;AAEnB;;;;AAIG;oBACW,aAAA,CAAA,MAAA;AAKd;AAIA;AAMA,uCAAmC,KAAK;AAIxC,0CAAsC,aAAa;oDA9CxC,cAAc;sDAAd,cAAc;AAiD1B;;;;","names":[]}

package/types/skra-ui-status-dot.d.ts

@@ -0,0 +1,62 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * StatusDotIntent — the Variant Surface Intent axis (ADR 035 §3.1, the status palette subset).
+ * Drops the action intents `primary`/`secondary` (those belong to interactive surfaces, not a
+ * status glyph). Closed enum; extension requires an ADR 035 amendment.
+ */
+type StatusDotIntent = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+/**
+ * StatusDotSize — the Variant Surface Size axis (ADR 035 §3.1, downward subset `sm|md|lg`).
+ * `xs`/`xl` are reserved (ADR 035 §3.2) and NOT in MVP — adding them later is purely additive.
+ * Unlike content-width Badge (which has no size — its size is its text), the dot has NO content,
+ * so size is a genuine free variable the consumer needs (corner-of-`lg`-avatar vs inline-in-text).
+ */
+type StatusDotSize = 'sm' | 'md' | 'lg';
+/**
+ * `<skra-status-dot>` — a bare, small, non-interactive status/presence indicator (a coloured dot)
+ * composed beside other content: an avatar corner (online/away/busy/offline), or beside a label.
+ * Second resident of `libs/ui/data-display`, sibling to `<skra-avatar>` (whose corner presence-dot
+ * it provides). See `adr/specs/component-status-dot-spec.md`.
+ *
+ * **Element, not a decorated native (ADR 012):** there is no native `<dot>`, and a bare `<span>`
+ * carries no semantics and forces a colour literal. NOT a Web Component (ADR 000).
+ *
+ * **No content (the SRP line vs `skra-badge`):** the dot IS the glyph — no slots, no projected
+ * content, no label/count. Meaning is carried by ADJACENT text the consumer owns. The defining
+ * value-add over a hand-rolled span is the semantic `intent`→token-colour mapping (no hex — ADR
+ * 002/023) + the size axis that tracks the avatar.
+ *
+ * **Non-interactive (Avatar/Badge precedent):** no focusable node, no widget role, no keyboard, no
+ * outputs → State Surface all-N/A. A clickable status = `button[skraButton]` composition, not a
+ * variant.
+ *
+ * **Accessible name (ADR 033 Path 3 — graphic host, the SkraIcon/Avatar contract):** the host
+ * carries NO default ARIA. The consumer declares semantics explicitly, exactly as for
+ * `<skra-icon>`/`<skra-avatar>`:
+ *   - decorative (Mode A, the ~90% case — dot beside visible/sr-only status text) → `aria-hidden="true"`;
+ *   - meaningful (Mode B — the dot is the SOLE status carrier) → **`role="img"` + `aria-label`/
+ *     `aria-labelledby` TOGETHER**. `role="img"` is REQUIRED: `aria-label` on the roleless host is
+ *     ARIA-prohibited (axe `aria-prohibited-attr`, the Avatar Mode-B fix) and conveys no name.
+ * WCAG 1.4.1 (colour-independence) cannot be enforced by the atom — the adjacent text is the
+ * consumer's; the `InlineStatus`/`A11yCheck` stories carry the editorial contract. NO `ariaLabel`
+ * input (ADR 033 boundary #8).
+ *
+ * **Look is skin-owned:** circle-vs-square is the `radius` comp token (brutal's `radius.full: 0`
+ * ships a square dot automatically). The fill is the semantic `intent`→`sys.color.<intent>.base`
+ * (recolour at the sys level, not a per-dot token — skin philosophy); NO `emphasis` (always filled),
+ * NO `live` (a dot has no text to announce — the consumer's adjacent live text does), NO
+ * `color`/`variant`/`shape` look-inputs.
+ */
+declare class SkraStatusDot {
+    /** Variant Surface Intent axis (ADR 035) — the fill colour (status palette subset). */
+    readonly intent: _angular_core.InputSignal<StatusDotIntent>;
+    /** Variant Surface Size axis (ADR 035) — the dot's (colored core) diameter. */
+    readonly size: _angular_core.InputSignal<StatusDotSize>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraStatusDot, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraStatusDot, "skra-status-dot", never, { "intent": { "alias": "intent"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SkraStatusDot };
+export type { StatusDotIntent, StatusDotSize };
+//# sourceMappingURL=skra-ui-status-dot.d.ts.map

package/types/skra-ui-status-dot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-status-dot.d.ts","sources":["../../../../libs/ui/status-dot/src/lib/status-dot/status-dot.ts"],"mappings":";;AAOA;;;;AAIG;AACG,KAAM,eAAe;AAO3B;;;;;AAKG;AACG,KAAM,aAAa;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACH,cAaa,aAAa;;qBAET,aAAA,CAAA,WAAA,CAAA,eAAA;;mBAGF,aAAA,CAAA,WAAA,CAAA,aAAA;oDALF,aAAa;sDAAb,aAAa;AAMzB;;;;","names":[]}