@malva-ui/core 0.1.12

package/combobox/lib/combobox/combobox.d.ts

@@ -0,0 +1,400 @@
+import type { ConnectedPosition } from '@angular/cdk/overlay';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import type { MlvPopupMobileMode } from '@malva-ui/core/popup';
+import type { MlvFormControl } from '@malva-ui/core/form-utils';
+import { MlvSelectionService, MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import type { MlvOptionMatcher, MlvOptionsInput, MlvOptionsSearchFn, MlvSelectOption, MlvSelectOptionTransform } from '@malva-ui/core/dropdown';
+import { MlvOptionsAdapter } from '@malva-ui/core/dropdown';
+import { MlvComboboxItemDef, MlvComboboxSelectedItemDef } from '../combobox-template.directives';
+import { LucideChevronDown, LucideChevronUp } from '@lucide/angular';
+import type { MlvDensity } from '@malva-ui/cdk/density';
+import * as i0 from "@angular/core";
+export declare class MlvCombobox<T> extends MlvSignalFormControlBase<T | T[] | null> implements MlvFormControl {
+    /** The scalar, array, or null selection used by all Angular forms APIs. */
+    readonly value: import("@angular/core").ModelSignal<T | T[] | null>;
+    /**
+     * Selectable options: a plain array, an observable of arrays, or an
+     * `MlvDataSource` (source-side search + lazy paging). Arrays and observables
+     * are filtered locally by the typed query; a data source owns its filtering
+     * and receives the query through `setSearch`.
+     */
+    readonly options: import("@angular/core").InputSignal<MlvOptionsInput<T>>;
+    /**
+     * Remote search: `(query) => T[] | Promise<T[]> | Observable<T[]>`. When set it
+     * supersedes {@link options} as the item source; the list is not filtered
+     * locally. Bind `[loading]` yourself if you want a spinner beyond the
+     * source-owned one.
+     */
+    readonly searchFn: import("@angular/core").InputSignal<MlvOptionsSearchFn<T> | null>;
+    /** Debounce (ms) for remote searches (`MlvDataSource` / {@link searchFn}). Local filtering stays instant. */
+    readonly searchDebounce: import("@angular/core").InputSignal<number>;
+    /** Whether multiple options can be selected at once. */
+    readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Custom placeholder override. Falls back to the i18n-provided placeholder. */
+    readonly placeholder: import("@angular/core").InputSignal<string | undefined>;
+    /** Whether the user can create a new value via Enter when no option matches. */
+    readonly allowCreate: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly toOption: import("@angular/core").InputSignal<MlvSelectOptionTransform<T>>;
+    /**
+     * Equality predicate used to match option values against the current
+     * selection (and against values written through any forms binding).
+     * Defaults to reference equality. Provide a custom comparator — e.g.
+     * `(a, b) => a.id === b.id` — so object values survive a serialize /
+     * deserialize round-trip and still match their option instances (check-marks
+     * and the displayed label stay in agreement).
+     */
+    readonly compareWith: import("@angular/core").InputSignal<(a: T, b: T) => boolean>;
+    /**
+     * Custom predicate deciding whether an option satisfies the current query
+     * (e.g. fuzzy or secondary-field matching). Defaults to the shared case- and
+     * diacritic-insensitive substring match. Filtered results are always ranked
+     * prefix-matches-first by the shared `filterOptions`, regardless of matcher.
+     * Mirrors `[mlvAutocomplete]`'s `mlvAutocompleteMatcher`.
+     */
+    readonly matcher: import("@angular/core").InputSignal<MlvOptionMatcher<T> | undefined>;
+    /** Emitted only when the user actually creates a brand-new value via Enter. */
+    readonly valueCreated: import("@angular/core").OutputEmitterRef<T>;
+    /**
+     * Controls whether the dropdown renders as a full-screen mobile sheet.
+     *
+     * Passed straight through to the underlying `mlv-popup`. Defaults to
+     * `'auto'` — full-screen below the `md` breakpoint (viewport < 768px),
+     * trigger-anchored above it — matching `mlv-select` and the date/time
+     * pickers. Set to `'off'` to always anchor, or `'fullscreen'` to always
+     * render the sheet (e.g. demos).
+     *
+     * In full-screen mode the search field would normally be occluded by the
+     * solid backdrop and blocked by the sheet's focus trap (it lives in the
+     * trigger row, outside the overlay panel). The combobox therefore projects an
+     * **in-sheet search input** into the popup's `[mlvPopupHeaderContent]` slot,
+     * wired to the same `searchQuery` and keyboard handlers, so type-to-filter
+     * keeps working.
+     */
+    readonly mobileMode: import("@angular/core").InputSignal<MlvPopupMobileMode>;
+    /**
+     * Density applied to the dropdown's option list.
+     *
+     * The dropdown panel is portaled to the CDK overlay container, outside the
+     * component's DOM tree, so ancestor density classes cannot cascade into it.
+     * This input is forwarded to the underlying `mlv-popup`, which stamps the
+     * resolved `mlv--{density}` class on the detached panel. When omitted, the
+     * nearest ancestor `MLV_DENSITY_CONTEXT` (e.g. a `form[mlvForm]`) applies,
+     * then the global `MlvDensityService`.
+     */
+    readonly mlvDensity: import("@angular/core").InputSignal<MlvDensity | undefined>;
+    /**
+     * Optional visible heading rendered in the full-screen sheet's header bar.
+     * When omitted, falls back to the field's `label` (or, when unset, the
+     * resolved placeholder). Only shown while the dropdown is full-screen.
+     */
+    readonly mobileTitle: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * @protected Resolved full-screen sheet title: explicit `mobileTitle` input
+     * takes precedence over the field's label, then the resolved placeholder.
+     */
+    protected readonly _resolvedMobileTitle: import("@angular/core").Signal<string>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvComboboxI18n>;
+    protected readonly _formI18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvFormUtilsI18n>;
+    /** @protected Resolved placeholder: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedPlaceholder: import("@angular/core").Signal<string>;
+    readonly focused: import("@angular/core").Signal<boolean>;
+    /**
+     * @private Latches `true` the first time a **remote** source reports
+     * `ready()`, and never flips back. It gates {@link _adapter}'s `eager` flag
+     * off for good.
+     *
+     * Without the latch, a `searchFn` bound to an inline arrow — a fresh
+     * reference on every change detection run — re-arms the adapter's lazy gate
+     * on every pass; while `eager` is still `true` (a committed value the first
+     * response did not contain) each pass would fire another request, whose
+     * result triggers the next pass. The latch bounds that to exactly one eager
+     * load per mount.
+     */
+    private readonly _eagerDone;
+    /**
+     * @protected Shared source adapter — arrays / observables are local (this
+     * component filters), a data source or a `searchFn` is remote (the source
+     * filters and the items render as-is). Template-facing: the paging bindings
+     * (`hasMore` / `loadingMore` / `loadMore`) read straight off it.
+     *
+     * The `eager` closure reads {@link hasValue} / {@link _allValuesMatched}
+     * lazily, so declaring those below is fine — the adapter's effects run after
+     * construction. A committed value with no resolvable label is what makes a
+     * `searchFn` load without waiting for the first open. The explicit type
+     * annotation breaks the inference cycle that closure creates
+     * (`_adapter` → `eager` → `_allValuesMatched` → `resolvedOptions` → `_adapter`).
+     */
+    protected readonly _adapter: MlvOptionsAdapter<T>;
+    /** @private ICU resolver for parameterised i18n strings. */
+    private readonly _resolver;
+    /** @private Last query sent to a remote source (so a close can reset it once). */
+    private _remoteQuery;
+    readonly resolvedOptions: import("@angular/core").Signal<MlvSelectOption<T>[]>;
+    readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+    /** Current text in the input. For single-select this doubles as the committed label when not actively searching. */
+    readonly searchQuery: import("@angular/core").WritableSignal<string>;
+    readonly triggerWidth: import("@angular/core").WritableSignal<number>;
+    /** @private Whether `searchQuery` represents live user search text (vs. a displayed committed label). */
+    private readonly _searching;
+    /**
+     * @private Shared activedescendant bookkeeping: tracks the active (highlighted)
+     * option index over the filtered options with wrap-around navigation. The same
+     * engine backs `[mlvAutocomplete]`.
+     */
+    private readonly _activeDescendant;
+    /** @protected Exposed to the template for the panel's `[activeIndex]`. */
+    protected readonly activeIndex: import("@angular/core").Signal<number>;
+    /** The HTML `id` assigned to the inner listbox element for `aria-controls` linking. */
+    readonly listboxId: import("@angular/core").Signal<string>;
+    readonly dropdownPositions: ConnectedPosition[];
+    readonly dropdownIcon: import("@angular/core").Signal<typeof LucideChevronUp | typeof LucideChevronDown>;
+    readonly filteredOptions: import("@angular/core").Signal<MlvSelectOption<T>[]>;
+    /**
+     * @protected The live query to highlight inside each suggestion (matched
+     * substring emphasis). Empty unless the user is actively searching, so a
+     * committed single-select label is never highlighted.
+     */
+    protected readonly _highlightQuery: import("@angular/core").Signal<string>;
+    /** @protected The options currently selected, resolved to `MlvSelectOption` for chip / template rendering. */
+    protected readonly selectedOptions: import("@angular/core").Signal<MlvSelectOption<T>[]>;
+    /** @protected The single-select committed label, or `''` when nothing is selected. */
+    protected readonly _committedLabel: import("@angular/core").Signal<string>;
+    /** @protected Whether every committed value has a matching option (by `compareWith`). */
+    protected readonly _allValuesMatched: import("@angular/core").Signal<boolean>;
+    /** @protected First payload arrived and no consumer-driven `loading`. */
+    protected readonly _ready: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Loading variant: a value is committed but no option resolves its
+     * label yet. The field is inert (readonly, no open) and shows a spinner in
+     * place of the chevron until the first load resolves.
+     */
+    protected readonly _awaitingValueLabel: import("@angular/core").Signal<boolean>;
+    /** @protected Panel spinner row: source-owned loading OR the consumer's `[loading]`. */
+    protected readonly _panelLoading: import("@angular/core").Signal<boolean>;
+    /** @protected Chips to render: while awaiting, only options that resolved. */
+    protected readonly _chipOptions: import("@angular/core").Signal<MlvSelectOption<T>[]>;
+    /** @protected `Press Enter to add "{query}"` resolved through i18n. */
+    protected readonly _pressEnterToAdd: import("@angular/core").Signal<string>;
+    /**
+     * @protected Whether the custom single-select display template should render
+     * over the input: single-select, a `selectedTemplate` is provided, a value is
+     * committed, and the field is not currently focused/searching (so the raw
+     * input text is shown for editing while focused).
+     */
+    protected readonly _showSingleTemplate: import("@angular/core").Signal<boolean>;
+    /** @protected `aria-activedescendant` target: the DOM id of the active option row, or `null`. */
+    protected readonly _activeOptionId: import("@angular/core").Signal<string | null>;
+    /**
+     * @protected Polite screen-reader announcement of the current result count.
+     * Empty while the popup is closed so no stale count is read out. Mirrors the
+     * visible empty-state copy rendered inside the dropdown panel.
+     */
+    protected readonly _resultsAnnouncement: import("@angular/core").Signal<string>;
+    readonly selectionService: MlvSelectionService<T>;
+    itemTemplate: import("@angular/core").Signal<MlvComboboxItemDef | undefined>;
+    selectedTemplate: import("@angular/core").Signal<MlvComboboxSelectedItemDef | undefined>;
+    /** @private The inner `mlv-input` — the tab stop and focus target for the whole control. */
+    private readonly _input;
+    /** @private The trigger row element (chips + input + chevron), used as the popup's click-outside exclusion. */
+    private readonly _triggerRef;
+    /** @private The dropdown popup — read to know whether it is rendering as a full-screen sheet. */
+    private readonly _popupRef;
+    /**
+     * @protected Whether the dropdown is currently a full-screen mobile sheet
+     * (mirrors `mlv-popup`'s own `isFullscreen()`). Drives the in-sheet search
+     * input's ARIA/focus handoff and suppresses the outer trigger input's
+     * combobox semantics so exactly one `role="combobox"` is exposed at a time.
+     */
+    protected readonly _isFullscreen: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Whether the outer trigger input owns the combobox semantics.
+     * `false` only while the full-screen sheet is actually open — then the
+     * in-sheet input is the live combobox and the outer input relinquishes the
+     * role/ARIA so exactly one `role="combobox"` is exposed. While anchored (or
+     * full-screen but closed, when the outer input is the visible trigger) the
+     * outer input keeps the combobox semantics.
+     */
+    protected readonly _outerIsCombobox: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected DOM `id` of the in-sheet search input. Distinct from the outer
+     * input's `id()` so both can coexist while full-screen and the in-sheet field
+     * can be focus-targeted by id after the sheet opens.
+     */
+    protected readonly _sheetInputId: import("@angular/core").Signal<string>;
+    /**
+     * @protected Elements the backdrop-less dropdown popup treats as "inside" for
+     * click-outside dismissal. The trigger row lives outside the floating panel,
+     * so without this a click on the input (e.g. to reposition the caret) would
+     * dismiss the open list. Passed to `mlv-popup`'s `dismissExcludeElements`.
+     */
+    protected readonly _popupExcludeElements: import("@angular/core").Signal<HTMLElement[]>;
+    /** @private Raw values last written through a forms binding, pre-normalisation. */
+    private _pendingValues;
+    constructor();
+    /**
+     * @protected Whether the last selected chip is "armed" — a visual-only
+     * selection driven by Backspace in the empty search input while DOM focus
+     * stays in the input (ported from mlv-tokenizer). The first Backspace arms;
+     * the next Backspace (or Delete) removes the armed chip and arms the new
+     * last one. Multi-select only.
+     */
+    protected readonly _armed: import("@angular/core").WritableSignal<boolean>;
+    /** @protected Polite screen-reader announcement for the armed chip. */
+    protected readonly _armedMessage: import("@angular/core").WritableSignal<string>;
+    /**
+     * @protected Whether the given selected option is the currently armed chip.
+     * Armed always targets the LAST selected chip.
+     */
+    protected _isChipArmed(option: MlvSelectOption<T>): boolean;
+    /**
+     * Handles Backspace in the search input (outer or in-sheet). When the input
+     * holds text this is a native edit and is left alone. With an empty input in
+     * multi-select: the first press arms the last chip (no deletion); each
+     * subsequent press removes the armed chip and arms the new last one.
+     */
+    onInputBackspace(event: Event): void;
+    /**
+     * Handles Delete in the search input — parity with the second Backspace:
+     * removes the armed chip and arms the new last one; no-op when nothing is
+     * armed.
+     */
+    onInputDelete(event: Event): void;
+    /**
+     * @private Removes the armed (last) chip through the regular deselection
+     * path and re-arms the new last chip, or disarms when none remain.
+     */
+    private _deleteArmedAndRearm;
+    /**
+     * @private Marks a removeSelected call as originating from the arm-driven
+     * deletion flow, so it preserves (re-arms) instead of disarming.
+     */
+    private _internalChipRemoval;
+    /** @private Clears the armed chip selection and its live announcement. */
+    private _disarmChips;
+    onSearchInput(event: Event): void;
+    /**
+     * Opens the dropdown when the input gains focus (unless disabled/readonly).
+     * Full-screen sheet mode is the exception: focus alone must NOT open — Tab
+     * focus would trap the user straight into the sheet, and the programmatic
+     * focus-restore in `_onPopupClosed` would instantly reopen it in a loop.
+     * There the sheet opens via pointer ({@link onTriggerClick}), the chevron,
+     * or explicit keyboard navigation (ArrowUp/Down).
+     */
+    onInputFocus(): void;
+    /**
+     * Opens the dropdown on a pointer click on the trigger input. This is the
+     * open gesture for the full-screen sheet (where focus alone never opens it);
+     * while anchored it is a no-op in practice because the preceding focus event
+     * already opened the panel.
+     */
+    onTriggerClick(): void;
+    /** Closes the dropdown, reverts stale text, and marks touched when focus genuinely leaves the field. */
+    onInputBlur(): void;
+    /**
+     * @protected Called after the dropdown popup finishes opening. In full-screen
+     * mode, hands focus to the in-sheet search input (the outer trigger input is
+     * occluded by the backdrop and outside the sheet's focus trap). No-op while
+     * trigger-anchored, so the desktop path is unchanged.
+     */
+    protected _onPopupOpened(): void;
+    /**
+     * @protected Called after the dropdown popup finishes closing. In full-screen
+     * mode, reverts any stale search text to the committed selection and restores
+     * focus to the outer trigger input (matching the desktop close behaviour that
+     * `onInputBlur`/`onEscape` provide when anchored). No-op while anchored.
+     */
+    protected _onPopupClosed(): void;
+    setFocused(isFocused?: boolean): void;
+    onArrowDown(event: Event): void;
+    onArrowUp(event: Event): void;
+    onHome(event: Event): void;
+    onEnd(event: Event): void;
+    onEnterKey(event?: Event): void;
+    /** First press (open) closes + reverts; second press (already closed) clears. */
+    onEscape(event: Event): void;
+    /** Chevron toggle. Uses `mousedown` + `preventDefault` so the input keeps focus. */
+    onChevronMousedown(event: MouseEvent): void;
+    /**
+     * Panel (pointer) selection path: aria emits the full selected-values array.
+     *
+     * The aria `ngListbox` re-emits its `value` model whenever the *rendered*
+     * option set changes — not only on user interaction. Typing filters the
+     * selected option out of view, so aria reconciles `value` down to the
+     * currently-rendered options and re-emits (see the `afterRenderEffect` in
+     * `@angular/aria`'s `Listbox`). That reconciliation is NOT a user action and
+     * must never mutate the committed selection or run commit side-effects
+     * (close / emit) — otherwise a single-select loses its value on any
+     * re-search and multi/allowCreate drop previously-picked items while typing
+     * to add another. We detect and ignore those emissions here.
+     */
+    selectValues(values: readonly T[]): void;
+    /**
+     * @private Whether an incoming panel `valueChange` is pure aria reconciliation
+     * noise rather than a user selection. True when the emit (a) adds no value not
+     * already committed and (b) only removes values whose option is currently
+     * filtered out of the rendered list. An emit that adds a value, removes a
+     * still-visible value (a genuine deselection), or exactly re-states the
+     * committed selection (nets to no change) is handled accordingly — the last
+     * case is treated as reconciliation so a spurious re-emit never re-runs the
+     * commit side-effects (e.g. closing a single-select popup mid-search).
+     */
+    private _isReconciliationEmit;
+    /**
+     * @private Committed values that aria dropped from its model only because
+     * their option is filtered out of the rendered list (and are not in the
+     * incoming array). Re-added to a genuine multi-select selection so earlier
+     * picks survive typing to add another value.
+     */
+    private _filteredOutCommitted;
+    /** Removes a single selected value (multi-select chip close / keyboard remove). */
+    removeSelected(value: T): void;
+    /**
+     * @private Focuses whichever search input is currently interactive: the
+     * in-sheet input while full-screen, otherwise the outer trigger input.
+     */
+    private _focusActiveInput;
+    /** Clears the whole selection and search text, emits, and refocuses the input. */
+    onClear(): void;
+    /** Moves focus back to the input (e.g. after single-select commit / close). */
+    setInitialFocus(): void;
+    updateTriggerWidth(evt: ResizeObserverEntry[]): void;
+    /**
+     * The combobox renders its own clear button inline in the trigger row,
+     * before the chevron — the wrapper must not render its trailing copy.
+     */
+    readonly ownsClearButton: import("@angular/core").Signal<boolean>;
+    /** Whether the control holds a clearable value — At least one committed option selected (search text alone is not a value). */
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    /** @private Normalises the pending form values against the current options and syncs display text. */
+    private _applyPendingValues;
+    /** @private Whether all open / interaction paths must be suppressed. */
+    private _isInert;
+    /** @private Opens the popup for keyboard navigation, resetting the active index on first open. */
+    private _openForNavigation;
+    /** @private ADD-only selection: single-select replaces, multi-select appends without duplicating. */
+    private _addOrReplace;
+    /** @private Commits an option value (Enter / active / exact-match path) and settles the UI. */
+    private _commitValue;
+    /** @private Settles UI after a committed selection: single closes + refocuses, multi stays open for more. */
+    private _afterCommit;
+    /** @private Reverts stale search text to the committed state and closes the popup. */
+    private _revertAndClose;
+    /**
+     * @private Re-searches `''` once whenever the visible query is dropped
+     * (close / revert, a commit in either selection mode, or a clear), so a blank
+     * input never sits above a list still filtered by the previous query. No-op
+     * in local mode and when the last remote query was already blank.
+     */
+    private _resetRemoteSearch;
+    /** @private Sets the input text to reflect the committed selection (single) or clears it (multi). */
+    private _syncDisplayText;
+    /**
+     * @private Commits the current selection to the forms model. {@link fromAriaValues}
+     * collapses the aria-side selection array back to the public value shape: `T[]`
+     * for multi-select, or the first value / `null` when empty for single-select.
+     */
+    private _emitValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvCombobox<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvCombobox<any>, "mlv-combobox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "searchFn": { "alias": "searchFn"; "required": false; "isSignal": true; }; "searchDebounce": { "alias": "searchDebounce"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "allowCreate": { "alias": "allowCreate"; "required": false; "isSignal": true; }; "toOption": { "alias": "toOption"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "matcher": { "alias": "matcher"; "required": false; "isSignal": true; }; "mobileMode": { "alias": "mobileMode"; "required": false; "isSignal": true; }; "mlvDensity": { "alias": "mlvDensity"; "required": false; "isSignal": true; }; "mobileTitle": { "alias": "mobileTitle"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueCreated": "valueCreated"; }, ["itemTemplate", "selectedTemplate"], never, true, never>;
+}

package/combobox/lib/combobox-template.directives.d.ts

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

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

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

package/copy-to-clipboard/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/copy-to-clipboard/copy-to-clipboard';

package/copy-to-clipboard/lib/copy-to-clipboard/copy-to-clipboard.d.ts

@@ -0,0 +1,130 @@
+import { type Signal } from '@angular/core';
+import { type BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+/**
+ * Inline copy-to-clipboard component.
+ *
+ * The component wraps arbitrary projected content (typically a short inline
+ * string). It reads as regular prose until the user hovers, at which point a
+ * subtle background tint appears and a small copy icon fades in at the trailing
+ * edge. Activating the element — click, Enter, or Space — writes the value to
+ * the clipboard, morphs the icon from Copy to Check via a soft blur crossfade,
+ * and emits the `copied` output.
+ *
+ * The copied text is derived from:
+ * 1. An explicit `value` input if provided, otherwise
+ * 2. The projected content's `textContent`.
+ *
+ * @example Basic inline usage
+ * ```html
+ * <p>
+ *   Your API key is <mlv-copy-to-clipboard>sk_live_abc123xyz</mlv-copy-to-clipboard>.
+ * </p>
+ * ```
+ *
+ * @example Override with [value]
+ * ```html
+ * Order #<mlv-copy-to-clipboard [value]="'ORDER-0042-7F9X2'">0042</mlv-copy-to-clipboard>
+ * ```
+ *
+ * @example Custom copied duration
+ * ```html
+ * <mlv-copy-to-clipboard [copiedDuration]="4000">token-value</mlv-copy-to-clipboard>
+ * ```
+ *
+ * @example Toast integration
+ * ```html
+ * <mlv-copy-to-clipboard (copied)="onCopied($event)">value</mlv-copy-to-clipboard>
+ * ```
+ */
+export declare class MlvCopyToClipboard {
+    /**
+     * Optional explicit value that will be written to the clipboard when the
+     * component is activated. When omitted, the component uses the `textContent`
+     * of the projected default slot content.
+     */
+    readonly value: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Duration in milliseconds for which the "copied" success state remains
+     * active after a successful clipboard write. After this window elapses, the
+     * component reverts to its idle state.
+     *
+     * @default 2000
+     */
+    readonly copiedDuration: import("@angular/core").InputSignal<number>;
+    /**
+     * Custom aria-label override. Falls back to the i18n-provided label.
+     * When a resolved value is available (either `value()` or projected text
+     * content), it is appended to this base for richer screen-reader context.
+     */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Text announced via the visually-hidden `aria-live="polite"` region
+     * immediately after a successful clipboard write.
+     *
+     * @default 'Copied to clipboard'
+     */
+    readonly copiedAriaLabel: import("@angular/core").InputSignal<string>;
+    /**
+     * When true, disables the copy action, removes the host from the tab order,
+     * and reflects `aria-disabled="true"`. Accepts attribute-style usage:
+     * `<mlv-copy-to-clipboard disabled>`.
+     */
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Emits the exact string that was successfully written to the clipboard.
+     * Fires after the `navigator.clipboard.writeText` promise resolves.
+     */
+    readonly copied: import("@angular/core").OutputEmitterRef<string>;
+    /**
+     * Reactive signal exposing whether the component is currently in the copied
+     * success state. Useful for template-driven UI that needs to react to the
+     * transient state (e.g. conditional labels).
+     */
+    readonly isCopied: Signal<boolean>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: Signal<import("@malva-ui/i18n").MlvCopyToClipboardI18n>;
+    /**
+     * @protected Computed accessible label. Combines the base `ariaLabel` (or
+     * i18n fallback) with the current resolved value when one is available, so
+     * screen readers get a descriptive name like `"Copy to clipboard: sk_live_abc123"`.
+     */
+    protected readonly _computedAriaLabel: Signal<string>;
+    /** @private Backing signal for `isCopied`. */
+    private readonly _isCopied;
+    /**
+     * @private Host element reference, used to read `textContent` when no
+     * explicit `value` input is provided.
+     */
+    private readonly _elementRef;
+    /** @private DestroyRef for cleaning up any pending auto-reset timers. */
+    private readonly _destroyRef;
+    /** @private CDK Clipboard service — SSR-safe, no insecure-context branch. */
+    private readonly _clipboard;
+    /**
+     * @private Handle for the auto-reset `setTimeout`. Stored so rapid repeated
+     * copies can reset the timer cleanly.
+     */
+    private _revertTimer;
+    constructor();
+    /**
+     * Writes the resolved text to the system clipboard. Triggered on click,
+     * Enter, or Space via the host bindings. Activates the copied state and
+     * schedules its reset. Rejects silently on clipboard write failure — the
+     * `copied` output only fires on a successful write.
+     */
+    copy(): void;
+    /**
+     * @private Resolves the text to copy. Prefers the explicit `value` input;
+     * falls back to the trimmed `textContent` of the host element.
+     */
+    private _resolveValue;
+    /**
+     * @private Activates the copied state, emits the `copied` output, and
+     * schedules the reset timer. Clears any pending reset before scheduling a
+     * new one so rapid repeated copies restart the window cleanly.
+     */
+    private _activateCopiedState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvCopyToClipboard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvCopyToClipboard, "mlv-copy-to-clipboard", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "copiedDuration": { "alias": "copiedDuration"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "copiedAriaLabel": { "alias": "copiedAriaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "copied": "copied"; }, never, ["*"], true, never>;
+}

package/copy-to-clipboard/malva-ui-core-copy-to-clipboard.d.ts

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

package/data-table/index.d.ts

@@ -0,0 +1,8 @@
+export * from './lib/types';
+export * from './lib/data-source';
+export * from './lib/data-table-cell';
+export * from './lib/data-table-edit-cell';
+export * from './lib/data-table-no-data';
+export * from './lib/data-table-error';
+export * from './lib/data-table-footer';
+export * from './lib/data-table/data-table';

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

@@ -0,0 +1,5 @@
+/**
+ * Compat re-export — the data source primitives now live in
+ * `@malva-ui/cdk/data-source` so option controls can share them.
+ */
+export * from '@malva-ui/cdk/data-source';

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

@@ -0,0 +1,31 @@
+import type { MlvDataTableColumn } from '../types';
+/** Internal row shape used while flattening tree data. */
+export type MlvDataRow = object & {
+    _mlvChildren?: MlvDataRow[];
+    _mlvDepth?: number;
+    _mlvRef?: MlvDataRow;
+};
+/** Internal column state enriched with measured layout information. */
+export interface MlvColumnState extends MlvDataTableColumn {
+    _currentWidth?: number;
+    _left?: number;
+    _right?: number;
+    _visible?: boolean;
+}
+/** Returns the original row reference used for expansion identity. */
+export declare function originalRow(row: MlvDataRow): MlvDataRow;
+/** Recursively flattens expanded tree rows into render order. */
+export declare function flattenRows(rows: MlvDataRow[], expanded: Set<MlvDataRow>, depth?: number): MlvDataRow[];
+/** Resolves responsive column visibility at the supplied container width. */
+export declare function isColumnVisible(column: MlvDataTableColumn, containerWidth: number): boolean;
+/**
+ * Parses a complete, non-negative CSS pixel width.
+ *
+ * Other CSS units deliberately return `undefined`; treating `12rem` or `50%`
+ * as `12px`/`50px` would corrupt resize bounds and pinned-column offsets.
+ */
+export declare function parsePixelWidth(width: string | undefined): number | undefined;
+/** Builds stable width styles for a table column. */
+export declare function columnWidthStyles(column: MlvColumnState): Record<string, string>;
+/** Adds sticky pin offsets to the base column width styles. */
+export declare function columnCellStyles(column: MlvColumnState, offsets: Map<string, string>): Record<string, string>;