@malva-ui/core 0.1.12

package/search-field/lib/search-field/search-field.d.ts

@@ -0,0 +1,347 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { PositionStrategy } from '@angular/cdk/overlay';
+import type { OverlayConfig } from '@angular/cdk/overlay';
+import type { TemplateRef } from '@angular/core';
+import { MlvOverlayHostBase } from '@malva-ui/cdk/overlay';
+import { MlvSearchOverlayContentDef } from './search-overlay-content';
+import type { MlvSearchOverlayContentContext } from './search-overlay-content';
+import * as i0 from "@angular/core";
+/** Controls when a search field commits the current query. */
+export type MlvSearchFieldTrigger = 'live' | 'submit';
+/**
+ * How the field presents itself before an overlay search is opened.
+ *
+ * - `'field'` — the standard input. With `overlay`, clicking or focusing it
+ *   opens the overlay instead of typing inline.
+ * - `'icon'` — a circular icon button only. Implies `overlay`, since an icon has
+ *   nowhere to type.
+ */
+export type MlvSearchFieldPresentation = 'field' | 'icon';
+/**
+ * ARIA role applied to the field's underlying `<input>`.
+ *
+ * - `'searchbox'` (default) — leaves the native `<input type="search">` role
+ *   implicit and emits no {@link MlvSearchField.navigate} events.
+ * - `'combobox'` — the field drives a popup listbox owned by the consumer.
+ *   Stamps `role="combobox"` on the input and turns on the arrow-key hooks.
+ */
+export type MlvSearchFieldRole = 'searchbox' | 'combobox';
+/** Values accepted by `aria-autocomplete` on a combobox input. */
+export type MlvSearchFieldAriaAutocomplete = 'none' | 'list' | 'both';
+/** One of the option-navigation keys reported by {@link MlvSearchField.navigate}. */
+export type MlvSearchFieldNavigateDirection = 'up' | 'down' | 'home' | 'end' | 'pageUp' | 'pageDown';
+/**
+ * Payload of {@link MlvSearchField.navigate} — an option-navigation key pressed
+ * while the field is acting as a combobox.
+ */
+export interface MlvSearchFieldNavigateEvent {
+    /** Which navigation key was pressed. */
+    readonly direction: MlvSearchFieldNavigateDirection;
+    /**
+     * The originating key event. `up`/`down`/`pageUp`/`pageDown` arrive already
+     * `preventDefault`ed; `home`/`end` do not — call `preventDefault()` on this
+     * event to take the caret keys over as well.
+     */
+    readonly event: KeyboardEvent;
+}
+/**
+ * Payload of {@link MlvSearchField.commit} — the user asked to act on the
+ * current query, through Enter or the submit action.
+ */
+export interface MlvSearchFieldCommitEvent {
+    /** The query at the moment of the commit. */
+    readonly value: string;
+    /**
+     * The originating event. Call `preventDefault()` on it to take the commit
+     * over: the field then skips its own `search` emission and leaves the key
+     * consumed, so a combobox consumer can resolve the active option instead.
+     */
+    readonly event: KeyboardEvent | MouseEvent;
+}
+/**
+ * A search-specific text field with either debounced live updates or explicit
+ * submission through Enter and a trailing action button.
+ */
+export declare class MlvSearchField extends MlvOverlayHostBase {
+    /** Current query. Supports two-way binding with `[(value)]`. */
+    readonly value: import("@angular/core").ModelSignal<string>;
+    /**
+     * Search commit strategy. Live mode emits after {@link debounce}; submit
+     * mode emits only from Enter or the submit button.
+     */
+    readonly trigger: import("@angular/core").InputSignal<MlvSearchFieldTrigger>;
+    /**
+     * Trailing delay, in milliseconds, used by live mode. Negative values are
+     * clamped to zero.
+     * @default 200
+     */
+    readonly debounce: import("@angular/core").InputSignalWithTransform<number, string | number>;
+    /** Placeholder override. Falls back to the active i18n language pack. */
+    readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
+    /** Accessible input label override. Falls back to the active i18n pack. */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /** Whether the field and all its actions are unavailable. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether a pending-search indicator is shown. The input remains editable
+     * so a newer live query can supersede an in-flight request; explicit submit
+     * activation is blocked until loading completes.
+     */
+    readonly loading: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether the trailing submit action is rendered in `submit` mode.
+     *
+     * Set to `false` for a field that commits from Enter alone — the overlay's own
+     * nested field does this, since the overlay already has a leading search icon
+     * and a close action.
+     * @default true
+     */
+    readonly showSubmit: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether a clear action is shown while the field has a value. */
+    readonly clearable: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Whether clearing also commits the empty query through {@link search}.
+     * Composite controls can disable this while still receiving the cleared
+     * {@link value} model update.
+     * @default true
+     */
+    readonly commitOnClear: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Visual form of the trigger. `'icon'` renders a circular search button only
+     * and implies {@link overlay}.
+     * @default 'field'
+     */
+    readonly presentation: import("@angular/core").InputSignal<MlvSearchFieldPresentation>;
+    /**
+     * Opens a full-screen search overlay instead of accepting input inline.
+     *
+     * With `presentation="field"` the visible input becomes a trigger: clicking it
+     * or pressing Enter/Space on it opens the overlay, so the inline input is
+     * rendered read-only to keep it from competing with the overlay's own input.
+     * Focus alone never opens the overlay — see {@link _onTriggerClick}. With
+     * `presentation="icon"` this is always on.
+     * @default false
+     */
+    readonly overlay: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * ARIA role of the underlying `<input>`, and the opt-in switch for the
+     * combobox keyboard hooks.
+     *
+     * `'searchbox'` (the default) changes nothing: the native
+     * `<input type="search">` role stays implicit, no `role` attribute is
+     * rendered, and {@link navigate} never emits. `'combobox'` stamps
+     * `role="combobox"` on the input and starts reporting the option-navigation
+     * keys through {@link navigate}, so a consumer-owned popup listbox can be
+     * driven from the field. Pair it with {@link ariaControls},
+     * {@link ariaExpanded}, {@link ariaAutocomplete} and
+     * {@link ariaActiveDescendant}.
+     *
+     * Only meaningful with `presentation="field"` — `presentation="icon"` renders
+     * a dialog-trigger button, which has no input to carry the role. Likewise
+     * mutually exclusive with {@link overlay}, whose inline trigger is a
+     * read-only dialog opener rather than a text entry.
+     * @default 'searchbox'
+     */
+    readonly role: import("@angular/core").InputSignal<MlvSearchFieldRole>;
+    /**
+     * Forwarded to `aria-controls` on the input — the DOM id of the popup listbox
+     * this field drives. Required by the combobox pattern; ignored while `null`.
+     */
+    readonly ariaControls: import("@angular/core").InputSignal<string | null>;
+    /**
+     * Forwarded to `aria-activedescendant` on the input — the DOM id of the
+     * currently highlighted option inside the popup. Keep DOM focus on the input
+     * and move this id instead, so typing keeps working while navigating options.
+     */
+    readonly ariaActiveDescendant: import("@angular/core").InputSignal<string | null>;
+    /**
+     * Forwarded to `aria-autocomplete` on the input. Use `'list'` when the popup
+     * suggests options without changing the query, `'both'` when the field also
+     * completes inline. Ignored while `null`.
+     */
+    readonly ariaAutocomplete: import("@angular/core").InputSignal<MlvSearchFieldAriaAutocomplete | null>;
+    /**
+     * Forwarded to `aria-expanded` on the input — whether the consumer's popup is
+     * currently open. Required by the combobox pattern.
+     *
+     * Ignored while {@link overlay} is enabled: the inline input is then a dialog
+     * trigger and reports the overlay's own open state instead.
+     */
+    readonly ariaExpanded: import("@angular/core").InputSignal<boolean | null>;
+    /** Emits a committed query according to the selected trigger strategy. */
+    readonly search: import("@angular/core").OutputEmitterRef<string>;
+    /**
+     * Emits when an option-navigation key is pressed while `role="combobox"`.
+     *
+     * Covers ArrowUp/ArrowDown, PageUp/PageDown and Home/End. The first four are
+     * `preventDefault`ed before the event is handed over — inside a text input
+     * they would otherwise jump the caret to the ends of the query or scroll the
+     * page, which is never what a combobox wants. Home/End are reported without
+     * being consumed, because an editable combobox keeps them as caret keys per
+     * WAI-ARIA; a consumer that wants "jump to first/last option" calls
+     * `preventDefault()` on the supplied event itself.
+     *
+     * Never emits while `role="searchbox"`, so the default field is untouched.
+     */
+    readonly navigate: import("@angular/core").OutputEmitterRef<MlvSearchFieldNavigateEvent>;
+    /**
+     * Emits when the user asks to act on the current query — a non-composing
+     * Enter on the inline input, or the trailing submit action.
+     *
+     * Always emitted *before* the field's own commit, in every `trigger` mode, so
+     * a combobox consumer can resolve the highlighted option instead of running a
+     * plain search: call `preventDefault()` on the supplied event and the field
+     * skips its `search` emission and leaves the key consumed. Left alone, the
+     * existing behaviour runs unchanged — `submit` mode emits `search`, `live`
+     * mode has already emitted through the debounce and Enter still bubbles.
+     *
+     * Not emitted while {@link overlay} is enabled, where Enter opens the dialog
+     * rather than committing, and not emitted while disabled or loading.
+     */
+    readonly commit: import("@angular/core").OutputEmitterRef<MlvSearchFieldCommitEvent>;
+    /** @protected Reactive strings for the active language. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvSearchFieldI18n>;
+    /** @protected Consumer template replacing the overlay body, when supplied. */
+    protected readonly _overlayContentDef: import("@angular/core").Signal<MlvSearchOverlayContentDef | undefined>;
+    /** @protected The overlay panel template attached to the CDK overlay. */
+    protected readonly _overlayTemplate: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+    /**
+     * @protected Whether overlay behaviour is active. `presentation="icon"` forces
+     * it on: an icon button has nowhere to accept text.
+     */
+    protected readonly _overlayEnabled: import("@angular/core").Signal<boolean>;
+    /** @protected Context handed to a consumer-supplied overlay body. */
+    protected readonly _overlayContext: import("@angular/core").Signal<MlvSearchOverlayContentContext>;
+    /** @protected Effective placeholder after resolving an explicit override. */
+    protected readonly _resolvedPlaceholder: import("@angular/core").Signal<string>;
+    /** @protected Effective input label after resolving an explicit override. */
+    protected readonly _resolvedAriaLabel: import("@angular/core").Signal<string>;
+    /**
+     * @protected Explicit `role` attribute for the input, or `null` to leave it off.
+     *
+     * `searchbox` is the implicit role of `<input type="search">`, so the default
+     * renders no attribute at all and the DOM stays exactly as it was.
+     */
+    protected readonly _resolvedRole: import("@angular/core").Signal<"combobox" | null>;
+    /**
+     * @protected Effective `aria-expanded`.
+     *
+     * An overlay-enabled field is a dialog trigger and owns this attribute
+     * itself; otherwise it mirrors the consumer's popup state.
+     */
+    protected readonly _resolvedAriaExpanded: import("@angular/core").Signal<boolean | null>;
+    /** @protected Whether the clear action should currently be rendered. */
+    protected readonly _showClear: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Whether the trailing submit action should be rendered.
+     *
+     * An overlay-enabled field never shows it: the inline input is a trigger, so
+     * there is nothing to submit from it — the query is typed in the overlay.
+     */
+    protected readonly _showSubmitAction: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Whether the leading search icon should be rendered.
+     *
+     * The field carries exactly one search glyph: trailing when there is a submit
+     * action to hang it on, leading otherwise. Live mode has no submit action, and
+     * neither does a submit-mode field with {@link showSubmit} turned off.
+     */
+    protected readonly _showLeadingIcon: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Whether the trailing spinner is rendered as its own element.
+     *
+     * The submit action carries its own loading state, so a second spinner beside
+     * it would be redundant. Without a submit action the field needs one of its own.
+     */
+    protected readonly _showStandaloneLoader: import("@angular/core").Signal<boolean>;
+    /** @private Last query emitted by live mode, used to suppress duplicates. */
+    private _lastLiveQuery;
+    /** @private Marks model writes originating from this control's own UI. */
+    private _interactionValue;
+    /** @private Pending live-search timer, when a debounce window is active. */
+    private _pendingTimer;
+    /** @protected Backdrop class; the base appends `--leaving` on close. */
+    protected readonly _backdropClass = "mlv-search-field__backdrop";
+    /** @protected Attaches the overlay panel template. */
+    protected _getOverlayTemplate(): TemplateRef<unknown> | undefined;
+    /** @protected Full-viewport overlay: a plain global strategy, sized by config. */
+    protected _buildPositionStrategy(): PositionStrategy;
+    /** @protected Makes the pane cover the viewport so the body can centre within it. */
+    protected _buildExtraOverlayConfig(): OverlayConfig;
+    /** Reconciles controlled values and registers timer cleanup. */
+    constructor();
+    /** @protected Opens the overlay if it is enabled and not already open. */
+    protected _openOverlay(): void;
+    /**
+     * @protected Opens the overlay from a click on the inline trigger.
+     *
+     * The handler sits on the `mlv-input` host, so clicks on the field's own
+     * actions — the clear button — bubble through here too. Only the input itself
+     * is the trigger, so clearing a committed query does not force the overlay open.
+     *
+     * Deliberately not bound to focus. WAI-ARIA treats the control that opens a
+     * dialog as a button, activated by click or Enter/Space; opening on focus traps
+     * a keyboard user who is only tabbing past, and fights the focus the overlay
+     * restores to this same input on close — which would reopen it immediately.
+     */
+    protected _onTriggerClick(event: Event): void;
+    /**
+     * @protected Opens the overlay from Space on the inline trigger.
+     *
+     * The trigger is `readonly` while the overlay is enabled, so Space types
+     * nothing; `preventDefault` stops it from scrolling the page instead.
+     */
+    protected _onTriggerSpace(event: Event): void;
+    /**
+     * @protected Commits from inside the overlay.
+     *
+     * Submit mode has a commit action; live mode has already emitted through the
+     * debounce, so Enter there only dismisses. Either way the overlay closes, which
+     * restores focus to the trigger.
+     */
+    protected _submitFromOverlay(): void;
+    /** @protected Commits and closes when Enter is pressed on the overlay input. */
+    protected _onOverlayEnter(event: Event): void;
+    /** @protected Synchronises user input and schedules a live search if enabled. */
+    protected _onValueChange(value: string): void;
+    /**
+     * @protected Handles a non-composing Enter on the inline field.
+     *
+     * With the overlay enabled the field is a dialog trigger, so Enter opens it;
+     * otherwise Enter commits a submit-mode search. Either way the key is consumed:
+     * search fields commonly live inside forms, and neither action should also
+     * submit the surrounding form.
+     */
+    protected _onEnter(event: Event): void;
+    /**
+     * @protected Reports an option-navigation key while the field is a combobox.
+     *
+     * Silent for the default `role="searchbox"`, so a plain search field keeps
+     * every key it has today. See {@link navigate} for which keys are consumed.
+     */
+    protected _onNavigationKey(event: Event): void;
+    /** @protected Commits from the trailing submit action, offering it up first. */
+    protected _onSubmitClick(event: MouseEvent): void;
+    /**
+     * @private Offers the commit to the consumer and reports whether they took it.
+     *
+     * Nothing is offered while the field cannot commit anyway — disabled or with
+     * a request already in flight — so `commit` never fires for an interaction
+     * the field itself would have ignored.
+     */
+    private _consumerHandledCommit;
+    /** @protected Commits the current value from the submit action button. */
+    protected _submit(): void;
+    /** @protected Clears immediately and invalidates any pending live query. */
+    protected _clear(): void;
+    /** @private Starts or immediately resolves the trailing live-search window. */
+    private _scheduleLive;
+    /** @private Emits a live query only when it differs from the prior one. */
+    private _emitLive;
+    /** @private Writes a user-originated value without treating it as controlled input. */
+    private _setInteractionValue;
+    /** @private Cancels and forgets the current live-search timer. */
+    private _cancelPending;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSearchField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSearchField, "mlv-search-field", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "debounce": { "alias": "debounce"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "showSubmit": { "alias": "showSubmit"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "commitOnClear": { "alias": "commitOnClear"; "required": false; "isSignal": true; }; "presentation": { "alias": "presentation"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "ariaControls": { "alias": "ariaControls"; "required": false; "isSignal": true; }; "ariaActiveDescendant": { "alias": "ariaActiveDescendant"; "required": false; "isSignal": true; }; "ariaAutocomplete": { "alias": "ariaAutocomplete"; "required": false; "isSignal": true; }; "ariaExpanded": { "alias": "ariaExpanded"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "search": "search"; "navigate": "navigate"; "commit": "commit"; }, ["_overlayContentDef"], never, true, never>;
+}

package/search-field/lib/search-field/search-overlay-content.d.ts

@@ -0,0 +1,59 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Context handed to a `[mlvSearchOverlayContent]` template.
+ *
+ * The template replaces the overlay's default body entirely, so everything it
+ * needs to drive the field is passed in rather than reached for: the current
+ * query, the writers that keep the host's `value` model and live/submit
+ * behaviour intact, and the close action.
+ */
+export interface MlvSearchOverlayContentContext {
+    /** Current query. Available as the implicit template variable. */
+    $implicit: string;
+    /** Current query, for `let-query="query"`. */
+    query: string;
+    /** Whether a search is in flight, mirroring the host's `loading` input. */
+    loading: boolean;
+    /** Placeholder resolved from the host input or the active language pack. */
+    placeholder: string;
+    /** Accessible input label resolved the same way. */
+    ariaLabel: string;
+    /**
+     * Writes the query. Routes through the host's normal input path, so live mode
+     * still debounces and deduplicates and submit mode still waits for a commit.
+     */
+    setQuery: (value: string) => void;
+    /** Commits the current query immediately, bypassing any pending debounce. */
+    submit: () => void;
+    /** Clears the query, honouring the host's `commitOnClear`. */
+    clear: () => void;
+    /** Closes the overlay and returns focus to whatever opened it. */
+    close: () => void;
+}
+/**
+ * Replaces the default body of `mlv-search-field`'s overlay.
+ *
+ * Without it the overlay renders the field's own input, restyled for the
+ * overlay surface. With it the consumer owns the body completely — an
+ * autocomplete input, recent searches, grouped results — while the host keeps
+ * owning the overlay lifecycle, focus restore, and the `value`/`search` contract.
+ *
+ * @example
+ * ```html
+ * <mlv-search-field overlay>
+ *   <ng-template mlvSearchOverlayContent let-query let-setQuery="setQuery" let-close="close">
+ *     <mlv-input [value]="query" (valueChange)="setQuery($event)" [mlvAutocomplete]="options" />
+ *     <button mlvButton (click)="close()">Cancel</button>
+ *   </ng-template>
+ * </mlv-search-field>
+ * ```
+ */
+export declare class MlvSearchOverlayContentDef {
+    /** The template reference for the overlay body. */
+    readonly templateRef: TemplateRef<any>;
+    /** Type guard so `let-` variables infer from {@link MlvSearchOverlayContentContext}. */
+    static ngTemplateContextGuard(_directive: MlvSearchOverlayContentDef, _context: unknown): _context is MlvSearchOverlayContentContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSearchOverlayContentDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSearchOverlayContentDef, "[mlvSearchOverlayContent]", never, {}, {}, never, never, true, never>;
+}

package/search-field/malva-ui-core-search-field.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/search-field" />
+export * from './index';

package/segmented/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/segmented.types';
+export * from './lib/segmented-token';
+export * from './lib/segmented-item/segmented-item';
+export * from './lib/segmented/segmented';

package/segmented/lib/segmented/segmented.d.ts

@@ -0,0 +1,80 @@
+import type { ElementRef } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import { MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import { MlvSegmentedItem } from '../segmented-item/segmented-item';
+import type { MlvSegmentedAccessor } from '../segmented-token';
+import type { MlvSegmentedOrientation, MlvSegmentedTone } from '../segmented.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@malva-ui/cdk/density";
+/**
+ * Segmented control: a grey track holding `mlvSegmentedItem` buttons or links,
+ * with a raised pill sliding behind the active one (the boxed-tabs look).
+ *
+ * - **Radio mode** (`<button mlvSegmentedItem value="…">`): a signal-form
+ *   control (`[(value)]`, `[(ngModel)]`, `[formField]`) with `role="radiogroup"`
+ *   semantics, arrow-key navigation and a roving tabindex.
+ * - **Link mode** (`<a mlvSegmentedItem routerLink="…">`): plain navigation
+ *   links; the active one is derived from the router and marked
+ *   `aria-current="page"`.
+ */
+export declare class MlvSegmented extends MlvSignalFormControlBase<unknown> implements MlvSegmentedAccessor {
+    /** Two-way bindable selected value (radio mode). */
+    readonly value: import("@angular/core").ModelSignal<unknown>;
+    /** Colour of the active pill — `'neutral'` (boxed-tabs white) or a pale semantic tone. */
+    readonly tone: import("@angular/core").InputSignal<MlvSegmentedTone>;
+    /** Layout axis of the track. */
+    readonly orientation: import("@angular/core").InputSignal<MlvSegmentedOrientation>;
+    /** Stretch the track to its container and give every item the same size. */
+    readonly equalWidth: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Projected items in DOM order. */
+    readonly items: import("@angular/core").Signal<readonly MlvSegmentedItem[]>;
+    /** Whether the control holds a value — a segment is selected. */
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    /** @internal Track element hosting the pill and the projected items. */
+    protected readonly _trackRef: import("@angular/core").Signal<ElementRef<HTMLElement>>;
+    /** @internal Link mode: any item is an `<a>`. */
+    protected readonly _isLinkMode: import("@angular/core").Signal<boolean>;
+    /** @internal The item currently rendered as active, if any. */
+    protected readonly _activeItem: import("@angular/core").Signal<MlvSegmentedItem | null>;
+    /** @internal Set once the pill has been positioned; enables the slide transition. */
+    protected readonly _measured: import("@angular/core").WritableSignal<boolean>;
+    /** @internal Tone / orientation / state modifier classes. */
+    protected readonly _hostModifiers: import("@angular/core").Signal<string>;
+    /** @private Roving-focus manager over the items (radio mode only). */
+    private _keyManager;
+    /** @private Guards the mixed `<a>` / `<button>` dev warning to one per group instance. */
+    private _warnedMixed;
+    /** @private Guards the multiple-active dev warning to one per group instance. */
+    private _warnedMultiActive;
+    /** @private Destroys the key manager with the component. */
+    private readonly _destroyRef;
+    /** @private Shared ResizeObserver — re-measures the pill when the track resizes (fonts, density, content). */
+    private readonly _resizeService;
+    /** @private Bumped on every track resize to re-run the measuring render effect. */
+    private readonly _layoutVersion;
+    constructor();
+    /** Selects `item` (radio mode). Ignored while the group is disabled or readonly. */
+    selectItem(item: MlvSegmentedItem): void;
+    /** Keeps the key manager's active item in sync with the item that received DOM focus. */
+    onItemFocus(item: MlvSegmentedItem): void;
+    /**
+     * @internal Track keydown handler (radio mode). ArrowLeft/ArrowUp → previous,
+     * ArrowRight/ArrowDown → next (wrapping, skipping disabled), Home/End → first/last.
+     * Moving focus also selects (WAI-ARIA radio group), unless the group is readonly.
+     */
+    protected _onKeydown(event: KeyboardEvent): void;
+    /**
+     * @private Writes the active item's offset box (relative to the track — its
+     * `offsetParent`, so items must be direct children) into the four
+     * `--mlv-segmented-indicator-*` custom properties. Without an active item the
+     * pill collapses. On the first successful (non-zero) measurement `_measured`
+     * flips (one macrotask later, after a forced style flush) so the slide
+     * transition only ever animates *subsequent* moves — never a slide-in from
+     * `0` on load. A group first rendered without a box (inside `display: none`,
+     * a collapsed `mlv-expand`, a closed drawer) measures `0` and stays
+     * unmeasured until it is actually laid out.
+     */
+    private _measure;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSegmented, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSegmented, "mlv-segmented", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "equalWidth": { "alias": "equalWidth"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["items"], ["*"], true, [{ directive: typeof i1.MlvDensityDirective; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}

package/segmented/lib/segmented-item/segmented-item.d.ts

@@ -0,0 +1,89 @@
+import { ElementRef } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { IsActiveMatchOptions } from '@angular/router';
+import * as i0 from "@angular/core";
+/** `RouterLinkActive`-style match options accepted by `linkActiveOptions`. */
+export type MlvSegmentedLinkActiveOptions = {
+    exact: boolean;
+} | IsActiveMatchOptions;
+/**
+ * One segment of an `mlv-segmented`. Enhances a native `<button>` (radio mode)
+ * or `<a>` (link mode) — never a wrapper element, so native `disabled`,
+ * `type`, `href`, `routerLink` and middle-click all keep working.
+ *
+ * Items must be direct children of `mlv-segmented`.
+ */
+export declare class MlvSegmentedItem {
+    /** Host element — read by the group for focus and pill measurement. */
+    readonly elementRef: ElementRef<any>;
+    /** @internal Parent group accessor (template-facing for the focus binding). */
+    protected readonly _group: import("@malva-ui/core/segmented").MlvSegmentedAccessor;
+    /**
+     * @internal `type` attribute reflected on `<button>` hosts: the consumer's
+     * own value when present, else `"button"` so a segmented inside a `<form>`
+     * never submits it.
+     */
+    protected readonly _type: string;
+    /** Whether this item is an `<a>` (link mode) rather than a `<button>` (radio mode). */
+    readonly isLink: boolean;
+    /** Value written to the group's `value` model when this item is selected (radio mode). */
+    readonly value: import("@angular/core").InputSignal<unknown>;
+    /** Disables this single item. The group's `disabled` disables all items. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Explicit active override. When set (`true`/`false`) it wins over the
+     * value comparison (radio mode) and over router matching (link mode).
+     */
+    readonly active: import("@angular/core").InputSignal<boolean | undefined>;
+    /**
+     * Link mode only: match options for `Router.isActive` when the item carries a
+     * `routerLink` but no `routerLinkActive` (same shape as `mlv-tab`).
+     */
+    readonly linkActiveOptions: import("@angular/core").InputSignal<MlvSegmentedLinkActiveOptions>;
+    /** Roving tabindex (radio mode) — written by the group; `0` for the single tab stop. */
+    readonly tabIndex: import("@angular/core").WritableSignal<number>;
+    /** Item disabled by its own input or by the group. */
+    readonly isDisabled: import("@angular/core").Signal<boolean>;
+    /** @private Router — absent when the consumer app has no router. */
+    private readonly _router;
+    /** @private `routerLink` on this very element (link mode without `routerLinkActive`). */
+    private readonly _routerLink;
+    /** @private `routerLinkActive` on this very element — when present it owns the active state. */
+    private readonly _routerLinkActive;
+    /**
+     * @private Live `RouterLinkActive.isActive`, or `null` when the host has no
+     * `routerLinkActive`.
+     */
+    private readonly _rlaActive;
+    /** @private Bumped on every `NavigationEnd` so `_routerActive` re-evaluates `Router.isActive`. */
+    private readonly _navigationCount;
+    /** @private Removes the capture-phase disabled-click guard with the component. */
+    private readonly _destroyRef;
+    /**
+     * @internal Router-derived active state for link items: `routerLinkActive`
+     * when present on the host, else `Router.isActive(routerLink.urlTree,
+     * linkActiveOptions)`. `false` for buttons and for links without a
+     * `routerLink`.
+     */
+    protected readonly _routerActive: import("@angular/core").Signal<boolean>;
+    constructor();
+    /** Whether this item is the active segment (pill + `aria-checked` / `aria-current`). */
+    readonly isActive: import("@angular/core").Signal<boolean>;
+    /** Focuses the host element (used by the group's `FocusKeyManager`). */
+    focus(): void;
+    /**
+     * @internal Click handler. Radio-mode buttons ask the group to select this
+     * item; disabled `<button>`s never fire `click` natively.
+     *
+     * Disabled links never reach this handler — the capture-phase guard installed
+     * in the constructor stops the event first. The `preventDefault()` below is
+     * the belt-and-braces fallback for a click that somehow bypasses it.
+     *
+     * The parameter must stay `Event`: host-binding type checking types `$event`
+     * as `Event` (the compiler cannot infer the host element), so narrowing it to
+     * `MouseEvent` breaks every consumer that compiles this source.
+     */
+    protected _onClick(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSegmentedItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSegmentedItem, "button[mlvSegmentedItem], a[mlvSegmentedItem]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "linkActiveOptions": { "alias": "linkActiveOptions"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/segmented/lib/segmented-token.d.ts

@@ -0,0 +1,22 @@
+import type { Signal } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { MlvSegmentedItem } from './segmented-item/segmented-item';
+/**
+ * Contract `mlvSegmentedItem` uses to talk to its `mlv-segmented` parent
+ * without importing the concrete class (avoids the item ↔ container import
+ * cycle).
+ */
+export interface MlvSegmentedAccessor {
+    /** Current group value (radio mode). */
+    readonly value: Signal<unknown>;
+    /** Group-level disabled state (input or form field). */
+    readonly computedDisabled: Signal<boolean>;
+    /** Group-level readonly state — items stay focusable, selection is blocked. */
+    readonly readonly: Signal<boolean>;
+    /** Selects `item` (radio mode). No-op for disabled/readonly groups. */
+    selectItem(item: MlvSegmentedItem): void;
+    /** Keeps the key manager's active item in sync with DOM focus. */
+    onItemFocus(item: MlvSegmentedItem): void;
+}
+/** Injection token through which items reach their `mlv-segmented`. */
+export declare const MLV_SEGMENTED: InjectionToken<MlvSegmentedAccessor>;

package/segmented/lib/segmented.types.d.ts

@@ -0,0 +1,9 @@
+import type { MlvTone } from '@malva-ui/cdk/utils';
+/**
+ * Colour of the active pill. `'neutral'` is the boxed-tabs look (raised white
+ * pill, primary text); every other tone uses the matching *pale* background and
+ * semantic text colour.
+ */
+export type MlvSegmentedTone = 'neutral' | 'accent' | MlvTone;
+/** Layout axis of the segmented track. */
+export type MlvSegmentedOrientation = 'horizontal' | 'vertical';

package/segmented/malva-ui-core-segmented.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/segmented" />
+export * from './index';

package/select/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/select/select';
+export * from './lib/select-template.directives';
+export * from './lib/select-option';