@skra/ui 0.2.0

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

@@ -0,0 +1,59 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * DialogSize — width bucket (Variant Surface, ADR 035 Size axis).
+ * Closed enum; extension requires an ADR 035 amendment.
+ */
+type DialogSize = 'sm' | 'md' | 'lg';
+/**
+ * SkraDialog — a Component on the native `<dialog>` host (ADR 012/040/041), rendered in the
+ * browser TOP LAYER via `showModal()` (ADR 0044 — no portal, no z-index, dependency-free).
+ *
+ * Forge owns the token-driven surface + size + enter/leave motion (see `dialog.scss`) and the
+ * focus contract (ADR 0044 §3 rule 8): deterministic INITIAL focus via the native `autofocus`
+ * attribute (consumer-placed), plus a focus-RETURN safety net. Open/closed state, `role="dialog"`,
+ * `aria-modal`, Escape, the `::backdrop` scrim, scroll-lock and focus containment are NATIVE
+ * (the scrim + scroll-lock live in the global `_overlay.scss` slice). Accessible name is consumer
+ * `aria-labelledby` → projected heading (ADR 033 container carve-out — no `ariaLabel` input).
+ *
+ * Full contract: adr/specs/component-dialog-spec.md.
+ */
+declare class SkraDialog {
+    /** Width bucket (ADR 035). No look inputs (ADR 025); no `ariaLabel` (ADR 033). */
+    readonly size: _angular_core.InputSignal<DialogSize>;
+    /**
+     * Emitted from `showModal()` once the dialog has entered the top layer. Fills a genuine
+     * NATIVE GAP — `<dialog>` fires no "open" event, so the dialog's owner otherwise cannot
+     * observe opening decoupled from whoever called `showModal()` (lazy content, analytics, …).
+     *
+     * There is deliberately NO `closed`/`cancel` output (native-first, boundary #9): the native
+     * `<dialog>` `(close)`/`(cancel)` events already serve the owner directly on the element
+     * (with `returnValue`). A Forge output would duplicate a native event.
+     */
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    private readonly host;
+    private previouslyFocused;
+    /** Native `.open` state (read-only proxy; open/closed stays native — ADR 0044). */
+    get open(): boolean;
+    /** Open as a modal: store the trigger for focus-return, then native `showModal()`. */
+    showModal(): void;
+    /** Close the dialog. The native `close` event drives focus-return (see `onClose`). */
+    close(returnValue?: string): void;
+    /** Restore focus to the trigger on any close path (Escape / form submit / `close()`). */
+    protected onClose(): void;
+    /**
+     * Wrap Tab focus within the modal (ADR 0044 §3 rule 8). Native `showModal()` makes the
+     * background `inert` but does NOT cycle Tab last<->first and lets focus leave an enclosing
+     * iframe / micro-frontend boundary — the WCAG-over-native gap this minimal JS closes. Modal
+     * only (`:modal`); non-modal open dialogs are not trapped. Host-scoped DOM access only.
+     */
+    protected onKeydown(event: KeyboardEvent): void;
+    /** Dev-only a11y nudge: native default initial focus is inconsistent without `autofocus`. */
+    private warnIfNoFocusTarget;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraDialog, "dialog[skraDialog]", ["skraDialog"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "opened": "opened"; }, never, ["*"], true, never>;
+}
+
+export { SkraDialog };
+export type { DialogSize };
+//# sourceMappingURL=skra-ui-dialog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-dialog.d.ts","sources":["../../../../libs/ui/dialog/src/lib/dialog/dialog.ts"],"mappings":";;AAUA;;;AAGG;AACG,KAAM,UAAU;AAsBtB;;;;;;;;;;;;AAYG;AACH,cAmBa,UAAU;;mBAER,aAAA,CAAA,WAAA,CAAA,UAAA;AAEb;;;;;;;;AAQG;qBACY,aAAA,CAAA,gBAAA;AAEf;;;;;AASA;;AAUA;;;AAYA;;;;;AAKG;AACH,+BAA2B,aAAa;;AAwBxC;oDA5EW,UAAU;sDAAV,UAAU;AAyFtB;;;;","names":[]}

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

@@ -0,0 +1,181 @@
+import * as i0 from '@angular/core';
+import { OnInit } from '@angular/core';
+
+/**
+ * Root-level service generating unique, short IDs for form elements.
+ * Implements ADR 013 — deterministic IDs without bloaty UUID libraries.
+ */
+declare class IdGeneratorService {
+    private counter;
+    nextId(prefix?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdGeneratorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdGeneratorService>;
+}
+
+/**
+ * DI Context service provided per SkraField instance.
+ * Acts as the synchronization bus between Field, Input, Label, Hint, and Error.
+ * Implements ADR 013: Signal-based Contextual Interaction.
+ */
+declare class SkraFieldContext {
+    readonly fieldId: i0.WritableSignal<string>;
+    readonly hasError: i0.WritableSignal<boolean>;
+    readonly isDisabled: i0.WritableSignal<boolean>;
+    readonly isRequired: i0.WritableSignal<boolean>;
+    readonly isReadonly: i0.WritableSignal<boolean>;
+    readonly hintId: i0.Signal<string>;
+    readonly errorId: i0.Signal<string>;
+    readonly labelId: i0.Signal<string>;
+    readonly describedByIds: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFieldContext, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SkraFieldContext>;
+}
+
+declare class SkraField implements OnInit {
+    private readonly idGen;
+    readonly context: SkraFieldContext;
+    readonly fieldId: i0.InputSignal<string | null>;
+    readonly readonly: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly required: i0.InputSignalWithTransform<boolean, unknown>;
+    readonly hasError: i0.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraField, "skra-field", never, { "fieldId": { "alias": "fieldId"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * `label[skraLabelFor]` — form-control label atom. Per ADR 040 this is a
+ * Component-on-the-native-host carrying its own `label.scss` (typography + colour
+ * + cursor) via Emulated encapsulation, replacing the ADR 038 slice branch.
+ *
+ * `<label>` is content-bearing (its text is the label), so the template MUST be
+ * `<ng-content>` — `template: ''` would discard the label text. See ADR 040 §2.
+ *
+ * Auto-links to its sibling control via `[htmlFor]` sourced from
+ * `SkraFieldContext.fieldId()` — zero manual ID passing (ADR 013). The label's
+ * error-state colour is driven by `<skra-field>[data-skra-validation="invalid"]`
+ * swapping `--skra-comp-field-label-color` through CSS variable inheritance; this
+ * SCSS is what consumes that variable (the swap was a no-op before the binding
+ * moved here from the slice).
+ */
+declare class SkraLabel {
+    readonly context: SkraFieldContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraLabel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraLabel, "label[skraLabelFor]", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Hint component for supplementary field information.
+ * Auto-receives ID from SkraFieldContext so aria-describedby on input works automatically.
+ */
+declare class SkraHint {
+    readonly context: SkraFieldContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraHint, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraHint, "skra-hint", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Error message atom sibling to `<skra-hint>`. Renders validation feedback
+ * inside `<skra-field>` with its own a11y semantics: `role="alert"` (which
+ * carries an implicit `aria-live="assertive"` + `aria-atomic="true"`), so screen
+ * readers announce a validation error promptly. NO explicit `aria-live` — adding
+ * `aria-live="polite"` alongside `role="alert"` is contradictory (alert is
+ * assertive by definition) and behaves inconsistently across AT. Assertive is
+ * the WAI-ARIA APG pattern for validation errors (decision 2026-05-31, Batch 4
+ * cleanroom review).
+ *
+ * Per ADR 037 (agnostic atom co-existence) — does not infer error state from
+ * any binding strategy. Consumer renders or omits `<skra-error>` based on
+ * their own validation source (Signal Forms `.invalid && .touched`, Reactive
+ * Forms `ctrl.errors`, raw computed signal). The atom itself just supplies
+ * a11y wiring + visual treatment.
+ *
+ *   <skra-field [hasError]="emailHasError()">
+ *     <label skraLabelFor>Email</label>
+ *     <input skraInput type="email" />
+ *     <skra-hint>We'll never share your email.</skra-hint>
+ *     @if (emailHasError()) {
+ *       <skra-error>Please enter a valid email address.</skra-error>
+ *     }
+ *   </skra-field>
+ *
+ * Separate from `<skra-hint>` per SRP: hint is static helper text
+ * (role="note", neutral colour); error is dynamic validation feedback
+ * (role="alert", live region, error colour). One element per visual
+ * responsibility — the rejected alternative ("hint that swaps text on error")
+ * loaded two responsibilities into a single primitive.
+ */
+declare class SkraError {
+    readonly context: SkraFieldContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraError, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraError, "skra-error", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Forge marker on a native `<fieldset>` used to group related form controls
+ * (checkbox group, radio group, or any related field cluster). Per ADR 039,
+ * Forge ships no `<skra-radio-group>` / `<skra-checkbox-group>` component
+ * wrappers — native `<fieldset>` + `<legend>` IS the WCAG-canonical group
+ * idiom, and Forge stops reinventing it.
+ *
+ * Per ADR 040 this is a Component-on-the-native-host carrying its own
+ * `fieldset.scss` (chrome reset + group layout) via Emulated encapsulation,
+ * replacing the ADR 038 slice branch. `<fieldset>` is content-bearing (it holds
+ * the grouped controls), so the template MUST be `<ng-content>` — `template: ''`
+ * would discard the entire group. See ADR 040 §2.
+ *
+ * The `[disabled]` input cascades to the native `disabled` attribute, and
+ * native `<fieldset disabled>` already disables every form control inside
+ * (browser-native behaviour). Forge does not iterate children manually.
+ *
+ * Selector is opt-in (`fieldset[skraFieldset]`) so the chrome-reset rules do
+ * not leak onto bare `<fieldset>` elements outside Forge.
+ *
+ *   <fieldset skraFieldset [disabled]="form.disabled()">
+ *     <legend skraLegend>Send notifications via</legend>
+ *     <!-- skra-field children with checkboxes -->
+ *     <skra-error *ngIf="form.channels().length === 0">Choose at least one</skra-error>
+ *   </fieldset>
+ *
+ * `role="group"` is the explicit ARIA role: while the browser default for
+ * `<fieldset>` is already group semantics for most AT, declaring it explicitly
+ * is friendlier to assistive tech that may have idiosyncratic handling.
+ *
+ * Native `disabled` is sufficient — `aria-disabled` is NOT set per
+ * native-attr-first doctrine (memory `feedback_native_attr_first.md`). The
+ * `data-skra-disabled` reflection drives the visual dimming in `fieldset.scss`.
+ */
+declare class SkraFieldset {
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraFieldset, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraFieldset, "fieldset[skraFieldset]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * `legend[skraLegend]` — visible group label for `<fieldset skraFieldset>`.
+ * Per ADR 040 this is a Component-on-the-native-host carrying its own
+ * `legend.scss` (chrome reset + typography role binding per ADR 036) via Emulated
+ * encapsulation, replacing the ADR 038 slice branch.
+ *
+ * `<legend>` is content-bearing (its text is the group label), so the template
+ * MUST be `<ng-content>` — `template: ''` would discard the label. See ADR 040 §2.
+ * No host bindings, no inputs, no DI — purely a styled marker.
+ *
+ *   <fieldset skraFieldset>
+ *     <legend skraLegend>Account preferences</legend>
+ *     ...
+ *   </fieldset>
+ *
+ * HTML requires `<legend>` to be the FIRST child of `<fieldset>` for native
+ * group-label semantics. The browser HTML parser auto-corrects misplaced
+ * legends (re-parents to fieldset), but Forge documents the canonical form.
+ */
+declare class SkraLegend {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraLegend, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraLegend, "legend[skraLegend]", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { IdGeneratorService, SkraError, SkraField, SkraFieldContext, SkraFieldset, SkraHint, SkraLabel, SkraLegend };
+//# sourceMappingURL=skra-ui-field.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-field.d.ts","sources":["../../../../libs/ui/field/src/lib/id-generator/id-generator.service.ts","../../../../libs/ui/field/src/lib/field-context/field-context.ts","../../../../libs/ui/field/src/lib/field/field.component.ts","../../../../libs/ui/field/src/lib/label/label.ts","../../../../libs/ui/field/src/lib/hint/hint.component.ts","../../../../libs/ui/field/src/lib/error/error.component.ts","../../../../libs/ui/field/src/lib/fieldset/fieldset.ts","../../../../libs/ui/field/src/lib/fieldset/legend.ts"],"mappings":";;;AAEA;;;AAGG;AACH,cACa,kBAAkB;;AAG7B;yCAHW,kBAAkB;6CAAlB,kBAAkB;AAM9B;;ACXD;;;;AAIG;AACH,cACa,gBAAgB;sBACXA,EAAA,CAAA,cAAA;uBACCA,EAAA,CAAA,cAAA;yBACEA,EAAA,CAAA,cAAA;yBACAA,EAAA,CAAA,cAAA;yBACAA,EAAA,CAAA,cAAA;qBAGJA,EAAA,CAAA,MAAA;sBACCA,EAAA,CAAA,MAAA;sBAQAA,EAAA,CAAA,MAAA;6BAOOA,EAAA,CAAA,MAAA;yCAxBZ,gBAAgB;6CAAhB,gBAAgB;AA2B5B;;ACtBD,cA0Ba,SAAU,YAAW,MAAM;AACtC;sBACgB,gBAAA;sBAEAA,EAAA,CAAA,WAAA;uBACCA,EAAA,CAAA,wBAAA;uBACAA,EAAA,CAAA,wBAAA;uBACAA,EAAA,CAAA,wBAAA;uBACAA,EAAA,CAAA,wBAAA;;AAkBjB;yCA1BW,SAAS;2CAAT,SAAS;AA6BrB;;AC5DD;;;;;;;;;;;;;;AAcG;AACH,cAwBa,SAAS;sBACJ,gBAAA;yCADL,SAAS;2CAAT,SAAS;AAErB;;ACzCD;;;AAGG;AACH,cAca,QAAQ;sBACH,gBAAA;yCADL,QAAQ;2CAAR,QAAQ;AAEpB;;ACpBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BG;AACH,cAiBa,SAAS;sBACJ,gBAAA;yCADL,SAAS;2CAAT,SAAS;AAErB;;AClDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACH,cAca,YAAY;uBACNA,EAAA,CAAA,wBAAA;yCADN,YAAY;2CAAZ,YAAY;AAExB;;ACpDD;;;;;;;;;;;;;;;;;;AAkBG;AACH,cASa,UAAU;yCAAV,UAAU;2CAAV,UAAU;AAAG;;;;","names":["_angular_core"]}

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

@@ -0,0 +1,38 @@
+import * as i0 from '@angular/core';
+
+type IconSize = 'sm' | 'md' | 'lg';
+/**
+ * SkraIcon — container atom for icon-shaped content (ADR 034).
+ *
+ * Forge owns geometry, layout isolation, color inheritance hook. The shape
+ * itself is supplied by the consumer via `<ng-content>` — inline SVG, `<img>`,
+ * a third-party icon library element, or a styled `<span>` are all supported
+ * equally. Forge ships no icon catalog and makes no rendering-strategy choice
+ * for the consumer.
+ *
+ * Accessibility: this host has NO default ARIA attributes (ADR 034 §3.4). The
+ * consumer MUST declare semantics explicitly:
+ *   - decorative icon  → `<skra-icon aria-hidden="true">`
+ *   - meaningful icon  → `<skra-icon role="img" aria-label="...">`  (ADR 033 Path 3;
+ *     `role="img"` is required — `aria-label` on the roleless host is ARIA-prohibited)
+ *
+ * @see ADR 034 — SkraIcon as a container atom
+ * @see ADR 033 — Accessible Name Contract
+ */
+declare class SkraIcon {
+    /**
+     * Preset size token (`'sm' | 'md' | 'lg'`). When `null`, the icon inherits
+     * `--skra-comp-icon-size` from the surrounding context — typical in button
+     * slot wrappers (ADR 030 §3.4) where the parent owns the icon size. Arbitrary
+     * dimensions are not an input (a free value would require an inline style,
+     * forbidden by ADR 021); a consumer needing a bespoke size overrides
+     * `--skra-comp-icon-size` via the sanctioned token-cascade path (ADR 029).
+     */
+    readonly size: i0.InputSignal<IconSize | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraIcon, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraIcon, "skra-icon", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SkraIcon };
+export type { IconSize };
+//# sourceMappingURL=skra-ui-icon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-icon.d.ts","sources":["../../../../libs/ui/icon/src/lib/icon/icon.ts"],"mappings":";;AAOM,KAAM,QAAQ;AAEpB;;;;;;;;;;;;;;;;;AAiBG;AACH,cAmBa,QAAQ;AACnB;;;;;;;AAOG;mBACUA,EAAA,CAAA,WAAA,CAAA,QAAA;yCATF,QAAQ;2CAAR,QAAQ;AAUpB;;;;","names":["_angular_core"]}

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

@@ -0,0 +1,22 @@
+import { SkraFieldContext } from '@skra/ui/field';
+import * as i0 from '@angular/core';
+
+/**
+ * `input[skraInput]` — text-input atom. Per ADR 040 this is a
+ * Component-on-a-native-host (not a directive): `<input>` is a void element, so
+ * `template: ''` is correct — there is no consumer content to project. Angular
+ * Emulated encapsulation scopes `input.scss` to the host, the same way
+ * <skra-button> carries its own CSS. Replaces the ADR 038 global slice branch.
+ *
+ * DI wiring (ADR 013), host a11y bindings (ADR 021/027), and the agnostic
+ * value posture (ADR 037 — no value channel, no @angular/forms) are unchanged
+ * from the prior directive form.
+ */
+declare class SkraInput {
+    readonly context: SkraFieldContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraInput, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraInput, "input[skraInput]", never, {}, {}, never, never, true, never>;
+}
+
+export { SkraInput };
+//# sourceMappingURL=skra-ui-input.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-input.d.ts","sources":["../../../../libs/ui/input/src/lib/input/input.ts"],"mappings":";;;AAQA;;;;;;;;;;AAUG;AACH,cAqBa,SAAS;sBACJ,gBAAA;yCADL,SAAS;2CAAT,SAAS;AAErB;;;;","names":[]}

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

@@ -0,0 +1,33 @@
+import * as i0 from '@angular/core';
+
+/**
+ * `kbd[skraKbd]` — keyboard-key display atom (first resident of `libs/ui/content`, the
+ * text-level inline-semantics family). Renders a single key / key-name as a styled key-cap for
+ * docs, shortcut hints and help text ("press `Esc` to close"). See
+ * `adr/specs/component-kbd-spec.md`.
+ *
+ * **Component-on-the-native-host (ADR 040), NOT `<skra-kbd>`:** native `<kbd>` already carries
+ * the correct HTML semantic ("user keyboard input"), so we decorate it (ADR 012). `<kbd>` is
+ * content-bearing, so the template MUST be `<ng-content>` — `template: ''` would discard the key
+ * text (ADR 040 §2; the `label[skraLabelFor]` precedent).
+ *
+ * **Zero inputs by design.** A key display is purely presentational:
+ * - sizing is em-relative (it harmonises with the surrounding text), so there is no `size` input
+ *   — an explicit size enum would be a look-input (skin-philosophy) and low-demand (90%-rule);
+ * - no coherent semantic exists for a `type`, and a `type` enum switching appearance is the SRP
+ *   smell the Decision Doctrine warns against;
+ * - the monospace family is skin-owned (`--skra-comp-kbd-font-family` → `sys.font-family.code`);
+ * - key-combos ("Ctrl+C") are consumer composition of multiple `<kbd skraKbd>` (agnostic
+ *   doctrine), not a `combo` input.
+ *
+ * So there is no input, no output, no `data-skra-*` state (non-interactive — State Surface
+ * all-N/A), and no `ariaLabel` (the visible text IS the accessible content, ADR 033). The host is
+ * deliberately **not** `aria-hidden`: the key name is meaningful content AT must announce.
+ */
+declare class SkraKbd {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraKbd, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraKbd, "kbd[skraKbd]", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { SkraKbd };
+//# sourceMappingURL=skra-ui-kbd.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-kbd.d.ts","sources":["../../../../libs/ui/kbd/src/lib/kbd/kbd.ts"],"mappings":";;AAMA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACH,cAYa,OAAO;yCAAP,OAAO;2CAAP,OAAO;AAAG;;;;","names":[]}

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

@@ -0,0 +1,86 @@
+import * as _angular_core from '@angular/core';
+
+type BoxPadding = 'none' | 'sm' | 'md' | 'lg';
+type BoxDisplay = 'block' | 'inline-block' | 'flex';
+/**
+ * SkraBox — semantically-neutral spacing/padding primitive (ADR 041).
+ *
+ * Component-on-native-host: layers onto a generic flow/sectioning container via
+ * the bounded host allowlist below — NEVER a `<skra-box>` custom element
+ * (ADR 012 §3.1 / ADR 041). Box does NOT arrange children, so list hosts
+ * (`ul`/`ol`/`menu`) are intentionally excluded from its allowlist.
+ *
+ * Box is a pure spacing primitive: it MUST NOT establish a container-query
+ * context (`container-type`/`container-name`) — that is an app-level concern
+ * (ADR 016 §3.3, amended by ADR 041).
+ */
+declare class SkraBox {
+    readonly padding: _angular_core.InputSignal<BoxPadding>;
+    readonly display: _angular_core.InputSignal<BoxDisplay>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraBox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraBox, "div[skraBox], section[skraBox], article[skraBox], main[skraBox], nav[skraBox], aside[skraBox], header[skraBox], footer[skraBox], form[skraBox], figure[skraBox]", never, { "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type StackDirection = 'row' | 'column';
+type StackGap = 'none' | 'sm' | 'md' | 'lg';
+type StackAlign = 'start' | 'center' | 'end' | 'stretch';
+type StackJustify = 'start' | 'center' | 'end' | 'between' | 'around';
+/**
+ * SkraStack — flex layout primitive that arranges its children (ADR 041).
+ *
+ * Component-on-native-host via the bounded allowlist below. As a child-arranger
+ * it additionally accepts list hosts (`ul`/`ol`/`menu`) — their UA list styling
+ * is normalized in stack.scss per the Host Normalization Contract. List markers
+ * are restorable without `!important` via a direct `li {}` rule (a direct
+ * declaration beats the inherited `list-style: none`).
+ *
+ * Stack consumes `@container`; it MUST NOT establish a container-query context
+ * (ADR 016 §3.3, amended by ADR 041).
+ */
+declare class SkraStack {
+    readonly direction: _angular_core.InputSignal<StackDirection>;
+    readonly gap: _angular_core.InputSignal<StackGap>;
+    readonly align: _angular_core.InputSignal<StackAlign>;
+    readonly justify: _angular_core.InputSignal<StackJustify>;
+    readonly wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraStack, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraStack, "div[skraStack], section[skraStack], article[skraStack], main[skraStack], nav[skraStack], aside[skraStack], header[skraStack], footer[skraStack], form[skraStack], figure[skraStack], ul[skraStack], ol[skraStack], menu[skraStack]", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "justify": { "alias": "justify"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type GridColumns = '1' | '2' | '3' | '4' | '5' | '6' | 'auto-fit' | 'auto-fill';
+type GridMin = 'sm' | 'md' | 'lg';
+type GridGap = 'none' | 'sm' | 'md' | 'lg';
+type GridFlow = 'row' | 'column' | 'dense';
+type GridAlign = 'start' | 'center' | 'end' | 'stretch';
+/**
+ * SkraGrid — 2D layout primitive that arranges its children in a CSS Grid
+ * (ADR 041, scope O-3). The bucket-only companion to Stack (1D) and Box (spacing).
+ *
+ * Component-on-native-host via the bounded allowlist below. As a child-arranger
+ * it additionally accepts list hosts (`ul`/`ol`/`menu`) — their UA list styling
+ * is normalized in grid.scss per the Host Normalization Contract.
+ *
+ * Bucket-only by design: every axis is an enumerated input reflected as a
+ * `data-skra-*` attribute → token. Arbitrary track lists, `grid-template-areas`,
+ * named lines and per-item placement are OUT of scope (bespoke = native CSS) —
+ * exposing them would force an `[style.*]` host binding (ADR 021 violation).
+ *
+ * Responsiveness: `columns="auto-fit"` (default) + `min` produce an intrinsically
+ * responsive card grid via `repeat(auto-fit, minmax(var(--min), 1fr))` — column
+ * count tracks available width with NO media/container queries. Grid consumes
+ * `@container`; it MUST NOT establish a container-query context (ADR 041 §3.3).
+ */
+declare class SkraGrid {
+    readonly columns: _angular_core.InputSignal<GridColumns>;
+    readonly min: _angular_core.InputSignal<GridMin>;
+    readonly gap: _angular_core.InputSignal<GridGap>;
+    readonly flow: _angular_core.InputSignal<GridFlow>;
+    readonly align: _angular_core.InputSignal<GridAlign>;
+    readonly justifyItems: _angular_core.InputSignal<GridAlign>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkraGrid, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkraGrid, "div[skraGrid], section[skraGrid], article[skraGrid], main[skraGrid], nav[skraGrid], aside[skraGrid], header[skraGrid], footer[skraGrid], form[skraGrid], figure[skraGrid], ul[skraGrid], ol[skraGrid], menu[skraGrid]", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "flow": { "alias": "flow"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "justifyItems": { "alias": "justifyItems"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SkraBox, SkraGrid, SkraStack };
+export type { BoxDisplay, BoxPadding, GridAlign, GridColumns, GridFlow, GridGap, GridMin, StackAlign, StackDirection, StackGap, StackJustify };
+//# sourceMappingURL=skra-ui-layout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-layout.d.ts","sources":["../../../../libs/ui/layout/src/lib/box/box.ts","../../../../libs/ui/layout/src/lib/stack/stack.ts","../../../../libs/ui/layout/src/lib/grid/grid.ts"],"mappings":";;AAOM,KAAM,UAAU;AAChB,KAAM,UAAU;AAEtB;;;;;;;;;;;AAWG;AACH,cAiBa,OAAO;sBACF,aAAA,CAAA,WAAA,CAAA,UAAA;sBACA,aAAA,CAAA,WAAA,CAAA,UAAA;oDAFL,OAAO;sDAAP,OAAO;AAGnB;;KClCW,cAAc;AACpB,KAAM,QAAQ;AACd,KAAM,UAAU;AAChB,KAAM,YAAY;AAExB;;;;;;;;;;;AAWG;AACH,cAoBa,SAAS;wBACF,aAAA,CAAA,WAAA,CAAA,cAAA;kBACN,aAAA,CAAA,WAAA,CAAA,QAAA;oBACE,aAAA,CAAA,WAAA,CAAA,UAAA;sBACE,aAAA,CAAA,WAAA,CAAA,YAAA;mBACH,aAAA,CAAA,wBAAA;oDALF,SAAS;sDAAT,SAAS;AAMrB;;KC5CW,WAAW;AASjB,KAAM,OAAO;AACb,KAAM,OAAO;AACb,KAAM,QAAQ;AACd,KAAM,SAAS;AAErB;;;;;;;;;;;;;;;;;AAiBG;AACH,cAqBa,QAAQ;sBACH,aAAA,CAAA,WAAA,CAAA,WAAA;kBACJ,aAAA,CAAA,WAAA,CAAA,OAAA;kBACA,aAAA,CAAA,WAAA,CAAA,OAAA;mBACC,aAAA,CAAA,WAAA,CAAA,QAAA;oBACC,aAAA,CAAA,WAAA,CAAA,SAAA;2BACO,aAAA,CAAA,WAAA,CAAA,SAAA;oDANV,QAAQ;sDAAR,QAAQ;AAOpB;;;;","names":[]}

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

@@ -0,0 +1,20 @@
+import * as i0 from '@angular/core';
+
+/**
+ * SkraLink — text-style anchor primitive (ADR 032 §3.6).
+ *
+ * Selector: `a[skraLink]` — `<a>` is the sole host.
+ *
+ * Per ADR 032 §3.6.3 there is no `disabled` input and no `data-skra-*`
+ * Availability reflection: a link the user cannot or should not follow should
+ * not be a link in the first place. Severity is deferred beyond MVP (§3.6.4).
+ * Accessible Name follows ADR 033 Path 1 — visible text is the accessible name;
+ * the component exposes no `ariaLabel` input.
+ */
+declare class SkraLink {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraLink, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraLink, "a[skraLink]", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { SkraLink };
+//# sourceMappingURL=skra-ui-link.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-link.d.ts","sources":["../../../../libs/ui/link/src/lib/link/link.ts"],"mappings":";;AAMA;;;;;;;;;;AAUG;AACH,cAQa,QAAQ;yCAAR,QAAQ;2CAAR,QAAQ;AAAG;;;;","names":[]}

package/types/skra-ui-loading-indicator.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from '@angular/core';
+
+declare class SkraLoadingIndicator {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraLoadingIndicator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkraLoadingIndicator, "[skraLoadingIndicator]", never, {}, {}, never, never, true, never>;
+}
+
+export { SkraLoadingIndicator };
+//# sourceMappingURL=skra-ui-loading-indicator.d.ts.map

package/types/skra-ui-loading-indicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-loading-indicator.d.ts","sources":["../../../../libs/ui/loading-indicator/src/lib/loading-indicator.directive.ts"],"mappings":";;AAEA,cAOa,oBAAoB;yCAApB,oBAAoB;2CAApB,oBAAoB;AAAG;;;;","names":[]}

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

@@ -0,0 +1,116 @@
+import * as i0 from '@angular/core';
+import { SkraPlacement } from '@skra/ui/core';
+export { SkraPlacement } from '@skra/ui/core';
+
+/**
+ * The item shape the menu keyboard controller drives. Structurally a CDK `FocusableOption`
+ * (`focus()`), plus the menu's own `getLabel()` (type-ahead) and `isDisabled()` (focusable-but-inert
+ * roving). Declared HERE — cdk-free — so the only `@angular/cdk` importer stays `menu-keyboard.ts`.
+ */
+interface SkraMenuKeyboardItem {
+    focus(): void;
+    getLabel(): string;
+    isDisabled(): boolean;
+}
+/** What a `skraMenuItem` needs from its `skra-menu` — narrow contract that breaks the menu↔item cycle. */
+interface SkraMenuPanel {
+    /** Dismiss the menu after an item activates (native `hidePopover()` → focus returns to the trigger). */
+    requestClose(): void;
+}
+
+/**
+ * SkraMenu — a WAI-ARIA APG **Menu Button** menu: a homogeneous set of commands anchored to a
+ * trigger, navigated as one composite widget with arrow keys, where activating a command closes it.
+ * Rendered in the browser TOP LAYER via the native Popover API (`popover="auto"`), per ADR 0044.
+ *
+ * SHAPE (scope 2026-06-07): a Component on the PANEL with projected `button[skraMenuItem]` children
+ * (the Popover model, ADR 040) — NOT a directive on the trigger, NOT a data-driven `[items]` array.
+ * The trigger is the consumer's own button linked by the native `popovertarget` attribute; toggle,
+ * light-dismiss and Escape are platform-owned. The consumer MUST give `<skra-menu>` an `id`.
+ *
+ *   <button skraButton popovertarget="actions" aria-haspopup="menu">Actions</button>
+ *   <skra-menu id="actions">
+ *     <button skraMenuItem (click)="edit()">Edit</button>
+ *     <button skraMenuItem disabled (click)="archive()">Archive</button>
+ *     <button skraMenuItem (click)="remove()">Delete</button>
+ *   </skra-menu>
+ *
+ * Forge adds, on top of the Popover substrate: the `role="menu"` keyboard model via `SkraMenuKeyboard`
+ * (CDK `FocusKeyManager` — Down/Up roving + wrap, Home/End, type-ahead, Tab-dismiss), **focus moving
+ * INTO the menu on open** (a composite widget — unlike non-modal Popover; the per-component ADR 0044
+ * §3 rule-8 decision), and the trigger's disclosure ARIA (`aria-haspopup="menu"` / `aria-controls` /
+ * `aria-expanded`). Side effects on open/close: bind the native `(toggle)` — there is no Forge output
+ * (native-first; contrast Dialog, whose `<dialog>` has no open event). Context menus (right-click) are
+ * a recipe with a visible button, never a trigger mode (SRP + WCAG 2.1.1).
+ *
+ * Full contract: adr/specs/component-menu-spec.md.
+ */
+declare class SkraMenu implements SkraMenuPanel {
+    /** Placement intent; `flip`/`shift` adjust at runtime. */
+    readonly placement: i0.InputSignal<SkraPlacement>;
+    private readonly menuItems;
+    private readonly host;
+    private readonly renderer;
+    private readonly keyboard;
+    /** The consumer's `[popovertarget]` button, resolved once (lazily-idempotent via `resolved`). */
+    private trigger;
+    private resolved;
+    private positioner?;
+    constructor();
+    /** SKRA_MENU contract — close on item activation (native focus-return to the trigger). */
+    requestClose(): void;
+    /** Capture-phase guard: block clicks on an `aria-disabled` item before they reach its listeners. */
+    private readonly onCaptureClick;
+    private readonly onToggleNative;
+    private readonly onKeydownNative;
+    private onOpen;
+    private onClose;
+    /**
+     * Resolve the `[popovertarget]` trigger and establish the menu disclosure ARIA on it (sanctioned a11y
+     * wiring, ADR 013-style — not style mutation). Idempotent. Returns the trigger (or null for an orphan
+     * menu, dev-warned once).
+     */
+    private ensureTrigger;
+    /** Read a length comp token (px/rem) off the host computed style for the positioner. */
+    private cssLenPx;
+    /** Dev-only nudge: a role="menu" with no menuitems is invalid — a link-list/content panel is a Popover. */
+    private warnIfEmpty;
+    private teardown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraMenu, "skra-menu", ["skraMenu"], { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, ["menuItems"], ["*"], true, never>;
+}
+
+/**
+ * SkraMenuItem — a single command in a `skra-menu`, a Component on the native command host
+ * `button[skraMenuItem]` (ADR 012/040: a `<button>` is the right semantic — Enter/Space→click +
+ * focusability for free; its implicit role is overridden to `role="menuitem"` per WAI-ARIA APG).
+ *
+ * Roving focus: `tabindex="-1"` (the keyboard controller moves real focus). Implements
+ * `SkraMenuKeyboardItem` (`focus`/`getLabel`/`isDisabled`) so `SkraMenuKeyboard` (CDK `FocusKeyManager`)
+ * can drive it. On activation it asks the menu to close (native `hidePopover()` → focus returns to the
+ * trigger).
+ *
+ * **Disabled is native-attr-first (boundary #9, ADR 039 precedent): the consumer sets
+ * `aria-disabled="true"` directly — Forge OBSERVES it, exposing NO `disabled` input.** This (a) keeps a
+ * disabled item **focusable/discoverable** in the roving order (APG) — native `disabled` would remove it
+ * from focus, and (b) avoids a Forge input shadowing the native `disabled` attribute. Styling keys off
+ * `:host([aria-disabled="true"])`; activation is blocked here.
+ *
+ * Full contract: adr/specs/component-menu-spec.md.
+ */
+declare class SkraMenuItem implements SkraMenuKeyboardItem {
+    private readonly host;
+    private readonly menu;
+    constructor();
+    focus(): void;
+    getLabel(): string;
+    /** Soft-disabled = the consumer's `aria-disabled="true"` (native-attr-first); read live (no input). */
+    isDisabled(): boolean;
+    protected onActivate(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkraMenuItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkraMenuItem, "button[skraMenuItem]", ["skraMenuItem"], {}, {}, never, ["*"], true, never>;
+}
+
+export { SkraMenu, SkraMenuItem };
+export type { SkraMenuPanel };
+//# sourceMappingURL=skra-ui-menu.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skra-ui-menu.d.ts","sources":["../../../../libs/ui/menu/src/lib/menu/menu-types.ts","../../../../libs/ui/menu/src/lib/menu/menu.ts","../../../../libs/ui/menu/src/lib/menu/menu-item.ts"],"mappings":";;;;AAEA;;;;AAIG;UACc,oBAAoB;;;;AAIpC;AAED;UACiB,aAAa;;;AAG7B;;ACQD;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACH,cAoBa,QAAS,YAAW,aAAa;;wBAE1BA,EAAA,CAAA,WAAA,CAAA,aAAA;AAElB;AAIA;AACA;AACA;;;;;;;AAoCA;;AAKA;AAWA;AAKA;AAIA;AAmBA;AAQA;;;;AAIG;AACH;;AA0CA;;AAcA;AAUA;yCAzKW,QAAQ;2CAAR,QAAQ;AAsLpB;;AClPD;;;;;;;;;;;;;;;;;AAiBG;AACH,cAea,YAAa,YAAW,oBAAoB;AACvD;AACA;;AAcA;AAGA;;AAIA;AAIA,gCAA4B,UAAU;yCA3B3B,YAAY;2CAAZ,YAAY;AAsCxB;;;;","names":["_angular_core"]}