@skra/ui 0.2.0

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

@@ -0,0 +1,196 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+
+/**
+ * SkraAccordion — the WAI-ARIA APG **Accordion** coordinator. A Component on a wrapping
+ * element that holds `[skraAccordionItem]` children (each item wraps a
+ * `button[skraAccordionHeader]` + a `[skraAccordionPanel]`). It provides
+ * `SkraAccordionContext` (the ADR 013 §3.6 non-form Contextual-ID-Sync bus), owns the
+ * consumer-facing `[expanded]` / `(expandedChange)` (controlled, ADR 037 — NO internal open
+ * state) and the `[exclusive]` policy, and draws the group's outer border + radius.
+ *
+ *   <div skraAccordion [expanded]="open()" (expandedChange)="open.set($event)">
+ *     <div skraAccordionItem value="general">
+ *       <h3><button skraAccordionHeader>General</button></h3>
+ *       <div skraAccordionPanel>…</div>
+ *     </div>
+ *     <div skraAccordionItem value="security"> … </div>
+ *   </div>
+ *
+ * Open state is consumer-owned: a header click emits `(expandedChange)` with the resolved
+ * next set (the `[exclusive]` policy applied here); the visible state updates when the
+ * consumer round-trips `[expanded]`. `[exclusive]` is a POLICY flag on an invariant
+ * `string[]` value — NOT a value-type switch, so it does not trigger ADR 0046.
+ *
+ * Full contract: adr/specs/component-accordion-spec.md.
+ */
+declare class SkraAccordion {
+    /** Consumer-owned set of OPEN item values (ADR 037). `[]` = all closed; order irrelevant. */
+    readonly expanded: _angular_core.InputSignal<readonly string[]>;
+    /** Policy: `true` → opening one item emits a set that drops the others (single-open). */
+    readonly exclusive: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Fires ONLY on user toggle — never on a programmatic `[expanded]` change. Carries the resolved next set. */
+    readonly expandedChange: _angular_core.OutputEmitterRef<readonly string[]>;
+    private readonly ctx;
+    private readonly items;
+    constructor();
+    /** A header was activated. Resolve the next open-set per the exclusive policy and REQUEST it
+     * from the consumer via `(expandedChange)` — never mutate open state internally (ADR 037). */
+    private toggleItem;
+    /** Dev-only nudge: duplicate item values collide on the shared header/panel id base. */
+    private warnDuplicateValues;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraAccordion, "[skraAccordion]", ["skraAccordion"], { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "exclusive": { "alias": "exclusive"; "required": false; "isSignal": true; }; }, { "expandedChange": "expandedChange"; }, ["items"], ["*"], true, never>;
+}
+
+/**
+ * Per-item DI context provided by `[skraAccordionItem]` (via `useExisting`). It lets
+ * `button[skraAccordionHeader]` and `[skraAccordionPanel]` read their shared `value`,
+ * derived ids, and open state **without each re-declaring `value`** — the item declares it
+ * once. All members are read-only/derived; `toggle()` forwards to the group coordinator
+ * (the open/closed set stays consumer-owned, ADR 037). `*Id` are `null` only when an item
+ * is used outside a `[skraAccordion]` (standalone misuse → dev-warned).
+ */
+declare abstract class SkraAccordionItemContext {
+    abstract readonly value: Signal<string>;
+    abstract readonly expanded: Signal<boolean>;
+    abstract readonly headerId: Signal<string | null>;
+    abstract readonly panelId: Signal<string | null>;
+    abstract toggle(): void;
+}
+
+/**
+ * SkraAccordionItem — one item, a Component on the consumer's `<div skraAccordionItem>`
+ * (ADR 040, `template: '<ng-content>'`). It declares `[value]` ONCE and provides
+ * `SkraAccordionItemContext` (via `useExisting`) so its `button[skraAccordionHeader]` and
+ * `[skraAccordionPanel]` read the shared value/ids/open-state without re-declaring it. It
+ * owns the per-item top divider (no double borders) and the open-item box (skins may tint it).
+ */
+declare class SkraAccordionItem implements SkraAccordionItemContext {
+    /** The item key — matched against `[expanded]` and the id base for its header/panel. */
+    readonly value: _angular_core.InputSignal<string>;
+    private readonly group;
+    readonly expanded: _angular_core.Signal<boolean>;
+    readonly headerId: _angular_core.Signal<string | null>;
+    readonly panelId: _angular_core.Signal<string | null>;
+    toggle(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAccordionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraAccordionItem, "[skraAccordionItem]", ["skraAccordionItem"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * SkraAccordionHeader — the heading wrapper, a Component on the consumer's heading element
+ * (`<h2 skraAccordionHeader>` … `<h6 skraAccordionHeader>` — the consumer picks the level for
+ * the document outline; ADR 012 attach-to-native). It wraps a `button[skraAccordionTrigger]`
+ * (the Radix Header+Trigger split, the way Material/Carbon/Radix all OWN the heading box rather
+ * than leaving a projected heading's UA margin to leak).
+ *
+ * Its ONLY job is to OWN the heading's box: because Forge is now the heading's host, its Emulated
+ * `:host` CSS can reset the UA heading margin (`margin: 0`) so the collapsed item hugs the
+ * trigger height — impossible to do from the item, which only sees the heading as projected
+ * content (ADR 040 cross-encapsulation limit; the same reason `_form-controls.scss` exists, but
+ * here solved structurally without a global slice). Carries no ARIA role of its own (the native
+ * heading element provides the heading semantics).
+ */
+declare class SkraAccordionHeader {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAccordionHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraAccordionHeader, "[skraAccordionHeader]", ["skraAccordionHeader"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Marker for the leading icon/element slot of `button[skraAccordionTrigger]` (the ADR 003
+ * `[skra-start]` convention). Detected via `contentChild` (ADR 020 Smart Slots v2.0) to
+ * toggle the start wrapper without emitting an empty DOM node. Lib-local (mirrors the
+ * Button/Chip per-lib marker) to avoid a cross-lib marker dependency.
+ */
+declare class SkraAccordionStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAccordionStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraAccordionStart, "[skra-start]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Marker for the optional expand/collapse indicator override of `button[skraAccordionTrigger]`.
+ * When present, it replaces the component-rendered default chevron (the ADR 028 slot+fallback
+ * idiom — here a presentation override, NOT the loading primitive).
+ */
+declare class SkraAccordionIndicator {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAccordionIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraAccordionIndicator, "[skra-accordion-indicator]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * SkraAccordionTrigger — the disclosure trigger, a Component on the native command host
+ * `button[skraAccordionTrigger]` (ADR 012/040: a `<button>` gives Enter/Space→click + focus
+ * for free — the same attach-to-native-button precedent as `button[skraButton]` / `skraTab` /
+ * `skraMenuItem`). It is wrapped by `[skraAccordionHeader]` on a heading element (Radix
+ * Header+Trigger split) so the heading owns the document outline + its own box/margin.
+ * `aria-expanded` is the canonical Toggle state (no native HTML "expanded" attribute on a button
+ * → ARIA is correct, boundary #9); the open STYLE keys off `:host([aria-expanded="true"])` (Tabs
+ * `aria-selected` precedent). value/ids/open-state come from `SkraAccordionItemContext` — the
+ * trigger declares no `value`.
+ *
+ * **Iron boundary:** no `expanded` / `ariaLabel` / `size` / `severity` inputs.
+ */
+declare class SkraAccordionTrigger {
+    private readonly ctx;
+    protected readonly startSlot: _angular_core.Signal<SkraAccordionStart | undefined>;
+    protected readonly indicatorSlot: _angular_core.Signal<SkraAccordionIndicator | undefined>;
+    protected readonly hasStart: _angular_core.Signal<boolean>;
+    protected readonly hasIndicator: _angular_core.Signal<boolean>;
+    protected readonly headerId: _angular_core.Signal<string | null>;
+    protected readonly panelId: _angular_core.Signal<string | null>;
+    protected readonly ariaExpanded: _angular_core.Signal<"true" | "false" | null>;
+    protected readonly expandedAttr: _angular_core.Signal<"" | null>;
+    protected onClick(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAccordionTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraAccordionTrigger, "button[skraAccordionTrigger]", ["skraAccordionTrigger"], {}, {}, ["startSlot", "indicatorSlot"], ["[skra-start]", "*", "[skra-accordion-indicator]"], true, never>;
+}
+
+/**
+ * SkraAccordionPanel — the disclosed region, a Component on the consumer's
+ * `<div skraAccordionPanel>` (ADR 040). `role="region"`, auto-named by `aria-labelledby`→its
+ * header. Collapse/expand is a CSS-only `grid-template-rows: 0fr↔1fr` animation driven by
+ * `data-skra-expanded` (ADR 021 — no `[style.*]`); the inner wrapper's `visibility:hidden`
+ * at the collapsed end removes content from the a11y tree + Tab order (see accordion-panel.scss).
+ * value/ids/open-state come from `SkraAccordionItemContext`.
+ */
+declare class SkraAccordionPanel {
+    private readonly ctx;
+    protected readonly panelId: _angular_core.Signal<string | null>;
+    protected readonly headerId: _angular_core.Signal<string | null>;
+    protected readonly expandedAttr: _angular_core.Signal<"" | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAccordionPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraAccordionPanel, "[skraAccordionPanel]", ["skraAccordionPanel"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * DI Context provided per `[skraAccordion]` instance — the ADR 013 §3.6 **non-form**
+ * Contextual-ID-Sync bus (the 2nd consumer of the idiom after `SkraTabsContext`). It
+ * carries **IDs + derived, read-only interaction state only** (`expanded` mirrors the
+ * consumer's `[expanded]`; `exclusive` mirrors `[exclusive]`). It **never owns value** —
+ * the open/closed set stays consumer-owned (ADR 037); a header requests a change through
+ * `toggle()`, which the coordinator implements (resolving the exclusive policy) and from
+ * which it emits `(expandedChange)`.
+ */
+declare class SkraAccordionContext {
+    /** Unique per `[skraAccordion]` — the prefix for every header/panel id in this group. */
+    private readonly baseId;
+    /** Mirror of the consumer's `[expanded]` — the set of OPEN item values (read-only to children). */
+    readonly expanded: _angular_core.WritableSignal<readonly string[]>;
+    /** Mirror of the consumer's `[exclusive]` policy (read-only to children). */
+    readonly exclusive: _angular_core.WritableSignal<boolean>;
+    headerId(value: string): string;
+    panelId(value: string): string;
+    isExpanded(value: string): boolean;
+    /** Coordinator-assigned: a header requests a toggle; the coordinator resolves the next
+     * open-set (applying the exclusive policy) and emits `(expandedChange)` — never mutated here. */
+    toggle: (value: string) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAccordionContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SkraAccordionContext>;
+}
+
+export { SkraAccordion, SkraAccordionContext, SkraAccordionHeader, SkraAccordionIndicator, SkraAccordionItem, SkraAccordionItemContext, SkraAccordionPanel, SkraAccordionStart, SkraAccordionTrigger };
+//# sourceMappingURL=skra-ui-accordion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-accordion.d.ts","sources":["../../../../libs/ui/accordion/src/lib/accordion/accordion.ts","../../../../libs/ui/accordion/src/lib/accordion/accordion-item-context.ts","../../../../libs/ui/accordion/src/lib/accordion/accordion-item.ts","../../../../libs/ui/accordion/src/lib/accordion/accordion-header.ts","../../../../libs/ui/accordion/src/lib/accordion/accordion.directives.ts","../../../../libs/ui/accordion/src/lib/accordion/accordion-trigger.ts","../../../../libs/ui/accordion/src/lib/accordion/accordion-panel.ts","../../../../libs/ui/accordion/src/lib/accordion/accordion-context.ts"],"mappings":";;;AAiBA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACH,cAUa,aAAa;;uBAEP,aAAA,CAAA,WAAA;;wBAEC,aAAA,CAAA,wBAAA;;6BAEK,aAAA,CAAA,gBAAA;AAEvB;AACA;;AAiBA;AAC8F;AAC9F;;AAaA;oDAzCW,aAAa;sDAAb,aAAa;AAqDzB;;ACrGD;;;;;;;AAOG;AACH,uBAAsB,wBAAwB;6BACnB,MAAM;gCACH,MAAM;gCACN,MAAM;+BACP,MAAM;;AAElC;;ACFD;;;;;;AAMG;AACH,cAea,iBAAkB,YAAW,wBAAwB;;oBAElD,aAAA,CAAA,WAAA;AAEd;uBAEiB,aAAA,CAAA,MAAA;uBAGA,aAAA,CAAA,MAAA;sBAGD,aAAA,CAAA,MAAA;AAEhB;;oDAdW,iBAAiB;sDAAjB,iBAAiB;AA4B7B;;ACtDD;;;;;;;;;;;;;AAaG;AACH,cASa,mBAAmB;;oDAAnB,mBAAmB;sDAAnB,mBAAmB;AAc/B;;AC7CD;;;;;AAKG;AACH,cAIa,kBAAkB;oDAAlB,kBAAkB;sDAAlB,kBAAkB;AAAG;AAElC;;;;AAIG;AACH,cAIa,sBAAsB;oDAAtB,sBAAsB;sDAAtB,sBAAsB;AAAG;;ACNtC;;;;;;;;;;;;AAYG;AACH,cAmBa,oBAAoB;AAC/B;AAGA,kCAA4B,aAAA,CAAA,MAAA,CAAA,kBAAA;AAC5B,sCAAgC,aAAA,CAAA,MAAA,CAAA,sBAAA;AAChC,iCAA2B,aAAA,CAAA,MAAA;AAC3B,qCAA+B,aAAA,CAAA,MAAA;AAG/B,iCAA2B,aAAA,CAAA,MAAA;AAC3B,gCAA0B,aAAA,CAAA,MAAA;AAC1B,qCAA+B,aAAA,CAAA,MAAA;AAG/B,qCAA+B,aAAA,CAAA,MAAA;;;oDAfpB,oBAAoB;sDAApB,oBAAoB;AAiChC;;ACtED;;;;;;;AAOG;AACH,cAgBa,kBAAkB;AAC7B;AAEA,gCAA0B,aAAA,CAAA,MAAA;AAC1B,iCAA2B,aAAA,CAAA,MAAA;AAC3B,qCAA+B,aAAA,CAAA,MAAA;;oDALpB,kBAAkB;sDAAlB,kBAAkB;AAmB9B;;AC1CD;;;;;;;;AAQG;AACH,cACa,oBAAoB;;AAE/B;;uBAGiB,aAAA,CAAA,cAAA;;wBAEC,aAAA,CAAA,cAAA;AAElB;AAGA;AAGA;AAIA;AACiG;AACjG;oDArBW,oBAAoB;wDAApB,oBAAoB;AAsBhC;;;;","names":[]}

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

@@ -0,0 +1,81 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Marker directive for the leading icon slot of `<skra-alert>`.
+ * Detected via `contentChild` (ADR 020 Smart Slots v2.0) to toggle the icon
+ * wrapper without emitting an empty DOM node. Feedback-local (not the button
+ * lib's `[skra-start]`) to avoid a cross-lib marker dependency.
+ */
+declare class SkraAlertIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAlertIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraAlertIcon, "[skra-alert-icon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Marker directive for the OPTIONAL title slot of `<skra-alert>` — a short, bold
+ * heading rendered above the message. Detected via `contentChild` (ADR 020) to
+ * toggle the title row. It is styled bold via a typography role but is NOT a
+ * semantic heading (`<h*>`): an alert title is not part of the document outline,
+ * and a heading would pollute screen-reader heading navigation (especially for a
+ * dynamically-injected alert). The live region announces title + body atomically.
+ */
+declare class SkraAlertTitle {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAlertTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraAlertTitle, "[skra-alert-title]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * AlertIntent — semantic feedback meaning (ADR 035 §3.1, downward subset).
+ * Excludes the action intents `primary`/`secondary` (meaningless for a status
+ * message). Closed enum; extension requires an ADR 035 amendment.
+ */
+type AlertIntent = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+/**
+ * AlertEmphasis — visual loudness within the chosen intent (ADR 035 §3.1, subset).
+ * `high` = filled banner, `medium` = soft/tinted. `low` deferred.
+ */
+type AlertEmphasis = 'high' | 'medium';
+/**
+ * AlertLive — screen-reader announcement politeness (ADR 0052). Maps to the
+ * implicit-live ARIA role; politeness is a property of USE (static vs injected),
+ * NOT of intent.
+ */
+type AlertLive = 'off' | 'polite' | 'assertive';
+/**
+ * `<skra-alert>` — in-content, page/section-level feedback message (Feedback/Status
+ * family, ADR 0052). Serves BOTH a static notification (`live="off"`, present at load)
+ * and a dynamically-injected alert (`live="polite"|"assertive"`, announced on insertion).
+ *
+ * SRP-distinct from `<skra-error>` (form-validation-bound, `SkraFieldContext`, error-only).
+ *
+ * Announcement (ADR 0052): the `live` input maps to the implicit-live ARIA role
+ * (`status`/`alert`) — which carries `aria-live` + `aria-atomic` implicitly. NO explicit
+ * `aria-live` is set (that would be redundant/contradictory; the `skra-error` pattern).
+ *
+ * Dismissal: `dismissible` renders a built-in close control that emits `(dismissed)`.
+ * Forge does NOT remove itself from the DOM — the consumer owns removal via `@if`
+ * (agnostic-atom doctrine). The close control's accessible name comes from a projected
+ * `[skra-alert-close-label]` (sr-only; ADR 033 Path 2) — the "×" glyph is `aria-hidden`.
+ */
+declare class SkraAlert {
+    readonly intent: _angular_core.InputSignal<AlertIntent>;
+    readonly emphasis: _angular_core.InputSignal<AlertEmphasis>;
+    readonly live: _angular_core.InputSignal<AlertLive>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    readonly iconSlot: _angular_core.Signal<SkraAlertIcon | undefined>;
+    readonly hasIcon: _angular_core.Signal<boolean>;
+    readonly titleSlot: _angular_core.Signal<SkraAlertTitle | undefined>;
+    readonly hasTitle: _angular_core.Signal<boolean>;
+    /**
+     * Map `live` politeness to the implicit-live ARIA role (ADR 0052). The role
+     * carries `aria-live` + `aria-atomic` implicitly; `off` → no live region.
+     */
+    readonly liveRole: _angular_core.Signal<"alert" | "status" | null>;
+    protected onDismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAlert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraAlert, "skra-alert", never, { "intent": { "alias": "intent"; "required": false; "isSignal": true; }; "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, ["iconSlot", "titleSlot"], ["[skra-alert-icon]", "[skra-alert-title]", "*", "[skra-alert-close-label]"], true, never>;
+}
+
+export { SkraAlert, SkraAlertIcon, SkraAlertTitle };
+export type { AlertEmphasis, AlertIntent, AlertLive };
+//# sourceMappingURL=skra-ui-alert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-alert.d.ts","sources":["../../../../libs/ui/alert/src/lib/alert.directives.ts","../../../../libs/ui/alert/src/lib/alert/alert.ts"],"mappings":";;AAEA;;;;;AAKG;AACH,cAIa,aAAa;oDAAb,aAAa;sDAAb,aAAa;AAAG;AAE7B;;;;;;;AAOG;AACH,cAIa,cAAc;oDAAd,cAAc;sDAAd,cAAc;AAAG;;ACd9B;;;;AAIG;AACG,KAAM,WAAW;AAEvB;;;AAGG;KACS,aAAa;AAEzB;;;;AAIG;AACG,KAAM,SAAS;AAErB;;;;;;;;;;;;;;;AAeG;AACH,cAqBa,SAAS;qBAEL,aAAA,CAAA,WAAA,CAAA,WAAA;uBACE,aAAA,CAAA,WAAA,CAAA,aAAA;mBAGJ,aAAA,CAAA,WAAA,CAAA,SAAA;0BAGO,aAAA,CAAA,wBAAA;wBACF,aAAA,CAAA,gBAAA;uBAGD,aAAA,CAAA,MAAA,CAAA,aAAA;sBACD,aAAA,CAAA,MAAA;wBAEE,aAAA,CAAA,MAAA,CAAA,cAAA;uBACD,aAAA,CAAA,MAAA;AAEjB;;;AAGG;uBACc,aAAA,CAAA,MAAA;;oDAvBN,SAAS;sDAAT,SAAS;AAqCrB;;;;","names":[]}

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

@@ -0,0 +1,71 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * AvatarSize — 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
+ * (new enum values + token rows, zero migration). Closed enum; extension requires an ADR 035
+ * amendment. See `adr/specs/component-avatar-spec.md` OQ 1.
+ */
+type AvatarSize = 'sm' | 'md' | 'lg';
+/**
+ * `<skra-avatar>` — a compact graphical representation of a person/entity: a photo with a
+ * graceful fallback to projected **initials** or an **icon** when the image is absent or fails
+ * to load. First resident of `libs/ui/data-display` (the identity/media-display family). See
+ * `adr/specs/component-avatar-spec.md`.
+ *
+ * **Element, not a decorated native (ADR 012):** there is no native `<avatar>`, and a bare
+ * `<img>` has nowhere to render the text/icon fallback — so Forge owns a container that
+ * conditionally renders an internal `<img>` OR the projected fallback. NOT a Web Component
+ * (ADR 000).
+ *
+ * **Image + fallback (the defining value-add):** Forge owns the internal `<img>` (rendered from
+ * the `src` *data* input — value not look, ADR 037, agnostic) so it can observe `(error)`/`(load)`
+ * and swap to the projected fallback. The swap is internal presentational logic, NOT an ADR 028
+ * `loading` operation (no `aria-busy`, no `[skraLoadingIndicator]`). SSR-safe: pure signals +
+ * template; on the server the `<img>` renders, the client swaps on error.
+ *
+ * **Non-interactive (Badge precedent):** no focusable node, no role, no keyboard, no outputs →
+ * State Surface all-N/A. A clickable avatar is `button[skraButton]`/`a[skraLink]` wrapping
+ * `<skra-avatar>` (composition), not a variant.
+ *
+ * **Accessible name (ADR 033 Path 3 — graphic host, the SkraIcon/ADR 034 §3.4 contract):** the
+ * inner content is **always decorative** — the internal `<img>` is `alt=""` and the fallback
+ * wrapper is `aria-hidden` — and the host carries **NO default ARIA**. The consumer declares
+ * semantics explicitly, exactly as for `<skra-icon>`:
+ *   - decorative (Mode A, the ~90% case — avatar beside a visible name) → `aria-hidden="true"`;
+ *   - meaningful (Mode B — standalone) → **`role="img"` + `aria-label`/`aria-labelledby` TOGETHER**.
+ *     `role="img"` is REQUIRED: `aria-label` on the roleless custom-element host is ARIA-prohibited
+ *     (axe `aria-prohibited-attr`) and conveys no name. Forge does NOT auto-set the role (parity
+ *     with SkraIcon — host owns no default ARIA).
+ * NO `ariaLabel` input (ADR 033 boundary #8), NO `name`/`alt` input (no initials derivation —
+ * agnostic; the name survives image failure by living on the host, not on the swapped-out img).
+ *
+ * **Look is skin-owned:** circle-vs-square is the `radius` comp token (a skin with
+ * `sys.radius.full: 0` — e.g. brutal — ships square avatars automatically). NO `shape`/`color`/
+ * `variant` look-inputs (skin philosophy). NO `intent`/`emphasis` (a neutral identity graphic —
+ * status colour is the sibling StatusDot's job, SRP).
+ */
+declare class SkraAvatar {
+    /**
+     * Image URL — a data input (ADR 037; agnostic). Absent or failed-to-load → the projected
+     * fallback (initials / icon) shows.
+     */
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    /** Variant Surface Size axis (ADR 035) — the square box dimension + initials scale. */
+    readonly size: _angular_core.InputSignal<AvatarSize>;
+    /**
+     * The `src` value that failed to load, if any. Keyed by URL (not a boolean) so that changing
+     * `src` to a new URL re-attempts the image instead of staying on the fallback.
+     */
+    private readonly failedSrc;
+    /** Whether the internal `<img>` should render (a `src` is set and has not failed). */
+    readonly showImage: _angular_core.Signal<boolean>;
+    /** The `<img>` failed to load → fall back to the projected content. */
+    protected onImageError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraAvatar, "skra-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SkraAvatar };
+export type { AvatarSize };
+//# sourceMappingURL=skra-ui-avatar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-avatar.d.ts","sources":["../../../../libs/ui/avatar/src/lib/avatar/avatar.ts"],"mappings":";;AASA;;;;;AAKG;AACG,KAAM,UAAU;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACH,cAea,UAAU;AACrB;;;AAGG;kBACS,aAAA,CAAA,WAAA;;mBAGC,aAAA,CAAA,WAAA,CAAA,UAAA;AAEb;;;AAGG;AACH;;wBAGkB,aAAA,CAAA,MAAA;;;oDAjBP,UAAU;sDAAV,UAAU;AA0BtB;;;;","names":[]}

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

@@ -0,0 +1,73 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Marker directive for the OPTIONAL leading icon/dot slot of `<skra-badge>`.
+ * Detected via `contentChild` (ADR 020 Smart Slots v2.0) to toggle the icon
+ * wrapper without emitting an empty DOM node. Feedback-local (not the button
+ * lib's `[skra-start]`) to avoid a cross-lib marker dependency, mirroring
+ * `[skra-alert-icon]`.
+ *
+ * The icon is decorative — the consumer sets `aria-hidden` on its content (ADR
+ * 034). The badge's visible text label still carries the meaning (WCAG 1.4.1):
+ * a leading dot enables the `● Active` pattern but never substitutes for the word.
+ */
+declare class SkraBadgeIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraBadgeIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraBadgeIcon, "[skra-badge-icon]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * BadgeIntent — semantic feedback meaning (ADR 035 §3.1, downward subset).
+ * Excludes the action intents `primary`/`secondary` (meaningless for a status
+ * indicator). Closed enum; extension requires an ADR 035 amendment.
+ */
+type BadgeIntent = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+/**
+ * BadgeEmphasis — visual loudness within the chosen intent (ADR 035 §3.1, subset).
+ * `high` = filled chip, `medium` = soft/tinted lozenge. `low` deferred.
+ */
+type BadgeEmphasis = 'high' | 'medium';
+/**
+ * BadgeLive — screen-reader announcement politeness (ADR 0052). Maps to the
+ * implicit-live ARIA role; politeness is a property of USE (static status vs a
+ * live notification count), NOT of intent. Default `off` (the static-status case).
+ */
+type BadgeLive = 'off' | 'polite' | 'assertive';
+/**
+ * `<skra-badge>` — a small, inline, non-interactive status indicator (Feedback/Status
+ * family, ADR 0052). Carries semantic importance (intent) as a short label or count —
+ * e.g. a status lozenge (`Active`/`Failed`) in a table, or a notification count.
+ *
+ * SRP-distinct from `<skra-counter>` (form value-bound character counter, `libs/ui/forms`)
+ * and from the closable `Tag/Chip` (interactive/dismissible — a different SRP, Wave 2).
+ *
+ * Non-interactive: no focusable node, no widget role, no keyboard, no outputs. The host is
+ * a presentational surface; severity is a Variant Surface axis (ADR 035), not a State (ADR 027).
+ *
+ * Announcement (ADR 0052): the `live` input maps to the implicit-live ARIA role
+ * (`status`/`alert`) — which carries `aria-live` + `aria-atomic` implicitly. NO explicit
+ * `aria-live` is set (that would be redundant; the `skra-alert`/`skra-error` pattern).
+ * When `live ≠ off`, the content must be self-describing (`3 unread`, not a bare `3`) — the
+ * role announces the whole badge atomically.
+ *
+ * Positioning (ADR 022): the badge owns no outer position. Overlaying it on a host's corner
+ * (a notification badge) is a consumer composition, not an atom responsibility.
+ */
+declare class SkraBadge {
+    readonly intent: _angular_core.InputSignal<BadgeIntent>;
+    readonly emphasis: _angular_core.InputSignal<BadgeEmphasis>;
+    readonly live: _angular_core.InputSignal<BadgeLive>;
+    readonly iconSlot: _angular_core.Signal<SkraBadgeIcon | undefined>;
+    readonly hasIcon: _angular_core.Signal<boolean>;
+    /**
+     * Map `live` politeness to the implicit-live ARIA role (ADR 0052). The role
+     * carries `aria-live` + `aria-atomic` implicitly; `off` → no live region.
+     */
+    readonly liveRole: _angular_core.Signal<"alert" | "status" | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraBadge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraBadge, "skra-badge", never, { "intent": { "alias": "intent"; "required": false; "isSignal": true; }; "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; }, {}, ["iconSlot"], ["[skra-badge-icon]", "*"], true, never>;
+}
+
+export { SkraBadge, SkraBadgeIcon };
+export type { BadgeEmphasis, BadgeIntent, BadgeLive };
+//# sourceMappingURL=skra-ui-badge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-badge.d.ts","sources":["../../../../libs/ui/badge/src/lib/badge.directives.ts","../../../../libs/ui/badge/src/lib/badge/badge.ts"],"mappings":";;AAEA;;;;;;;;;;AAUG;AACH,cAIa,aAAa;oDAAb,aAAa;sDAAb,aAAa;AAAG;;ACP7B;;;;AAIG;AACG,KAAM,WAAW;AAEvB;;;AAGG;KACS,aAAa;AAEzB;;;;AAIG;AACG,KAAM,SAAS;AAErB;;;;;;;;;;;;;;;;;;;AAmBG;AACH,cAoBa,SAAS;qBAEL,aAAA,CAAA,WAAA,CAAA,WAAA;uBACE,aAAA,CAAA,WAAA,CAAA,aAAA;mBAGJ,aAAA,CAAA,WAAA,CAAA,SAAA;uBAGI,aAAA,CAAA,MAAA,CAAA,aAAA;sBACD,aAAA,CAAA,MAAA;AAEhB;;;AAGG;uBACc,aAAA,CAAA,MAAA;oDAhBN,SAAS;sDAAT,SAAS;AA0BrB;;;;","names":[]}

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

@@ -0,0 +1,45 @@
+import * as _angular_core from '@angular/core';
+import { SkraLoadingIndicator } from '@skra/ui/loading-indicator';
+
+declare class SkraButtonStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraButtonStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraButtonStart, "[skra-start]", never, {}, {}, never, never, true, never>;
+}
+declare class SkraButtonEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraButtonEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraButtonEnd, "[skra-end]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * ButtonIntent — semantic role of the action (ADR 035 §3.1).
+ * Closed enum; extension requires amendment to ADR 035.
+ */
+type ButtonIntent = 'neutral' | 'primary' | 'secondary' | 'info' | 'success' | 'warning' | 'danger';
+/**
+ * ButtonEmphasis — visual loudness within the chosen intent (ADR 035 §3.1).
+ * Skin maps each level to its own treatment (filled / outlined / ghost / other).
+ */
+type ButtonEmphasis = 'high' | 'medium' | 'low';
+/**
+ * ButtonSize — per-instance scale relative to typography and spacing (ADR 035 §3.1).
+ * Distinct from Density (ADR 016 §3.5), which is subtree-runtime.
+ */
+type ButtonSize = 'sm' | 'md' | 'lg';
+declare class SkraButton {
+    readonly intent: _angular_core.InputSignal<ButtonIntent>;
+    readonly emphasis: _angular_core.InputSignal<ButtonEmphasis>;
+    readonly size: _angular_core.InputSignal<ButtonSize>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly startSlot: _angular_core.Signal<SkraButtonStart | undefined>;
+    readonly endSlot: _angular_core.Signal<SkraButtonEnd | undefined>;
+    readonly hasStart: _angular_core.Signal<boolean>;
+    readonly hasEnd: _angular_core.Signal<boolean>;
+    readonly loadingIndicatorSlot: _angular_core.Signal<SkraLoadingIndicator | undefined>;
+    readonly hasLoadingIndicator: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraButton, "button[skraButton]", never, { "intent": { "alias": "intent"; "required": false; "isSignal": true; }; "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, ["startSlot", "endSlot", "loadingIndicatorSlot"], ["[skra-start]", "*", "[skra-end]", "[skraLoadingIndicator]"], true, never>;
+}
+
+export { SkraButton, SkraButtonEnd, SkraButtonStart };
+export type { ButtonEmphasis, ButtonIntent, ButtonSize };
+//# sourceMappingURL=skra-ui-button.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-button.d.ts","sources":["../../../../libs/ui/button/src/lib/button.directives.ts","../../../../libs/ui/button/src/lib/button/button.ts"],"mappings":";;;AAEA,cAIa,eAAe;oDAAf,eAAe;sDAAf,eAAe;AAAG;AAE/B,cAIa,aAAa;oDAAb,aAAa;sDAAb,aAAa;AAAG;;ACA7B;;;AAGG;KACS,YAAY;AASxB;;;AAGG;AACG,KAAM,cAAc;AAE1B;;;AAGG;AACG,KAAM,UAAU;AAEtB,cAsBa,UAAU;qBAEN,aAAA,CAAA,WAAA,CAAA,YAAA;uBACE,aAAA,CAAA,WAAA,CAAA,cAAA;mBACJ,aAAA,CAAA,WAAA,CAAA,UAAA;sBAGG,aAAA,CAAA,wBAAA;wBAGE,aAAA,CAAA,MAAA,CAAA,eAAA;sBACF,aAAA,CAAA,MAAA,CAAA,aAAA;uBAEC,aAAA,CAAA,MAAA;qBACF,aAAA,CAAA,MAAA;mCAGc,aAAA,CAAA,MAAA,CAAA,oBAAA;kCACD,aAAA,CAAA,MAAA;oDAlBjB,UAAU;sDAAV,UAAU;AAmBtB;;;;","names":[]}

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

@@ -0,0 +1,52 @@
+import * as i0 from '@angular/core';
+import { SkraFieldContext } from '@skra/ui/field';
+
+/**
+ * Wires a native `<input type="checkbox">` to SkraFieldContext when inside
+ * `<skra-field>` (ADR 013), or stands alone with no cascade. Per ADR 039/040,
+ * Forge ships no `<skra-checkbox>` wrapper — this is a Component-on-the-native-
+ * host (`<input>` is void → `template: ''`, ADR 040 §2) carrying its own
+ * `checkbox.scss` via Emulated encapsulation. Value channel stays consumer-owned
+ * per ADR 037: bind
+ * via native `[checked]` + `(change)`, Reactive Forms `formControlName`,
+ * Signal Forms `[formField]`, or `[(ngModel)]` — all work orthogonally with
+ * this directive (which only handles a11y + skin context).
+ *
+ *   <!-- inside Field -->
+ *   <skra-field>
+ *     <input type="checkbox" skraCheckbox [checked]="x()" (change)="x.set($any($event.target).checked)" />
+ *     <label skraLabelFor>Accept ToS</label>
+ *   </skra-field>
+ *
+ *   <!-- standalone (label wraps input — no id/for needed) -->
+ *   <label>
+ *     <input type="checkbox" skraCheckbox [checked]="x()" (change)="x.set($any($event.target).checked)" />
+ *     Accept ToS
+ *   </label>
+ *
+ * Toggle state (`checked`, `indeterminate`) is NOT reflected as `data-skra-*`
+ * — that would require Forge to observe native state, violating ADR 037. Slice
+ * CSS targets native `:checked` and `:indeterminate` pseudo-classes directly;
+ * browsers handle `aria-checked` natively (including `"mixed"` for indeterminate).
+ */
+declare class SkraCheckbox {
+    private readonly el;
+    readonly context: SkraFieldContext | null;
+    readonly indeterminate: i0.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    /**
+     * Readonly enforcement — native checkbox has no `[readonly]`, so without this
+     * the `aria-readonly` we announce would be a lie (the user could still toggle
+     * it). `preventDefault` on `click` blocks the toggle from both pointer and
+     * Space/Enter (keyboard activation dispatches a click on form controls).
+     * Mirrors the `<select skraSelect>` / `skraRadio` readonly guards.
+     */
+    protected blockWhenReadonly(event: Event): void;
+    /** Block keyboard activation (Space) when readonly; let `Tab` through. */
+    protected blockKeyWhenReadonly(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraCheckbox, "input[type=\"checkbox\"][skraCheckbox]", never, { "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SkraCheckbox };
+//# sourceMappingURL=skra-ui-checkbox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-checkbox.d.ts","sources":["../../../../libs/ui/checkbox/src/lib/checkbox/checkbox.ts"],"mappings":";;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACH,cAqBa,YAAY;AACvB;sBACgB,gBAAA;4BAKMA,EAAA,CAAA,wBAAA;;AAsBtB;;;;;;AAMG;AACH,uCAAmC,KAAK;;AAKxC,0CAAsC,aAAa;yCAzCxC,YAAY;2CAAZ,YAAY;AA8CxB;;;;","names":["_angular_core"]}

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

@@ -0,0 +1,60 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Marker directive for the leading icon/dot/avatar slot of `<skra-chip>`.
+ * Detected via `contentChild` (ADR 020 Smart Slots v2.0) to toggle the icon
+ * wrapper without emitting an empty DOM node. Feedback-local (mirrors
+ * `SkraBadgeIcon`/`SkraAlertIcon`) to avoid a cross-lib marker dependency.
+ */
+declare class SkraChipIcon {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraChipIcon, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkraChipIcon, "[skra-chip-icon]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * ChipIntent — semantic meaning (ADR 035 §3.1, downward subset). Excludes the
+ * action intents `primary`/`secondary` (meaningless for a status/category pill).
+ * Closed enum; extension requires an ADR 035 amendment.
+ */
+type ChipIntent = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+/**
+ * ChipEmphasis — visual loudness within the chosen intent (ADR 035 §3.1, subset).
+ * `high` = filled pill, `medium` = soft/tinted. `low` deferred.
+ */
+type ChipEmphasis = 'high' | 'medium';
+/**
+ * `<skra-chip>` — a small, inline, **removable** labelled pill (Feedback/Status
+ * family, Wave 2): a selected multi-select value, an applied filter, an input tag.
+ * The host is a non-interactive presentational pill (the label is plain text, no
+ * host role/focus); it contains exactly ONE interactive sub-control — the built-in
+ * remove `<button>` (the Alert dismiss precedent).
+ *
+ * SRP-distinct from `<skra-badge>` (a NON-removable status pill): the remove
+ * control is intrinsic to Chip — there is no `removable` flag, because a chip
+ * without it would be a Badge. A SELECTABLE/filter chip (a toggle) is a SEPARATE
+ * deferred atom (ARCHITECTURE_BACKLOG watch-list), NOT a `selectable` variant —
+ * one atom carrying both interaction models is an SRP smell.
+ *
+ * No `live` axis (unlike Badge/Alert): a chip is an input/selection element, not a
+ * status announcer; add/remove announcements are the consumer's own `aria-live`.
+ *
+ * Removal (ADR 037): the remove control fires `(removed)`. Forge does NOT remove
+ * itself from the DOM — the consumer owns removal (splice the bound array / `@if`).
+ * The remove control's accessible name comes from a projected
+ * `[skra-chip-remove-label]` (sr-only; ADR 033 Path 2) — the "×" glyph is `aria-hidden`.
+ */
+declare class SkraChip {
+    readonly intent: _angular_core.InputSignal<ChipIntent>;
+    readonly emphasis: _angular_core.InputSignal<ChipEmphasis>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    readonly iconSlot: _angular_core.Signal<SkraChipIcon | undefined>;
+    readonly hasIcon: _angular_core.Signal<boolean>;
+    protected onRemove(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraChip, "skra-chip", never, { "intent": { "alias": "intent"; "required": false; "isSignal": true; }; "emphasis": { "alias": "emphasis"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, ["iconSlot"], ["[skra-chip-icon]", "*", "[skra-chip-remove-label]"], true, never>;
+}
+
+export { SkraChip, SkraChipIcon };
+export type { ChipEmphasis, ChipIntent };
+//# sourceMappingURL=skra-ui-chip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-chip.d.ts","sources":["../../../../libs/ui/chip/src/lib/chip.directives.ts","../../../../libs/ui/chip/src/lib/chip/chip.ts"],"mappings":";;AAEA;;;;;AAKG;AACH,cAIa,YAAY;oDAAZ,YAAY;sDAAZ,YAAY;AAAG;;ACA5B;;;;AAIG;AACG,KAAM,UAAU;AAEtB;;;AAGG;KACS,YAAY;AAExB;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,cAsBa,QAAQ;qBAEJ,aAAA,CAAA,WAAA,CAAA,UAAA;uBACE,aAAA,CAAA,WAAA,CAAA,YAAA;uBAGA,aAAA,CAAA,wBAAA;sBAGD,aAAA,CAAA,gBAAA;uBAGC,aAAA,CAAA,MAAA,CAAA,YAAA;sBACD,aAAA,CAAA,MAAA;;oDAbL,QAAQ;sDAAR,QAAQ;AAmBpB;;;;","names":[]}