@malva-ui/core 0.1.12

package/tile/lib/tile-header.d.ts

@@ -0,0 +1,6 @@
+import { MlvStructural } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+export declare class MlvTileHeader extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTileHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvTileHeader, "[mlvTileHeader]", never, {}, {}, never, never, true, never>;
+}

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

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

package/time-picker/README.md

@@ -0,0 +1,7 @@
+# time-picker
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test time-picker` to execute the unit tests.

package/time-picker/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/time-picker/time-picker';

package/time-picker/lib/time-picker/time-picker.d.ts

@@ -0,0 +1,135 @@
+import type { Signal } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvFormState, MlvFormControl } from '@malva-ui/core/form-utils';
+import { MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@malva-ui/cdk/density";
+/**
+ * Clock mode — 24-hour or 12-hour (AM/PM).
+ */
+export type MlvTimeMode = '24h' | '12h';
+/**
+ * Visual/validation state of the time picker. Mirrors {@link MlvFormState}.
+ */
+export type MlvTimePickerState = MlvFormState;
+/**
+ * Time picker component (`mlv-time-picker`) that allows users to select a time
+ * value using a compact trigger that opens a floating popup with scrollable
+ * drum-roll columns. Supports 24h and 12h (AM/PM) modes, optional seconds
+ * display, and integrates with signal, reactive, and template-driven forms.
+ *
+ * Emits values as `HH:mm` (24h format) or `HH:mm:ss` when `showSeconds` is true.
+ * In 12h mode the emitted value is still in 24h format internally.
+ */
+export declare class MlvTimePicker extends MlvSignalFormControlBase<string> implements MlvFormControl {
+    /** The `HH:mm`/`HH:mm:ss` value used by all Angular forms APIs. */
+    readonly value: import("@angular/core").ModelSignal<string>;
+    /**
+     * Clock mode — `'24h'` for 24-hour display (default) or `'12h'` for AM/PM.
+     */
+    readonly mode: import("@angular/core").InputSignal<MlvTimeMode>;
+    /**
+     * When `true`, shows a seconds column in addition to hours and minutes.
+     */
+    readonly showSeconds: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: Signal<import("@malva-ui/i18n").MlvTimePickerI18n>;
+    /** @protected Resolved aria-label: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedAriaLabel: Signal<string>;
+    /** @private Whether the time selection popup is open. */
+    readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    /** @private Internal signal for the selected hour (0–23 in 24h mode; 1–12 in 12h mode). */
+    protected readonly _hour: import("@angular/core").WritableSignal<number>;
+    /** @private Internal signal for the selected minute (0–59). */
+    protected readonly _minute: import("@angular/core").WritableSignal<number>;
+    /** @private Internal signal for the selected second (0–59). */
+    protected readonly _second: import("@angular/core").WritableSignal<number>;
+    /** @private AM/PM period — `'AM'` or `'PM'`. Only relevant in 12h mode. */
+    protected readonly _period: import("@angular/core").WritableSignal<"AM" | "PM">;
+    /** Unique ID for the message element, used for aria-describedby linking. */
+    /** Unique ID for the popup panel, used for aria-controls linking. */
+    readonly panelId: Signal<string>;
+    /** Override focused to also be true when the popup is open. */
+    readonly focused: Signal<boolean>;
+    /** @protected Formatted display value shown in the trigger. */
+    protected readonly _displayValue: Signal<string>;
+    /** @protected Hour items for the column — depends on mode. */
+    protected readonly _hourItems: Signal<number[]>;
+    /** @protected Minute items for the column (0–59). */
+    protected readonly _minuteItems: Signal<number[]>;
+    /** @protected Second items for the column (0–59). */
+    protected readonly _secondItems: Signal<number[]>;
+    /** @protected The hour value shown in the column (1–12 in 12h mode, 0–23 in 24h). */
+    protected readonly _displayHour: Signal<number>;
+    /** @private Reference to the trigger element for focus restoration after popup close. */
+    private readonly _triggerRef;
+    /**
+     * @private The rendered drum-roll columns (hours, minutes, optional seconds),
+     * in DOM order. They are `mlv-time-picker-column` children declared in this
+     * component's own template (inside `mlvPopupContent`), so a signal view query
+     * resolves them — even though the popup content renders in a detached overlay.
+     * Used for focus-on-open and inter-column Arrow navigation instead of reaching
+     * into the overlay DOM by class name.
+     */
+    private readonly _columns;
+    /** @private Density directive instance for reading the resolved density level. */
+    private readonly _densityDirective;
+    /** @protected Effective density to pass to the detached popup panel. */
+    protected readonly _effectiveDensity: Signal<import("@malva-ui/cdk/density").MlvDensity>;
+    constructor();
+    /**
+     * @protected Toggle the popup open/closed state.
+     */
+    protected _toggleDropdown(): void;
+    /**
+     * @private Build the time string from internal signals.
+     * Always returns 24h format: `HH:mm` or `HH:mm:ss`.
+     */
+    private _buildValue;
+    /**
+     * @private Parse a time string (`HH:mm` or `HH:mm:ss`) into internal signals.
+     */
+    private _parseValue;
+    /** Whether the control holds a clearable value — The drum always shows a time, so there is always a value. */
+    readonly hasValue: Signal<boolean>;
+    /** @private Synchronizes drum columns from an external model value. */
+    private _applyValue;
+    /**
+     * @protected Called when the popup opens. Focuses the first column listbox
+     * so keyboard navigation is immediately available.
+     */
+    protected _onPopupOpened(): void;
+    /**
+     * @protected Called when the popup closes. Restores focus to the trigger element.
+     */
+    protected _onPopupClosed(): void;
+    /** @protected Marks the control touched when the trigger loses focus. */
+    protected _onTriggerBlur(): void;
+    /**
+     * @protected Handle hour column value change.
+     */
+    protected _onHourChange(value: number): void;
+    /**
+     * @protected Handle minute column value change.
+     */
+    protected _onMinuteChange(value: number): void;
+    /**
+     * @protected Handle second column value change.
+     */
+    protected _onSecondChange(value: number): void;
+    /**
+     * @protected Toggle the AM/PM period in 12h mode.
+     */
+    protected _onPeriodChange(period: 'AM' | 'PM'): void;
+    /**
+     * @protected Handle ArrowLeft/ArrowRight on the columns container to move
+     * focus between column listboxes.
+     */
+    protected _onPanelKeydown(event: KeyboardEvent): void;
+    /**
+     * @private Write the current value to the forms model.
+     */
+    private _emitValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTimePicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvTimePicker, "mlv-time-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof i1.MlvDensityDirective; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}

package/time-picker/lib/time-picker-column/time-picker-column.d.ts

@@ -0,0 +1,111 @@
+import { type AfterViewInit } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+/**
+ * A single scrollable column for the time picker (hours, minutes, seconds).
+ *
+ * Renders a `<ul>` backed by `@angular/aria`'s headless `ngListbox`/`ngOption`
+ * pattern in **`focusMode="activedescendant"`** — focus stays on the `<ul>`
+ * container while `aria-activedescendant` tracks the active item. aria owns the
+ * roles (`listbox`/`option`), `aria-selected`, `aria-activedescendant`, roving
+ * `aria-activedescendant`, and all keyboard navigation (ArrowUp/Down wrap,
+ * Home/End, Enter/Space, and additive type-ahead).
+ *
+ * The CSS scroll-snap **drum-roll** UX is retained on top of aria: in
+ * `activedescendant` mode aria never moves DOM focus and never scrolls (its
+ * `scrollActiveItemIntoView()` is opt-in and is not called here), so it cannot
+ * fight the snap scrolling. Programmatic scroll (on external value change) and
+ * pointer/wheel scroll-to-select stay component-owned; on a scroll-driven change
+ * the aria active item is re-synced via {@link Listbox.gotoIndex} so a following
+ * Arrow key moves from the centered value rather than a stale one.
+ *
+ * @internal This component is not part of the public API and should not be used directly.
+ */
+export declare class MlvTimePickerColumn implements AfterViewInit {
+    /** The accessible label for the column (e.g. "Hours", "Minutes"). */
+    readonly label: import("@angular/core").InputSignal<string>;
+    /** The list of numeric values to display in the column. */
+    readonly items: import("@angular/core").InputSignal<number[]>;
+    /** The currently selected value in this column. */
+    readonly selectedValue: import("@angular/core").InputSignal<number>;
+    /** Whether the column is disabled. */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Emitted when the user selects a new value via scroll, click, or keyboard. */
+    readonly valueChange: import("@angular/core").OutputEmitterRef<number>;
+    /** @private Reference to the scrollable list element. */
+    private readonly _listRef;
+    /**
+     * @private The component's own `@for`-rendered `<li>` option elements, in DOM
+     * order. Replaces `querySelectorAll('.mlv-time-picker-column__item')` over the
+     * host — the items belong to this component's template, so a signal view query
+     * is the correct mechanism.
+     */
+    private readonly _itemEls;
+    /**
+     * @private The aria `Listbox` instance on the `<ul>`. Used to keep aria's
+     * internal active item aligned with the drum-roll scroll position.
+     */
+    private readonly _ariaListbox;
+    /** @private DestroyRef for cleanup. */
+    private readonly _destroyRef;
+    /** @protected Sanitized label key for use in element IDs (spaces replaced with hyphens). */
+    protected readonly _labelKey: import("@angular/core").Signal<string>;
+    /** @protected Formatted display items (zero-padded two digits). */
+    protected readonly _displayItems: import("@angular/core").Signal<{
+        value: number;
+        label: string;
+    }[]>;
+    /**
+     * @protected Bridges the scalar `selectedValue` input into aria's array-based
+     * (`V[]`) single-select value model. Single-select always holds ≤1 entry.
+     */
+    protected readonly _ariaValue: import("@angular/core").Signal<number[]>;
+    /**
+     * @protected Listbox tabindex. Forced to `-1` when disabled to preserve the
+     * historical contract; otherwise `undefined` so aria's pattern manages it
+     * (`0` in activedescendant mode — the container is the tab stop).
+     */
+    protected readonly _listboxTabIndex: import("@angular/core").Signal<-1 | undefined>;
+    /** @private Timer ID for scroll debounce. */
+    private _scrollTimer;
+    constructor();
+    ngAfterViewInit(): void;
+    /**
+     * Focus the column's listbox element.
+     * Used by the parent component for inter-column keyboard navigation.
+     */
+    focusList(): void;
+    /**
+     * The column's scrollable `<ul>` listbox element, or `null` before view init.
+     * Exposed so the parent time picker can identify which column currently holds
+     * focus (comparing against `document.activeElement`) when moving focus between
+     * columns, without reaching into child DOM by class name.
+     */
+    get listElement(): HTMLElement | null;
+    /**
+     * @protected Bridge aria's array `valueChange` back to the scalar output.
+     * Guards against no-op echoes so the parent form control is only touched on
+     * genuine changes.
+     */
+    protected _onAriaValueChange(values: number[]): void;
+    /**
+     * @protected Handle scroll events — debounced to avoid fighting with CSS
+     * scroll-snap during large swipes. aria attaches no scroll listener of its
+     * own, so this remains the sole owner of scroll-driven selection.
+     */
+    protected _onScroll(): void;
+    /**
+     * @private Read the current scroll position and update the selected value.
+     * Also re-aligns aria's active item so a subsequent Arrow key moves from the
+     * centered value.
+     */
+    private _syncIndexFromScroll;
+    /**
+     * @private Scroll the list to bring item at the given index into view.
+     * @param index - The index to scroll to.
+     * @param smooth - Whether to use smooth scroll behavior.
+     */
+    private _scrollToIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTimePickerColumn, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvTimePickerColumn, "mlv-time-picker-column", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "selectedValue": { "alias": "selectedValue"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}

package/time-picker/malva-ui-core-time-picker.d.ts

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

package/timeline/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/timeline/timeline';
+export * from './lib/timeline/timeline-item';
+export * from './lib/timeline/timeline-item-icon';
+export * from './lib/timeline/timeline-item-meta';
+export * from './lib/timeline/timeline.types';

package/timeline/lib/timeline/timeline-item-icon.d.ts

@@ -0,0 +1,24 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Slot directive for the icon or avatar displayed inside the timeline item node.
+ *
+ * Use with `<ng-template mlvTimelineItemIcon>` inside a `mlv-timeline-item` element.
+ * When provided, the projected content replaces the default circle node indicator.
+ *
+ * @example
+ * ```html
+ * <mlv-timeline-item title="Deployed">
+ *   <ng-template mlvTimelineItemIcon>
+ *     <svg lucideRocket [size]="16" />
+ *   </ng-template>
+ *   Deployment completed successfully.
+ * </mlv-timeline-item>
+ * ```
+ */
+export declare class MlvTimelineItemIcon {
+    /** The template reference for this icon slot. */
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTimelineItemIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvTimelineItemIcon, "[mlvTimelineItemIcon]", never, {}, {}, never, never, true, never>;
+}

package/timeline/lib/timeline/timeline-item-meta.d.ts

@@ -0,0 +1,24 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Slot directive for supplementary metadata content displayed in the timeline item.
+ *
+ * Use with `<ng-template mlvTimelineItemMeta>` inside a `mlv-timeline-item` element.
+ * Intended for badges, chips, status indicators, or other compact metadata.
+ *
+ * @example
+ * ```html
+ * <mlv-timeline-item title="Review">
+ *   <ng-template mlvTimelineItemMeta>
+ *     <mlv-badge tone="warning">Pending</mlv-badge>
+ *   </ng-template>
+ *   Awaiting code review.
+ * </mlv-timeline-item>
+ * ```
+ */
+export declare class MlvTimelineItemMeta {
+    /** The template reference for this meta slot. */
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTimelineItemMeta, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvTimelineItemMeta, "[mlvTimelineItemMeta]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,52 @@
+import { MlvTimelineItemIcon } from './timeline-item-icon';
+import { MlvTimelineItemMeta } from './timeline-item-meta';
+import type { MlvTimelineItemDirection, MlvTimelineItemTone } from './timeline.types';
+import * as i0 from "@angular/core";
+/**
+ * A single event entry within a `mlv-timeline`.
+ *
+ * Renders a node circle (or projected icon), a connector line segment, a title,
+ * an optional timestamp in a `<time>` element, optional meta slot content
+ * (badges, chips), and a default content slot for the event description.
+ *
+ * The `tone` input drives the icon node accent color via BEM modifier.
+ *
+ * @example
+ * ```html
+ * <mlv-timeline-item title="Deployed" timestamp="2025-03-26T10:00:00" tone="success">
+ *   <ng-template mlvTimelineItemIcon>
+ *     <svg lucideRocket [size]="16" />
+ *   </ng-template>
+ *   Release v2.0.0 was deployed to production.
+ * </mlv-timeline-item>
+ * ```
+ */
+export declare class MlvTimelineItem {
+    /** The heading text for this timeline event. Required. */
+    readonly title: import("@angular/core").InputSignal<string>;
+    /**
+     * The timestamp string for this event.
+     * Rendered inside a `<time>` element. Should be a human-readable date/time string;
+     * for machine-readable precision, use a full ISO 8601 string.
+     */
+    readonly timestamp: import("@angular/core").InputSignal<string>;
+    /**
+     * Semantic tone controlling the icon node accent color.
+     * Defaults to `'default'` (neutral).
+     */
+    readonly tone: import("@angular/core").InputSignal<MlvTimelineItemTone>;
+    /**
+     * MlvLayout direction for this item.
+     * - `'right'` (default): node circle on the left, content on the right.
+     * - `'left'`: content on the left, node circle on the right.
+     *
+     * Allows alternating left-right layouts within a single timeline.
+     */
+    readonly direction: import("@angular/core").InputSignal<MlvTimelineItemDirection>;
+    /** @protected Template slot for the icon or avatar inside the node circle. */
+    protected readonly _iconRef: import("@angular/core").Signal<MlvTimelineItemIcon | undefined>;
+    /** @protected Template slot for supplementary metadata (badges, chips, etc.). */
+    protected readonly _metaRef: import("@angular/core").Signal<MlvTimelineItemMeta | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTimelineItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvTimelineItem, "mlv-timeline-item", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "timestamp": { "alias": "timestamp"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; }, {}, ["_iconRef", "_metaRef"], ["*", "*"], true, never>;
+}

package/timeline/lib/timeline/timeline.d.ts

@@ -0,0 +1,27 @@
+import * as i0 from "@angular/core";
+/**
+ * Container component for a vertical timeline of events.
+ *
+ * Renders an ordered list (`<ol>`) that manages the vertical connector line
+ * between `mlv-timeline-item` children via CSS. Each child handles its own
+ * connector segment; the last child hides its connector automatically.
+ *
+ * @example
+ * ```html
+ * <mlv-timeline>
+ *   <mlv-timeline-item title="Submitted" timestamp="Mar 24, 2025" tone="info">
+ *     Form submitted by user.
+ *   </mlv-timeline-item>
+ *   <mlv-timeline-item title="Approved" timestamp="Mar 25, 2025" tone="success">
+ *     Approved by manager.
+ *   </mlv-timeline-item>
+ *   <mlv-timeline-item title="Completed" timestamp="Mar 26, 2025" tone="success">
+ *     Process completed.
+ *   </mlv-timeline-item>
+ * </mlv-timeline>
+ * ```
+ */
+export declare class MlvTimeline {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTimeline, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvTimeline, "mlv-timeline", never, {}, {}, never, ["*"], true, never>;
+}

package/timeline/lib/timeline/timeline.types.d.ts

@@ -0,0 +1,18 @@
+import type { MlvTone } from '@malva-ui/cdk/utils';
+/**
+ * Semantic tone for a timeline item.
+ * Drives the icon node accent color and status indicator.
+ *
+ * Extends the shared {@link MlvTone} vocabulary
+ * (`'info' | 'success' | 'warning' | 'danger'`) with:
+ *
+ * - `'default'` — neutral/gray (no semantic meaning)
+ */
+export type MlvTimelineItemTone = MlvTone | 'default';
+/**
+ * MlvLayout direction for a timeline item.
+ *
+ * - `'right'` — node on the left, content on the right (default)
+ * - `'left'` — node on the right, content on the left
+ */
+export type MlvTimelineItemDirection = 'left' | 'right';

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

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

package/title/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/title/title';

package/title/lib/title/title.d.ts

@@ -0,0 +1,63 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvFormControl } from '@malva-ui/core/form-utils';
+import { MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import * as i0 from "@angular/core";
+export type MlvTitleLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * Inline title component that decorates the host element with Malva UI heading
+ * typography. It can render projected content, bind to a model, or act as an
+ * editable control through signal, reactive, and template-driven forms.
+ */
+export declare class MlvTitle extends MlvSignalFormControlBase<string | null> implements MlvFormControl {
+    /** Explicit visual title level. Falls back to the host heading tag. */
+    readonly level: import("@angular/core").InputSignalWithTransform<MlvTitleLevel | undefined, string | number | null | undefined>;
+    /** Enables the auto-sizing editable textarea overlay. */
+    readonly editable: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Placeholder displayed when the editable field is empty. */
+    readonly placeholder: import("@angular/core").InputSignal<string>;
+    /** Signal-model API for directly binding the title text. */
+    readonly value: import("@angular/core").ModelSignal<string | null>;
+    /** @private Host element ref, used to read the host tag name for level inference. */
+    private readonly _hostElement;
+    /** @private Reference to the projected-content span, used to hydrate text from projected content. */
+    private readonly _projectionElement;
+    /** @private Trimmed text extracted from projected content. */
+    private readonly _projectedText;
+    /** @private Whether the component is currently driven by its internal editable value. */
+    private readonly _usesInternalValue;
+    /** @private Tracks whether internal state was last synced from an external `value`. */
+    private _syncedFromExternalValue;
+    /** @protected Whether the host element is a native `h1`–`h6` heading. */
+    protected readonly _isNativeHeading: import("@angular/core").Signal<boolean>;
+    /** @protected Resolved visual heading level — explicit `level` input or inferred from the host tag. */
+    protected readonly _resolvedLevel: import("@angular/core").Signal<MlvTitleLevel>;
+    /** @protected The effective title text: bound `value`, internal editable value, or projected content. */
+    protected readonly currentText: import("@angular/core").Signal<string>;
+    /** @protected Whether the projected `<ng-content>` should be shown (no value, not editable). */
+    protected readonly showProjectedContent: import("@angular/core").Signal<boolean>;
+    /** @protected Whether the bound value text should be shown (not editable, not projected). */
+    protected readonly showValueText: import("@angular/core").Signal<boolean>;
+    /** @protected Sizing text for the editable `<pre>` mirror (trailing newline keeps a blank line tall). */
+    protected readonly editorMeasureText: import("@angular/core").Signal<string>;
+    /** @protected Whether the editable field is empty and a placeholder should be shown. */
+    protected readonly editorShowsPlaceholder: import("@angular/core").Signal<boolean>;
+    /** @protected Current value bound to the editable `<textarea>`. */
+    protected readonly textareaValue: import("@angular/core").Signal<string>;
+    /** Internal text state used by editable mode and forms APIs. */
+    readonly internalValue: import("@angular/core").WritableSignal<string>;
+    /** @private The lowercased tag name of the host element (e.g. `h2`, `div`). */
+    private get _hostTagName();
+    constructor();
+    /** Handles interactive edits from the textarea overlay. */
+    onInput(event: Event): void;
+    /** Tracks focus state for form-field styling. */
+    onFocus(): void;
+    /** Tracks blur state for form-field styling and touched state. */
+    onBlur(): void;
+    /** Whether the control holds a clearable value — Non-empty text present. */
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    /** @private Reads projected text after render and seeds the editable value from it when appropriate. */
+    private _hydrateProjectedText;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvTitle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvTitle, "[mlvTitle]", never, { "level": { "alias": "level"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
+}

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

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

package/toast/index.d.ts

@@ -0,0 +1,10 @@
+export * from './lib/toast.types';
+export * from './lib/toast-ref';
+export * from './lib/toast-timer';
+export * from './lib/abstract-toast-container';
+export * from './lib/abstract-toast.service';
+export * from './lib/abstract-toast-item';
+export * from './lib/toast-item/toast-item';
+export * from './lib/toast-container/toast-container';
+export * from './lib/toast.service';
+export * from './lib/toast.directives';

package/toast/lib/abstract-toast-container.d.ts

@@ -0,0 +1,29 @@
+import type { Signal, Type } from '@angular/core';
+import type { MlvInternalBaseToast, MlvToastPosition } from './toast.types';
+import * as i0 from "@angular/core";
+export interface MlvIAbstractToastComponent<T extends MlvInternalBaseToast = MlvInternalBaseToast> {
+    toast: Signal<T>;
+}
+/**
+ * Abstract base for toast/notification container components.
+ * Manages the ordered list of active items for a single overlay position.
+ * Extend this class and add the @Component decorator to create a concrete container.
+ */
+export declare abstract class MlvAbstractToastContainerComponent<T extends MlvInternalBaseToast> {
+    /** The overlay position this container is responsible for. Set by the service. */
+    readonly position: import("@angular/core").WritableSignal<MlvToastPosition>;
+    readonly toasts: import("@angular/core").WritableSignal<T[]>;
+    abstract component: Type<MlvIAbstractToastComponent>;
+    /** @private Service-owned callback used by every item close source. */
+    private _closeHandler;
+    add(item: T): void;
+    remove(id: string): boolean;
+    isEmpty(): boolean;
+    setComponent(component: Type<MlvIAbstractToastComponent>): void;
+    /** Registers the service-owned close callback for timer, action, and dismiss-button requests. */
+    setCloseHandler(handler: (id: string) => void): void;
+    /** @protected Routes an item close request through the owning service. */
+    protected requestClose(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvAbstractToastContainerComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvAbstractToastContainerComponent<any>, never, never, {}, {}, never, never, true, never>;
+}

package/toast/lib/abstract-toast-item.d.ts

@@ -0,0 +1,44 @@
+import type { OnDestroy, OnInit } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import type { MlvInternalBaseToast } from './toast.types';
+import type { MlvIAbstractToastComponent } from './abstract-toast-container';
+import { MlvToastTimer } from './toast-timer';
+import * as i0 from "@angular/core";
+export declare abstract class MlvAbstractToastItem<T extends MlvInternalBaseToast = MlvInternalBaseToast> implements MlvIAbstractToastComponent<T>, OnInit, OnDestroy {
+    toast: import("@angular/core").InputSignal<T>;
+    /** @protected Auto-dismiss countdown timer for this toast item. */
+    protected readonly timer: MlvToastTimer;
+    /** @protected Dismiss callback that closes this item by id. */
+    protected readonly _dismiss: (id: string) => void;
+    /**
+     * @protected Host element ref, used to detect whether focus stays within the
+     * item when handling `focusout` (so intra-item focus moves do not resume the
+     * timer prematurely).
+     */
+    protected readonly _elementRef: ElementRef<any>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /** @protected Closes this toast item via the injected dismiss callback. */
+    protected onClose(): void;
+    /** @protected Pauses the auto-dismiss timer on pointer enter when `pauseOnHover` is set. */
+    protected onMouseEnter(): void;
+    /** @protected Resumes the auto-dismiss timer on pointer leave. */
+    protected onMouseLeave(): void;
+    /**
+     * @protected Pauses the auto-dismiss timer when keyboard focus enters the
+     * item, so keyboard users are not raced by the countdown (WCAG 2.2.1).
+     */
+    protected onFocusIn(): void;
+    /**
+     * @protected Resumes the auto-dismiss timer when focus leaves the item
+     * entirely. Focus moves between elements inside the same item are ignored.
+     */
+    protected onFocusOut(event: FocusEvent): void;
+    /**
+     * @private Restarts the countdown from the full `displayTime` when pausing is
+     * enabled and the item is auto-dismissable.
+     */
+    private _resumeTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvAbstractToastItem<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvAbstractToastItem<any>, never, never, { "toast": { "alias": "toast"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}