@malva-ui/core 0.1.12

package/data-table/lib/data-table/services/data-table-column-visibility.service.d.ts

@@ -0,0 +1,19 @@
+import * as i0 from "@angular/core";
+/**
+ * Tracks the user-toggled column hidden set for `mlv-data-table`.
+ * The component reads `isHidden(key)` while building `visibleColumns`
+ * and calls `toggle(key)` when the user clicks the column-visibility
+ * popup checkbox.
+ */
+export declare class MlvDataTableColumnVisibilityService {
+    /** @private Set of currently-hidden column keys. */
+    private readonly _hiddenColumns;
+    /** Read-only signal exposing the hidden-set for `effect()` consumers. */
+    readonly hiddenColumns: import("@angular/core").Signal<Set<string>>;
+    /** Whether a column is currently hidden by the user. */
+    isHidden(key: string): boolean;
+    /** Toggle visibility of a hideable column. */
+    toggle(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTableColumnVisibilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MlvDataTableColumnVisibilityService>;
+}

package/data-table/lib/data-table/services/data-table-editing.service.d.ts

@@ -0,0 +1,37 @@
+import * as i0 from "@angular/core";
+/**
+ * Component-scoped editing state for `mlv-data-table`. Holds the per-row
+ * snapshot map used for rollback on cancel and tracks whether a given row
+ * index is currently in edit mode. The component delegates `startEdit` /
+ * `saveEdit` / `cancelEdit` to this service and emits the matching outputs
+ * itself.
+ *
+ * Provided per-component via `providers: [MlvDataTableEditingService]` so each
+ * `mlv-data-table` instance has its own isolated editing state.
+ */
+export declare class MlvDataTableEditingService<T = Record<string, unknown>> {
+    /** @private Map of row-index → original row snapshot (for rollback). */
+    private readonly _editingRows;
+    /** Whether any row is currently being edited. */
+    isEditing(index: number): boolean;
+    /** Whether at least one row is currently being edited. */
+    hasActiveEdit(): boolean;
+    /**
+     * Begin editing the given row. Stores a shallow clone in the rollback map.
+     * Returns the cloned snapshot for the caller to emit on `rowEditStart`.
+     */
+    start(row: T, index: number): T;
+    /**
+     * Confirm edits for the given row. Returns the original snapshot (or the
+     * row itself if no snapshot was stored) so the caller can include it on
+     * the `rowEditSave` payload.
+     */
+    save(row: T, index: number): T;
+    /**
+     * Cancel editing the given row. Drops the snapshot. The caller is
+     * responsible for restoring the row data if it wants rollback semantics.
+     */
+    cancel(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTableEditingService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MlvDataTableEditingService<any>>;
+}

package/data-table/lib/data-table/services/data-table-pinning.service.d.ts

@@ -0,0 +1,37 @@
+import type { MlvDataTableColumn, MlvPinSide } from '../../types';
+import * as i0 from "@angular/core";
+/** @private Per-column pin override stored in the service. */
+interface PinOverride {
+    pinned: boolean;
+    pinSide: MlvPinSide;
+}
+/**
+ * Component-scoped pin-state service for `mlv-data-table`. Holds the
+ * user-driven pin/unpin overrides keyed by column key. The component
+ * delegates `togglePin`/`pinTo`/`unpin` and the read-side queries to
+ * this service while continuing to compute layout offsets internally.
+ */
+export declare class MlvDataTablePinningService {
+    /** @private Map of column key → user-applied pin override. */
+    private readonly _overrides;
+    /** Read-only signal exposing the override map for `effect()` consumers. */
+    readonly overrides: import("@angular/core").Signal<Map<string, PinOverride>>;
+    /**
+     * Returns the list of sides the user may pin a column to, based on
+     * `col.pinnable`.
+     */
+    getPinnableSides(col: MlvDataTableColumn): MlvPinSide[];
+    /** Pin a column to the given side, or unpin if it is already pinned. */
+    togglePin(col: MlvDataTableColumn, side?: MlvPinSide): void;
+    /** Pin a column to a specific side. */
+    pinTo(col: MlvDataTableColumn, side: MlvPinSide): void;
+    /** Explicitly unpin a column. */
+    unpin(col: MlvDataTableColumn): void;
+    /** Whether a column is currently pinned (accounting for overrides). */
+    isPinned(col: MlvDataTableColumn): boolean;
+    /** Pin side for a column (considering overrides) or null. */
+    getPinSide(col: MlvDataTableColumn): MlvPinSide | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTablePinningService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MlvDataTablePinningService>;
+}
+export {};

package/data-table/lib/data-table-cell.d.ts

@@ -0,0 +1,44 @@
+import { TemplateRef } from '@angular/core';
+import type { MlvDataSource } from './data-source';
+import * as i0 from "@angular/core";
+/** Context for DataTableCell templates */
+export interface MlvDataTableCellContext<T> {
+    $implicit: T;
+    row: T;
+    index: number;
+}
+/**
+ * Structural directive for providing custom cell templates with full type inference.
+ *
+ * Usage (asterisk shorthand — preferred):
+ * ```html
+ * <mlv-data-table [data]="employees" [columns]="columns">
+ *   <span *mlvDataTableCell="'salary'; let row from employees">
+ *     {{ row.salary.toLocaleString() }}
+ *   </span>
+ * </mlv-data-table>
+ * ```
+ *
+ * Usage (explicit ng-template):
+ * ```html
+ * <ng-template mlvDataTableCell="salary" [mlvDataTableCellFrom]="employees" let-row>
+ *   <span>{{ row.salary.toLocaleString() }}</span>
+ * </ng-template>
+ * ```
+ */
+export declare class MlvDataTableCell<T extends object = Record<string, unknown>> {
+    /** Column key this template applies to — typed as `keyof T` when `from` is provided. */
+    readonly columnKey: import("@angular/core").InputSignal<keyof T & string>;
+    /**
+     * Pass the same value as `[data]` on the parent `mlv-data-table`.
+     * Angular uses this to infer `T` and type `let-row` in the template.
+     */
+    readonly from: import("@angular/core").InputSignal<MlvDataSource<T> | T[] | undefined>;
+    readonly templateRef: TemplateRef<MlvDataTableCellContext<T>>;
+    /** Narrows the template context to `MlvDataTableCellContext<T>` for type-safe `let-row`. */
+    static ngTemplateContextGuard<T extends object>(_dir: MlvDataTableCell<T>, _ctx: unknown): _ctx is MlvDataTableCellContext<T>;
+    /** Enables `*mlvDataTableCell="'key'; let row from data"` microsyntax. */
+    static ngTemplateGuard_mlvDataTableCellFrom: 'binding';
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTableCell<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvDataTableCell<any>, "[mlvDataTableCell]", never, { "columnKey": { "alias": "mlvDataTableCell"; "required": true; "isSignal": true; }; "from": { "alias": "mlvDataTableCellFrom"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/data-table/lib/data-table-edit-cell.d.ts

@@ -0,0 +1,44 @@
+import { TemplateRef } from '@angular/core';
+import type { MlvDataSource } from './data-source';
+import * as i0 from "@angular/core";
+/** Context for DataTableEditCell templates */
+export interface MlvDataTableEditCellContext<T> {
+    $implicit: T;
+    row: T;
+    index: number;
+}
+/**
+ * Structural directive for providing custom edit-mode cell templates.
+ *
+ * When the table is in editable mode and a row enters editing, this template
+ * replaces the display template for the given column key.
+ *
+ * Usage (asterisk shorthand):
+ * ```html
+ * <mlv-input *mlvDataTableEditCell="'name'; let row from employees"
+ *   [ngModel]="row.name" (ngModelChange)="row.name = $event" />
+ * ```
+ *
+ * Usage (explicit ng-template):
+ * ```html
+ * <ng-template mlvDataTableEditCell="name" [mlvDataTableEditCellFrom]="employees" let-row>
+ *   <mlv-input [ngModel]="row.name" (ngModelChange)="row.name = $event" />
+ * </ng-template>
+ * ```
+ */
+export declare class MlvDataTableEditCell<T extends object = Record<string, unknown>> {
+    /** Column key this edit template applies to. */
+    readonly columnKey: import("@angular/core").InputSignal<keyof T & string>;
+    /**
+     * Pass the same value as `[data]` on the parent `mlv-data-table`.
+     * Angular uses this to infer `T` and type `let-row` in the template.
+     */
+    readonly from: import("@angular/core").InputSignal<MlvDataSource<T> | T[] | undefined>;
+    readonly templateRef: TemplateRef<MlvDataTableEditCellContext<T>>;
+    /** Narrows the template context to `MlvDataTableEditCellContext<T>` for type-safe `let-row`. */
+    static ngTemplateContextGuard<T extends object>(_dir: MlvDataTableEditCell<T>, _ctx: unknown): _ctx is MlvDataTableEditCellContext<T>;
+    /** Enables `*mlvDataTableEditCell="'key'; let row from data"` microsyntax. */
+    static ngTemplateGuard_mlvDataTableEditCellFrom: 'binding';
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTableEditCell<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvDataTableEditCell<any>, "[mlvDataTableEditCell]", never, { "columnKey": { "alias": "mlvDataTableEditCell"; "required": true; "isSignal": true; }; "from": { "alias": "mlvDataTableEditCellFrom"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/data-table/lib/data-table-error.d.ts

@@ -0,0 +1,37 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Template context handed to a `mlvDataTableError` template.
+ */
+export interface MlvDataTableErrorContext {
+    /** Resolved error message — the `error` string, or the localized default. */
+    $implicit: string;
+    /** Invoke to emit the table's `(retry)` output. */
+    retry: () => void;
+}
+/**
+ * Directive for the "request failed" slot. Rendered in place of the table body
+ * whenever `[error]` is truthy and the table is not loading, so a failed request
+ * is never mistaken for an empty result set.
+ *
+ * Usage:
+ * ```html
+ * <mlv-data-table [data]="rows()" [columns]="columns" [error]="error()" (retry)="reload()">
+ *   <ng-template mlvDataTableError let-message let-retry="retry">
+ *     <p>{{ message }}</p>
+ *     <button mlvButton variant="secondary" type="button" (click)="retry()">Try again</button>
+ *   </ng-template>
+ * </mlv-data-table>
+ * ```
+ */
+export declare class MlvDataTableError {
+    /** The projected template rendered instead of the default error block. */
+    readonly templateRef: TemplateRef<any>;
+    /**
+     * Type guard so Angular narrows `let-message` / `let-retry="retry"` to
+     * {@link MlvDataTableErrorContext} in strict templates.
+     */
+    static ngTemplateContextGuard(_dir: MlvDataTableError, _ctx: unknown): _ctx is MlvDataTableErrorContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTableError, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvDataTableError, "[mlvDataTableError]", never, {}, {}, never, never, true, never>;
+}

package/data-table/lib/data-table-footer.d.ts

@@ -0,0 +1,26 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive for the footer summary row slot.
+ *
+ * The template context provides `{ $implicit: columns }` where `columns`
+ * is the current visible column list.
+ *
+ * Usage:
+ * ```html
+ * <mlv-data-table ...>
+ *   <ng-template mlvDataTableFooter let-cols>
+ *     <th scope="row" [attr.colspan]="cols.length - 1">Total</th>
+ *     <td>...</td>
+ *   </ng-template>
+ * </mlv-data-table>
+ * ```
+ *
+ * Direct `th` and `td` children receive the table's density, divider, sticky
+ * surface, and bordered-cell styling without private component classes.
+ */
+export declare class MlvDataTableFooter {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTableFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvDataTableFooter, "[mlvDataTableFooter]", never, {}, {}, never, never, true, never>;
+}

package/data-table/lib/data-table-no-data.d.ts

@@ -0,0 +1,19 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive for the "no data" slot.
+ *
+ * Usage:
+ * ```html
+ * <mlv-data-table ...>
+ *   <ng-template mlvDataTableNoData>
+ *     <p>No records found.</p>
+ *   </ng-template>
+ * </mlv-data-table>
+ * ```
+ */
+export declare class MlvDataTableNoData {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDataTableNoData, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvDataTableNoData, "[mlvDataTableNoData]", never, {}, {}, never, never, true, never>;
+}

package/data-table/lib/filter-dropdown/filter-dropdown.d.ts

@@ -0,0 +1,54 @@
+import type { MlvSelectOptionTransform } from '@malva-ui/core/select';
+import type { MlvDataSourceFilterOperator, MlvFilterState } from '@malva-ui/cdk/data-source';
+import type { MlvDataTableFilterOption, MlvDataTableColumn } from '../types';
+import * as i0 from "@angular/core";
+export declare class MlvFilterDropdown {
+    readonly columns: import("@angular/core").InputSignal<readonly MlvDataTableColumn<unknown>[]>;
+    readonly activeFilters: import("@angular/core").ModelSignal<MlvFilterState[]>;
+    readonly closed: import("@angular/core").OutputEmitterRef<void>;
+    /** @protected Injected i18n translations for the data table. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvDataTableI18n>;
+    /** @protected Shared operator and filter-action translations. */
+    protected readonly _filterI18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvFilterI18n>;
+    /** @private Resolver for ICU parameterized i18n strings. */
+    private readonly _resolver;
+    /** @private Host used to place focus in the first editor after overlay creation. */
+    private readonly _host;
+    /** @protected Transform mapping a `MlvDataSourceFilterOperator` to a `MlvSelectOption` for the operator dropdown. */
+    protected readonly operatorTransform: MlvSelectOptionTransform<MlvDataSourceFilterOperator>;
+    /** @protected The subset of columns that are marked filterable. */
+    protected readonly filterableColumns: import("@angular/core").Signal<MlvDataTableColumn<unknown>[]>;
+    /** @private Working copy of in-progress filter edits, keyed by column key. */
+    private readonly _localFilters;
+    constructor();
+    /** @protected Returns the allowed operators for a column, falling back to the defaults. */
+    protected operators(col: MlvDataTableColumn): readonly MlvDataSourceFilterOperator[];
+    /** @protected Returns the configured filter options for a column, or an empty list. */
+    protected options(col: MlvDataTableColumn): readonly MlvDataTableFilterOption[];
+    /** @protected Returns the working filter state for a column key, creating a default if absent. */
+    protected getFilter(key: string): MlvFilterState;
+    /** @protected Updates the operator of the working filter for a column key. */
+    protected setOperator(key: string, operator: MlvDataSourceFilterOperator): void;
+    /** @protected Updates the value of the working filter for a column key. */
+    protected setValue(key: string, value: unknown): void;
+    /** @protected Commits non-empty working filters to `activeFilters` and closes the dropdown. */
+    protected apply(): void;
+    /** @protected Clears all working and active filters, then closes the dropdown. */
+    protected clear(): void;
+    /** @protected Discards draft edits and asks the owning popup to close. */
+    protected cancel(): void;
+    /** @protected Toggles a value in a multi-select (array) filter for a column key. */
+    protected toggleInArray(key: string, value: unknown): void;
+    /** @protected Returns whether a value is currently selected in a column's array filter. */
+    protected isInArray(key: string, value: unknown): boolean;
+    /** @protected Resolves the filterByColumn ICU string for a given column name. */
+    protected resolveFilterPlaceholder(columnName: string): string;
+    /** @protected Localized accessible name for one column's operator selector. */
+    protected resolveOperatorLabel(col: MlvDataTableColumn): string;
+    /** @private Operator used when a field has no committed or draft value. */
+    private _defaultOperator;
+    /** @private Resolves one operator key through the shared filter translations. */
+    private _operatorLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvFilterDropdown, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvFilterDropdown, "mlv-dt-filter-dropdown", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "activeFilters": { "alias": "activeFilters"; "required": false; "isSignal": true; }; }, { "activeFilters": "activeFiltersChange"; "closed": "closed"; }, never, never, true, never>;
+}

package/data-table/lib/types.d.ts

@@ -0,0 +1,134 @@
+import type { MlvTone } from '@malva-ui/cdk/utils';
+import type { MlvDataSourceFilterOperator } from '@malva-ui/cdk/data-source';
+export type { MlvSearchFieldTrigger } from '@malva-ui/core/search-field';
+/** @deprecated Use `MlvDataSourceFilterOperator` from `@malva-ui/cdk/data-source`. */
+export type MlvDataTableFilterOperator = MlvDataSourceFilterOperator;
+export interface MlvDataTableFilterOption {
+    label: string;
+    value: unknown;
+}
+/** Where filter controls are presented by the data table. */
+export type MlvFilterDisplay = 'toolbar' | 'column' | 'none';
+export interface MlvColumnFilterConfig {
+    options?: MlvDataTableFilterOption[];
+    operators?: MlvDataSourceFilterOperator[];
+}
+export type MlvColumnResponsive = Record<string | number, 'hidden' | 'visible'>;
+export type MlvColumnAlign = 'left' | 'center' | 'right';
+/** Side a column can be pinned to. */
+export type MlvPinSide = 'left' | 'right';
+/**
+ * Maps raw cell values to human-readable labels for a column's default cell
+ * renderer. Either an object keyed by the stringified raw value, or the same
+ * `{ label, value }` option list already used by `filterConfig.options`.
+ */
+export type MlvColumnValueLabels = Record<string, string> | ReadonlyArray<MlvDataTableFilterOption>;
+/**
+ * Resolves the semantic tone of one row so a column's default cell can render a
+ * toned `mlv-badge`. Returning `null`/`undefined` falls back to plain text.
+ *
+ * Declared through the method-syntax bivariance form so a column list authored
+ * against a concrete row type (`MlvDataTableColumn<User>[]`) stays assignable to
+ * the table's `MlvDataTableColumn[]` input.
+ */
+export type MlvColumnToneFn<T = unknown> = {
+    bivarianceHack(row: T): MlvTone | null | undefined;
+}['bivarianceHack'];
+export interface MlvDataTableColumn<T = unknown> {
+    key: string;
+    title?: string;
+    sortable?: boolean;
+    /** Include this column in the table's global search. */
+    searchable?: boolean;
+    filterable?: boolean;
+    /**
+     * Controls whether the user can toggle the pin state via the header pin button, and which sides are allowed.
+     * - `true` — both sides allowed (clicking opens a popup with Pin Left / Pin Right / Unpin options).
+     * - `'left'` / `'right'` — only the given side is allowed; clicking the pin button toggles directly.
+     * - `['left', 'right']` — explicit list of allowed sides. A single-element list behaves like the direct-toggle string form; a multi-element list opens the popup.
+     * - `false` / `undefined` — the column cannot be user-pinned (it may still be pinned at load time via `pinned`/`pinSide`).
+     */
+    pinnable?: boolean | MlvPinSide | MlvPinSide[];
+    pinned?: boolean;
+    pinSide?: MlvPinSide;
+    hideable?: boolean;
+    align?: MlvColumnAlign;
+    resizable?: boolean;
+    width?: string;
+    minWidth?: string;
+    /** Maximum width allowed while resizing. Pixel and percentage values are resolved to rendered CSS pixels. */
+    maxWidth?: string;
+    responsive?: MlvColumnResponsive;
+    filterConfig?: MlvColumnFilterConfig;
+    /**
+     * Human-readable labels for the raw values of this column, used by the
+     * **default** cell renderer only (a `mlvDataTableCell` template still wins).
+     * Accepts a `Record<rawValue, label>` or a `{ label, value }` list.
+     *
+     * When omitted, the table falls back to `filterConfig.options`, so a column
+     * that already declares option filters renders its option labels for free.
+     */
+    valueLabels?: MlvColumnValueLabels;
+    /**
+     * Semantic tone for the default cell renderer. When set (either a fixed
+     * {@link MlvTone} or a per-row resolver), the default cell renders the value
+     * as a muted `mlv-badge` instead of plain text. A resolver returning
+     * `null`/`undefined` renders that row's cell as plain text.
+     *
+     * Ignored when a `mlvDataTableCell` template is provided for the column.
+     */
+    tone?: MlvTone | MlvColumnToneFn<T>;
+}
+/** Interaction that committed a user-controlled column width. */
+export type MlvColumnResizeSource = 'pointer' | 'keyboard' | 'reset';
+/** Payload emitted after a column width is committed or reset. */
+export interface MlvColumnResizeEvent {
+    /** Key of the resized column. */
+    key: string;
+    /**
+     * Committed width in CSS pixels. `null` means the user override was removed
+     * and the column returned to its declared/default width.
+     */
+    width: number | null;
+    /** Interaction that committed the change. */
+    source: MlvColumnResizeSource;
+}
+export interface MlvDataTableColumnGroup {
+    /** Display title for the group header cell. */
+    title: string;
+    /** Column keys this group spans. */
+    columns: string[];
+    /** Optional alignment for the group header cell. */
+    align?: MlvColumnAlign;
+}
+export type MlvEditMode = 'row' | 'cell';
+export interface MlvEditEvent<T = Record<string, unknown>> {
+    row: T;
+    index: number;
+}
+export interface MlvEditSaveEvent<T = Record<string, unknown>> {
+    row: T;
+    index: number;
+    originalRow: T;
+}
+export interface MlvRowClickEvent<T = Record<string, unknown>> {
+    row: T;
+    index: number;
+    event: MouseEvent;
+}
+export type MlvSelectableMode = 'single' | 'multi' | false;
+export interface MlvSelectionChangeEvent<T = Record<string, unknown>> {
+    selectedRows: Set<T>;
+    row?: T;
+}
+/** Pagination strategy for the data table. `'paged'` renders the classic paginator footer; `'infinite'` hides it and emits `loadMore` as the user scrolls near the bottom. */
+export type MlvPaginationMode = 'paged' | 'infinite';
+/** Payload emitted by the data table when infinite scroll crosses the threshold. */
+export interface MlvLoadMoreEvent {
+    /** Next page the consumer should request (1-based). */
+    page: number;
+    /** Items-per-page configured on the table. */
+    perPage: number;
+    /** Distance in px from the bottom of the scroll container when the event fired. */
+    distance: number;
+}

package/data-table/malva-ui-core-data-table.d.ts

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

package/date-range-picker/index.d.ts

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

package/date-range-picker/lib/date-range-picker/date-range-picker.d.ts

@@ -0,0 +1,145 @@
+import { type MlvCalendarRangeValue } from '@malva-ui/core/calendar';
+import { MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import type { MlvFormState, MlvFormControl } from '@malva-ui/core/form-utils';
+import * as i0 from "@angular/core";
+/**
+ * Visual/validation state of the date range picker. Mirrors {@link MlvFormState}.
+ */
+export type MlvDateRangePickerState = MlvFormState;
+/**
+ * Value shape for the date range picker.
+ * Both `start` and `end` can be `null` when not yet selected.
+ */
+export interface MlvDateRangePickerValue<D = Date> {
+    /** The start date of the selected range. */
+    start: D | null;
+    /** The end date of the selected range. */
+    end: D | null;
+}
+export declare class MlvDateRangePicker<D = Date> extends MlvSignalFormControlBase<MlvDateRangePickerValue<D> | null> implements MlvFormControl {
+    /** The committed date range used by all Angular forms APIs. */
+    readonly value: import("@angular/core").ModelSignal<MlvDateRangePickerValue<D> | null>;
+    /** @private The active date adapter — a provided `MLV_DATE_ADAPTER`, or the native fallback. */
+    private readonly _dateAdapter;
+    /**
+     * The pending range being assembled during selection.
+     * Committed to the form control only when the user clicks Apply.
+     */
+    protected readonly _pendingRange: import("@angular/core").WritableSignal<MlvCalendarRangeValue<D> | null>;
+    /**
+     * The last committed range value (reflects the form control value).
+     */
+    readonly rangeValue: import("@angular/core").ModelSignal<MlvDateRangePickerValue<D> | null>;
+    /** Custom placeholder override. Falls back to the i18n-provided placeholder. */
+    readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
+    /** Minimum selectable date, passed to both calendars. */
+    readonly min: import("@angular/core").InputSignalWithTransform<D | null, D | MlvDateRangePickerValue<D> | null | undefined>;
+    /** Maximum selectable date, passed to both calendars. */
+    readonly max: import("@angular/core").InputSignalWithTransform<D | null, D | MlvDateRangePickerValue<D> | null | undefined>;
+    /** Optional callback for disabling arbitrary dates, passed to both calendars. */
+    readonly disabledDates: import("@angular/core").InputSignal<((date: D) => boolean) | null>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvDateRangePickerI18n>;
+    /**
+     * @private Reference to the trigger element, used to restore focus when the
+     * popup closes. It is declared in this component's own template, so a signal
+     * view query is the correct mechanism (was a host `querySelector`).
+     */
+    private readonly _triggerRef;
+    /** @private Locates the first tabbable element inside the popup panel. */
+    private readonly _tabbable;
+    /** @private Document ref for locating the rendered popup panel by id. */
+    private readonly _document;
+    /** @protected Resolved placeholder: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedPlaceholder: import("@angular/core").Signal<string>;
+    /**
+     * @internal Whether the picker popup is currently open.
+     */
+    protected readonly _isOpen: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * @internal Whether a range selection is in progress (start chosen, awaiting end click).
+     */
+    protected readonly _isSelecting: import("@angular/core").Signal<boolean>;
+    /**
+     * Override focused to also be true when the calendar popup is open.
+     */
+    readonly focused: import("@angular/core").Signal<boolean>;
+    /** Unique ID for the optional message element used by aria-describedby. */
+    /** Unique ID for the popup panel element used by aria-controls. */
+    readonly panelId: import("@angular/core").Signal<string>;
+    /**
+     * The initial date for the left (earlier-month) calendar panel.
+     * Defaults to today when no range is selected.
+     */
+    readonly leftCalendarActiveDate: import("@angular/core").Signal<D>;
+    /**
+     * The initial date for the right (later-month) calendar panel.
+     * Always one month ahead of the left panel's month.
+     */
+    readonly rightCalendarActiveDate: import("@angular/core").Signal<D>;
+    /**
+     * The formatted start date display string.
+     * Returns an empty string when no start date is selected.
+     */
+    get startDisplayValue(): string;
+    /**
+     * The formatted end date display string.
+     * Returns an empty string when no end date is selected.
+     */
+    get endDisplayValue(): string;
+    /**
+     * Whether the Apply button should be enabled.
+     * Requires both start and end dates to be set in the pending range.
+     */
+    readonly canApply: import("@angular/core").Signal<boolean>;
+    /**
+     * Whether the clear button should be shown.
+     */
+    readonly hasClearableValue: import("@angular/core").Signal<boolean>;
+    /**
+     * Toggles the popup open/closed.
+     * No-op when the picker is disabled.
+     */
+    toggleDropdown(): void;
+    /**
+     * @protected Moves focus into the popup panel when it opens.
+     * Focuses the first tabbable element, falling back to the panel container
+     * (which carries `tabindex="-1"`) so focus always lands inside the modal.
+     */
+    protected _onPanelOpened(): void;
+    /**
+     * @protected Handles popup close: clears the focused state and returns focus
+     * to the trigger, matching the overlay focus-restore pattern.
+     */
+    protected _onPanelClosed(): void;
+    /** @protected Marks the control touched when its trigger loses focus. */
+    protected _onTriggerBlur(): void;
+    /**
+     * Closes the popup and resets the pending selection to the committed value.
+     */
+    closeDropdown(): void;
+    /**
+     * Handles range value changes from either calendar.
+     * Updates the pending (uncommitted) range.
+     *
+     * @param range - The updated range value from the calendar.
+     */
+    onRangeChanged(range: MlvCalendarRangeValue<D> | null): void;
+    /**
+     * Applies the pending range selection and closes the popup.
+     * Commits the value to the form control.
+     */
+    applySelection(): void;
+    /**
+     * Clears the selected range and resets the picker.
+     */
+    clearSelection(): void;
+    /** Whether the control holds a clearable value — A committed range is set. */
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    /**
+     * @private Formats a single date for display.
+     */
+    private _formatDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDateRangePicker<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDateRangePicker<any>, "mlv-date-range-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "disabledDates": { "alias": "disabledDates"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}

package/date-range-picker/malva-ui-core-date-range-picker.d.ts

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

package/day-picker/index.d.ts

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