@malva-ui/core 0.1.12

package/popup/lib/popup-trigger/popup-trigger.d.ts

@@ -0,0 +1,102 @@
+import type { OnDestroy } from '@angular/core';
+import type { MlvPopup } from '../popup/popup';
+import * as i0 from "@angular/core";
+export type MlvPopupTriggerType = 'click' | 'hover' | 'focus';
+export declare class MlvPopupTrigger implements OnDestroy {
+    /** @private Low-level overlay API used in standalone mode. */
+    private readonly _popupService;
+    /** @private Host element ref used as the overlay anchor. */
+    private readonly _elementRef;
+    /** @private View container used to instantiate the popup template portal. */
+    private readonly _vcr;
+    /** @private Zone used to re-enter Angular after out-of-zone hover timers. */
+    private readonly _ngZone;
+    /**
+     * Optional injection of a parent {@link MlvPopupContainer}.
+     *
+     * When present the trigger operates in **container mode**: it delegates
+     * open/close/toggle to the container instead of creating its own overlay,
+     * and registers its host element as the visual anchor.
+     *
+     * When absent the trigger operates in **standalone mode** and manages the
+     * overlay lifecycle itself (legacy behaviour).
+     */
+    private readonly _container;
+    /** @private The active overlay handle in standalone mode, or `null` when closed. */
+    private _handle;
+    /** @private Guards against re-triggering the leave animation while already closing. */
+    private _closing;
+    /** @private Subscription to the popup's leave-animation-done stream. */
+    private _leaveSubscription;
+    /** @private Pending hover-close timer handle, or `null` when none is scheduled. */
+    private _hoverCloseTimer;
+    /**
+     * @private Last-resort timer that force-detaches an overlay whose leave never
+     * completed — without it a lost `animationState` write latches `_closing`
+     * with no path back to a detach.
+     */
+    private _detachWatchdog;
+    /** @private Teardown callbacks for the overlay hover mouse listeners. */
+    private _overlayMouseListeners;
+    /**
+     * The `MlvPopup` to control.
+     *
+     * **Standalone mode** (no parent `mlv-popup-container`): must be bound to the
+     * target `<mlv-popup>` element: `[mlvPopupTrigger]="myPopup"`.
+     *
+     * **Container mode** (inside `mlv-popup-container`): can be used as a bare
+     * attribute (`mlvPopupTrigger`) without a value — the container already holds
+     * the popup reference and orchestrates the overlay. The empty-string value from
+     * the bare attribute is coerced to `undefined` by the transform.
+     */
+    readonly mlvPopupTrigger: import("@angular/core").InputSignalWithTransform<MlvPopup | undefined, string | MlvPopup | undefined>;
+    /** One or more event types that open the popup. Defaults to `'click'`. */
+    readonly triggerOn: import("@angular/core").InputSignal<MlvPopupTriggerType | MlvPopupTriggerType[]>;
+    /**
+     * Value applied to the trigger's `aria-haspopup` attribute. Should match the
+     * semantic role of the popup panel's content — e.g. `'menu'` for a menu
+     * flyout, `'listbox'` for a select, `'dialog'` for a modal surface. Defaults
+     * to `'dialog'` for backwards compatibility. Set to `null` to omit the
+     * attribute entirely (e.g. for a tooltip-only popup).
+     */
+    readonly ariaHasPopup: import("@angular/core").InputSignal<string | null>;
+    /** @protected Whether the associated popup is currently open. */
+    protected readonly _isOpen: import("@angular/core").Signal<boolean>;
+    constructor();
+    open(): void;
+    close(): void;
+    toggle(): void;
+    ngOnDestroy(): void;
+    onClick(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocus(): void;
+    onBlur(): void;
+    hasTrigger(type: MlvPopupTriggerType): boolean;
+    /** @private Schedules a delayed close after the pointer leaves the trigger. */
+    private _scheduleHoverClose;
+    /** @private Cancels any pending hover-close timer. */
+    private _clearHoverTimer;
+    /** @private Creates the CDK overlay and plays the enter animation (standalone mode). */
+    private _attachOverlay;
+    /** @private Wires hover enter/leave listeners on the overlay panel to keep it open on hover. */
+    private _addOverlayMouseListeners;
+    /** @private Removes the overlay hover listeners. */
+    private _removeOverlayMouseListeners;
+    /** @private Triggers the popup leave animation before detaching the overlay. */
+    private _startLeaveAnimation;
+    /** @private Tears down the overlay, its subscriptions, and pending timers. */
+    private _detachOverlay;
+    /**
+     * @private Arms the force-detach timer for the pending leave. Detaching is
+     * what resets `_closing` and `_handle`, so a leave that never completes must
+     * still end in a detach or the trigger latches permanently.
+     */
+    private _armDetachWatchdog;
+    /** @private Cancels a pending force-detach timer. */
+    private _clearDetachWatchdog;
+    /** @private Unsubscribes from the leave-animation-done stream. */
+    private _cleanupSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvPopupTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvPopupTrigger, "[mlvPopupTrigger]", ["mlvPopupTrigger"], { "mlvPopupTrigger": { "alias": "mlvPopupTrigger"; "required": false; "isSignal": true; }; "triggerOn": { "alias": "triggerOn"; "required": false; "isSignal": true; }; "ariaHasPopup": { "alias": "ariaHasPopup"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/popup/lib/popup.service.d.ts

@@ -0,0 +1,159 @@
+import type { ElementRef, TemplateRef, ViewContainerRef } from '@angular/core';
+import type { OverlayRef, ConnectedPosition, ConnectedOverlayPositionChange } from '@angular/cdk/overlay';
+import type { MlvPopupPositionName } from './popup-positions';
+import * as i0 from "@angular/core";
+/**
+ * Controls what happens to the popup when the user scrolls.
+ *
+ * - `'reposition'` (default) — the overlay repositions with the trigger as the page scrolls.
+ * - `'close'` — the overlay closes as soon as the user scrolls.
+ * - `'block'` — scroll is blocked while the overlay is open.
+ * - `'noop'` — the overlay stays fixed at its original position; no repositioning or closing.
+ */
+export type MlvPopupScrollStrategy = 'reposition' | 'close' | 'block' | 'noop';
+/** Size constraints passed to the CDK overlay on creation. */
+export interface MlvPopupSizeConfig {
+    /** Explicit panel width (CSS value or pixel number). */
+    width?: number | string;
+    /** Explicit panel height (CSS value or pixel number). */
+    height?: number | string;
+    /** Minimum panel width. */
+    minWidth?: number | string;
+    /** Minimum panel height. */
+    minHeight?: number | string;
+    /** Maximum panel width. */
+    maxWidth?: number | string;
+    /** Maximum panel height. */
+    maxHeight?: number | string;
+}
+/** Configuration object passed to {@link MlvPopupService.open}. */
+export interface MlvPopupOpenConfig {
+    /** The element the overlay attaches to. */
+    origin: ElementRef;
+    /** The `<ng-template>` to render inside the overlay. */
+    template: TemplateRef<unknown>;
+    /** The `ViewContainerRef` used to instantiate the portal. */
+    vcr: ViewContainerRef;
+    /**
+     * Ordered list of CDK `ConnectedPosition` objects the overlay will try in
+     * sequence until one fits within the viewport.
+     *
+     * Use {@link MlvPopupService.resolvePositions} to build this list from named
+     * positions when working programmatically.
+     */
+    positions: ConnectedPosition[];
+    /** Optional size constraints applied to the overlay panel. */
+    size?: MlvPopupSizeConfig;
+    /**
+     * When `true`, the overlay is rendered as a full-screen mobile sheet:
+     * a global (viewport-filling) position strategy replaces the connected
+     * strategy, a solid backdrop is always shown, page scroll is locked
+     * (block scroll strategy), and the connected {@link positions}/{@link size}
+     * are ignored. Defaults to `false` (trigger-anchored behaviour).
+     */
+    fullscreen?: boolean;
+    /**
+     * When `true` (default), a transparent CDK backdrop is created; clicking it
+     * triggers `onRequestClose`.
+     *
+     * When `false`, no visual backdrop is rendered, but click-outside detection
+     * is preserved via a document-level click listener (attached after a
+     * `setTimeout(0)` to avoid catching the opening click). Escape key closure
+     * is always active regardless of this flag.
+     */
+    hasBackdrop?: boolean;
+    /** Optional CDK backdrop class. Defaults to `cdk-overlay-transparent-backdrop`. */
+    backdropClass?: string;
+    /**
+     * Controls overlay behaviour when the page is scrolled.
+     * Defaults to `'reposition'`.
+     */
+    scrollStrategy?: MlvPopupScrollStrategy;
+    /** Allow the overlay to grow in the axis constrained by the viewport. */
+    flexibleDimensions?: boolean;
+    /**
+     * Extra elements treated as "inside" the popup for click-outside detection
+     * (backdrop-less mode only). A click within any of these — in addition to the
+     * overlay panel itself — does not trigger `onRequestClose`. Typically the
+     * trigger/anchor element, which lives outside the floating overlay panel.
+     */
+    dismissExcludeElements?: readonly HTMLElement[];
+    /** Called after the overlay is fully disposed. */
+    onClose: () => void;
+    /**
+     * Called when the user requests closure (backdrop click, Escape key).
+     * Defaults to `onClose` when not provided.
+     */
+    onRequestClose?: () => void;
+    /** Called each time CDK selects a different `ConnectedPosition`. */
+    onPositionChange?: (change: ConnectedOverlayPositionChange) => void;
+}
+/** Return value of {@link MlvPopupService.open}. */
+export interface MlvPopupHandle {
+    /** The underlying CDK overlay reference. */
+    overlayRef: OverlayRef;
+    /** Disposes the overlay and triggers `onClose`. */
+    close: () => void;
+}
+/**
+ * Low-level CDK overlay service for Malva UI popup components.
+ *
+ * Handles overlay creation, portal attachment, position strategy,
+ * backdrop clicks, and Escape-key closure.
+ *
+ * For template-driven usage prefer `[mlvPopupTrigger]` or
+ * `<mlv-popup-container>`. Use this service directly only when you need
+ * full programmatic control.
+ *
+ * @example Programmatic usage
+ * ```ts
+ * const handle = this.popupService.open({
+ *   origin: this.triggerRef,
+ *   template: this.tpl,
+ *   vcr: this.vcr,
+ *   positions: this.popupService.resolvePositions(['bottom', 'top']),
+ *   onClose: () => this.isOpen.set(false),
+ * });
+ * // Later:
+ * handle.close();
+ * ```
+ */
+export declare class MlvPopupService {
+    /** @private CDK overlay service. */
+    private readonly _overlay;
+    /** @private Active named-position map (overridable via `POPUP_POSITIONS` token). */
+    private readonly _positionMap;
+    /** @private Angular zone for running document-level event handlers inside change detection. */
+    private readonly _ngZone;
+    /**
+     * Resolves one or more {@link MlvPopupPositionName} strings to CDK
+     * `ConnectedPosition` objects.
+     *
+     * Positions are resolved from the active `POPUP_POSITIONS` map. If a name
+     * is not found, it is skipped and a `console.warn` is emitted in dev mode.
+     * CDK uses the first position in the returned array that fits in the viewport.
+     *
+     * @param names — A single name or ordered array of fallback names.
+     *
+     * @example
+     * ```ts
+     * positions: this.popupService.resolvePositions('bottom-end')
+     * positions: this.popupService.resolvePositions(['bottom-end', 'top-end'])
+     * ```
+     */
+    resolvePositions(names: MlvPopupPositionName | MlvPopupPositionName[]): ConnectedPosition[];
+    /**
+     * Creates a CDK overlay, attaches the given template portal, and wires up
+     * backdrop and Escape-key closure.
+     *
+     * @param config — Full overlay configuration.
+     * @returns A {@link MlvPopupHandle} with the `overlayRef` and a `close()` method.
+     */
+    open(config: MlvPopupOpenConfig): MlvPopupHandle;
+    /**
+     * @private Maps a {@link MlvPopupScrollStrategy} name to a CDK scroll-strategy instance.
+     */
+    private _resolveScrollStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvPopupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MlvPopupService>;
+}

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

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

package/progress/index.d.ts

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

package/progress/lib/progress/progress.d.ts

@@ -0,0 +1,69 @@
+import { type BooleanInput } from '@angular/cdk/coercion';
+import type { MlvTone } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+/**
+ * Semantic tone for the progress component. Extends the shared {@link MlvTone}
+ * vocabulary (`'info' | 'success' | 'warning' | 'danger'`) with a neutral
+ * `'default'`.
+ */
+export type MlvProgressTone = MlvTone | 'default';
+/** Visual shape of the progress component. */
+export type MlvProgressShape = 'bar' | 'circle';
+/** Size variant of the progress component. */
+export type MlvProgressSize = 's' | 'm' | 'l';
+/** SVG dimensions used for the circle variant. */
+interface CircleDimensions {
+    /** SVG viewBox string. */
+    viewBox: string;
+    /** Circle center X/Y coordinate. */
+    center: number;
+    /** Circle radius. */
+    radius: number;
+    /** Full stroke circumference. */
+    circumference: number;
+    /** Stroke width in viewBox units. */
+    strokeWidth: number;
+}
+export declare class MlvProgress {
+    /** Visual shape variant — `'bar'` for a horizontal track, `'circle'` for an SVG ring. */
+    readonly shape: import("@angular/core").InputSignal<MlvProgressShape>;
+    /**
+     * Current progress value between 0 and 100.
+     * Clamped to the `[0, 100]` range internally.
+     */
+    readonly value: import("@angular/core").InputSignal<number>;
+    /** Size variant controlling track height (bar) or diameter (circle). */
+    readonly size: import("@angular/core").InputSignal<MlvProgressSize>;
+    /** Semantic tone applied to the fill element. */
+    readonly tone: import("@angular/core").InputSignal<MlvProgressTone>;
+    /**
+     * When `true`, displays the current value as a percentage text.
+     * Bar: appears above the track (right-aligned).
+     * Circle: appears centred inside the ring.
+     */
+    readonly showPercentage: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** Custom aria-label override. Falls back to the i18n-provided label. */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvProgressI18n>;
+    /** @protected Resolved aria-label: explicit input takes precedence over i18n default. */
+    protected readonly _resolvedAriaLabel: import("@angular/core").Signal<string>;
+    /** @protected Progress clamped to [0, 100]. */
+    protected readonly _clampedValue: import("@angular/core").Signal<number>;
+    /** @protected Formatted percentage text. */
+    protected readonly _percentageText: import("@angular/core").Signal<string>;
+    /**
+     * @protected Delays enabling the CSS fill transition by one tick so the browser
+     * has a defined starting state before the transition begins.
+     */
+    protected readonly _progressVisible: import("@angular/core").Signal<boolean | undefined>;
+    /** @protected Computed circle SVG dimensions based on the size input. */
+    protected readonly _circleDimensions: import("@angular/core").Signal<CircleDimensions>;
+    /** @protected The stroke-dashoffset for the circle fill, derived from clamped value. */
+    protected readonly _strokeDashoffset: import("@angular/core").Signal<number>;
+    /** @protected Host CSS class string. */
+    protected readonly _hostClasses: import("@angular/core").Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvProgress, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvProgress, "mlv-progress", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "showPercentage": { "alias": "showPercentage"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*", "*"], true, never>;
+}
+export {};

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

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

package/radio/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/radio/radio';
+export * from './lib/radio-group/radio-group';

package/radio/lib/radio/radio.d.ts

@@ -0,0 +1,87 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class MlvRadio {
+    /** @private Optional parent radio group accessor injected via `RADIO_GROUP`. */
+    private readonly _group;
+    /** @private Host element reference, used to strip the moved ARIA attributes. */
+    private readonly _elementRef;
+    /** @private Renderer used to imperatively remove host ARIA attributes. */
+    private readonly _renderer;
+    /**
+     * @private The `aria-label` a consumer placed directly on the `<mlv-radio>`
+     * host, captured before host bindings run. The host is role-less, so ARIA
+     * prohibits an `aria-label` there (axe `aria-prohibited-attr`); it is moved to
+     * the inner `<input type="radio">` instead (see the constructor).
+     */
+    private readonly _hostAriaLabel;
+    /**
+     * @private The `aria-labelledby` a consumer placed directly on the
+     * `<mlv-radio>` host, captured before host bindings run. Moved to the inner
+     * input for the same reason as {@link _hostAriaLabel}.
+     */
+    private readonly _hostAriaLabelledBy;
+    /**
+     * Accessible name applied to the inner native input (`aria-label`). Use this
+     * input (not a host `[attr.aria-label]` binding) when the label is dynamic —
+     * the role-less host must not carry ARIA naming attributes
+     * (axe `aria-prohibited-attr`). A static host `aria-label` attribute is also
+     * supported and forwarded automatically (see the constructor); this input
+     * takes precedence when both are present.
+     */
+    readonly ariaLabel: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Id reference(s) naming the inner native input (`aria-labelledby`). Same
+     * rationale and precedence as {@link ariaLabel}.
+     */
+    readonly ariaLabelledBy: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * @internal The accessible name forwarded onto the native input, sourced from a
+     * host `aria-label`. `null` when the consumer supplied none, so no empty
+     * `aria-label` is emitted on the input (and any group-provided naming is left
+     * untouched).
+     */
+    readonly _ariaLabel: import("@angular/core").WritableSignal<string | null>;
+    /**
+     * @internal The `aria-labelledby` forwarded onto the native input, sourced from
+     * a host `aria-labelledby`. `null` when the consumer supplied none.
+     */
+    readonly _ariaLabelledBy: import("@angular/core").WritableSignal<string | null>;
+    /**
+     * @internal The final `aria-label` for the native input: the `ariaLabel` input
+     * wins over a captured static host attribute; `null` emits no attribute.
+     */
+    readonly _resolvedAriaLabel: import("@angular/core").Signal<string | null>;
+    /**
+     * @internal The final `aria-labelledby` for the native input, with the same
+     * precedence as {@link _resolvedAriaLabel}.
+     */
+    readonly _resolvedAriaLabelledBy: import("@angular/core").Signal<string | null>;
+    constructor();
+    readonly value: import("@angular/core").InputSignal<unknown>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    readonly checked: import("@angular/core").WritableSignal<boolean>;
+    readonly name: import("@angular/core").WritableSignal<string>;
+    /**
+     * Roving tabindex applied to the native `<input type="radio">` — the single
+     * focus target. `0` for the tabbable radio, `-1` for the rest. Managed by
+     * `MlvRadioGroup`.
+     */
+    readonly tabIndex: import("@angular/core").WritableSignal<number>;
+    /**
+     * @private Reference to the visually-hidden native radio input, which is the
+     * focus target (kept in the a11y tree via the clip-path pattern so native
+     * radio semantics — Space selection, grouping — are preserved).
+     */
+    private readonly _nativeInput;
+    /**
+     * Moves focus to the native radio input. Satisfies CDK `FocusableOption` so
+     * the group's `FocusKeyManager` focuses the input rather than the host.
+     */
+    focus(): void;
+    /** @internal Notifies the parent group when the native input gains focus. */
+    onFocus(): void;
+    /** @internal Handles native selection (click, Space, native arrow keys). */
+    onSelect(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvRadio, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvRadio, "mlv-radio", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/radio/lib/radio-group/radio-group.d.ts

@@ -0,0 +1,35 @@
+import { MlvRadio } from '../radio/radio';
+import type { MlvRadioGroupAccessor } from '../radio-group-token';
+import type { MlvFormState } from '@malva-ui/core/form-utils';
+import { MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import * as i0 from "@angular/core";
+/**
+ * Visual/validation state of the group. Structurally identical to
+ * {@link MlvFormState}; retained as a public alias for backwards compatibility.
+ */
+export type MlvRadioGroupState = MlvFormState;
+export declare class MlvRadioGroup extends MlvSignalFormControlBase<unknown> implements MlvRadioGroupAccessor {
+    /** Two-way bindable selected value of the group. */
+    readonly value: import("@angular/core").ModelSignal<unknown>;
+    /** Shared `name` applied to the native radio inputs in the group. */
+    readonly name: import("@angular/core").InputSignalWithTransform<string, string | undefined>;
+    readonly radios: import("@angular/core").Signal<readonly MlvRadio[]>;
+    /** @private FocusKeyManager driving roving focus + arrow-key navigation across the radios. */
+    private _keyManager;
+    constructor();
+    onChildFocus(radio: MlvRadio): void;
+    /**
+     * @protected Host keydown handler. Handles all four arrow keys for WAI-ARIA
+     * radiogroup semantics, moving focus + selection via the FocusKeyManager.
+     */
+    _onKeydown(event: KeyboardEvent): void;
+    selectRadio(radio: MlvRadio): void;
+    /** Whether the control holds a clearable value — A radio value is selected. */
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    /** @private Syncs each radio's checked state to the current group value and refreshes tab indices. */
+    private _updateSelection;
+    /** @private Applies the roving tabindex: only the checked radio (or first when none checked) is tabbable. */
+    private _updateTabIndices;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvRadioGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvRadioGroup, "mlv-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["radios"], ["*"], true, never>;
+}

package/radio/lib/radio-group-token.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import type { MlvRadio } from './radio/radio';
+export interface MlvRadioGroupAccessor {
+    selectRadio(radio: MlvRadio): void;
+    onChildFocus(radio: MlvRadio): void;
+}
+export declare const RADIO_GROUP: InjectionToken<MlvRadioGroupAccessor>;

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

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

package/rating/index.d.ts

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

package/rating/lib/rating/rating.d.ts

@@ -0,0 +1,100 @@
+import type { MlvFormControl } from '@malva-ui/core/form-utils';
+import { MlvSignalFormControlBase } from '@malva-ui/core/form-utils';
+import * as i0 from "@angular/core";
+/**
+ * Star rating component with half-star precision and read-only mode.
+ *
+ * Extends {@link MlvSignalFormControlBase}, inheriting the shared `disabled`,
+ * `readonly`, `state`, `id`, `label`, `hint` and `message` inputs plus the
+ * signal-forms field contract.
+ *
+ * - Hover preview highlights stars up to the cursor.
+ * - Half-star precision via clip-path technique when `step="0.5"`.
+ * - Keyboard: ArrowRight/ArrowLeft step up/down, Home for min, End for max.
+ * - Integrates with signal, reactive, and template-driven Angular forms.
+ *
+ * @example Basic
+ * ```html
+ * <mlv-rating [max]="5" [(ngModel)]="rating" />
+ * ```
+ *
+ * @example Half-star precision
+ * ```html
+ * <mlv-rating [step]="0.5" [formField]="ratingForm.score" />
+ * ```
+ *
+ * @example Read-only display
+ * ```html
+ * <mlv-rating [value]="4.5" [readonly]="true" />
+ * ```
+ */
+export declare class MlvRating extends MlvSignalFormControlBase<number> implements MlvFormControl {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvRatingI18n>;
+    /** @private Resolver for ICU parameterized i18n strings. */
+    private readonly _resolver;
+    /**
+     * Total number of stars.
+     * @default 5
+     */
+    readonly max: import("@angular/core").InputSignalWithTransform<number, string | number | null | undefined>;
+    /**
+     * Step increment — `1` for whole stars, `0.5` for half-star precision.
+     * @default 1
+     */
+    readonly step: import("@angular/core").InputSignalWithTransform<1 | 0.5, number | null | undefined>;
+    /**
+     * The committed rating — the signal-forms `FormValueControl` model. Kept in
+     * sync by `[formField]`, `[formControl]`, and `ngModel` bindings.
+     */
+    readonly value: import("@angular/core").ModelSignal<number>;
+    /** Tracks the hover preview value (0 = not hovering). */
+    protected readonly _hoverValue: import("@angular/core").WritableSignal<number>;
+    /** The value visually displayed — hover preview takes precedence. */
+    protected readonly _displayValue: import("@angular/core").Signal<number>;
+    /** Indices `[0 … max-1]` for `@for` iteration. */
+    protected readonly _indices: import("@angular/core").Signal<number[]>;
+    /**
+     * The 0-based index of the star that is in the tab order (roving tabindex).
+     * The star covering the current value is tabbable; when no value is set the
+     * first star is. All other stars are removed from the tab order so the rating
+     * is a single tab stop, with Arrow keys moving between values.
+     */
+    protected readonly _activeIndex: import("@angular/core").Signal<number>;
+    /** Whether the control holds a clearable value — A non-zero rating is set. */
+    readonly hasValue: import("@angular/core").Signal<boolean>;
+    /**
+     * Returns the percentage of star `starIndex` (1-indexed) that should be filled.
+     * 100 = full, 50 = half, 0 = empty.
+     */
+    protected _getFillPercent(starIndex: number): number;
+    /**
+     * Returns the CSS `clip-path` value for the filled star overlay.
+     * `inset(0 {remainder}% 0 0)` clips the right side.
+     */
+    protected _clipPath(starIndex: number): string;
+    /**
+     * @internal Resolves the per-star aria-label, e.g. "Rate 3 out of 5".
+     * @param starIndex 1-based star number.
+     */
+    protected _rateLabel(starIndex: number): string;
+    /**
+     * @internal Roving tabindex for star `index` (0-based): `0` for the active
+     * star, `-1` for the rest. Always `-1` when read-only or disabled.
+     */
+    protected _starTabIndex(index: number): number;
+    /** @internal */
+    protected _onStarMouseMove(starIndex: number, event: MouseEvent): void;
+    /** @internal */
+    protected _onStarClick(starIndex: number, event: MouseEvent): void;
+    /** @internal */
+    protected _onHostMouseLeave(): void;
+    /** @internal */
+    protected _onHostKeydown(event: KeyboardEvent): void;
+    /** @internal */
+    protected _onStarFocus(starIndex: number): void;
+    /** @internal */
+    protected _onStarBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvRating, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvRating, "mlv-rating", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}

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

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

package/schematics/collection.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "../../../node_modules/@angular-devkit/schematics/collection-schema.json",
+  "schematics": {
+    "ng-add": {
+      "description": "Install and configure Malva UI in an Angular application.",
+      "factory": "./ng-add/index.cjs",
+      "schema": "./ng-add/schema.json",
+      "aliases": ["install"],
+      "hidden": true
+    }
+  }
+}