@malva-ui/core 0.1.13 → 0.1.14

package/types/malva-ui-core-notification.d.ts

@@ -0,0 +1,122 @@
+import { MlvToastRef, MlvInternalBaseToast, MlvBaseToastConfig, MlvAbstractToastItem, MlvAbstractToastService, MlvIAbstractToastComponent, MlvToastContainer, MlvToastPoliteness, MlvToastPosition } from '@malva-ui/core/toast';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type, Injector, InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import { MlvTone } from '@malva-ui/cdk/utils';
+import * as _malva_ui_core_notification from '@malva-ui/core/notification';
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import { LucideCircleCheck, LucideCircleAlert, LucideTriangleAlert, LucideInfo } from '@lucide/angular';
+
+/**
+ * Handle returned by `MlvNotificationService.show()` and
+ * `MlvNotificationService.open()`.
+ *
+ * Component content can inject this class and template content receives it in
+ * its context.
+ *
+ * @typeParam D - Type of the data supplied for this notification.
+ */
+declare class MlvNotificationRef<D = unknown> extends MlvToastRef<D> {
+}
+
+type MlvNotificationTone = MlvTone | 'default';
+interface MlvNotificationAction {
+    label: string;
+    action: () => void;
+    variant?: 'primary' | 'secondary';
+}
+interface MlvNotificationConfig<D = unknown> extends MlvBaseToastConfig<D> {
+    title: string;
+    description?: string;
+    tone?: MlvNotificationTone;
+    actions?: MlvNotificationAction[];
+    /** Override the auto-selected icon. Pass null to hide the icon. */
+    showIcon?: boolean;
+}
+/** Options for `MlvNotificationService.open()` where content is supplied separately. */
+interface MlvNotificationOpenConfig<D = unknown> extends MlvBaseToastConfig<D> {
+    description?: string;
+    tone?: MlvNotificationTone;
+    actions?: MlvNotificationAction[];
+    showIcon?: boolean;
+}
+/** Context exposed when `MlvNotificationService.open()` receives a `TemplateRef`. */
+interface MlvNotificationTemplateContext<D = unknown> {
+    $implicit: MlvNotificationRef<D>;
+    ref: MlvNotificationRef<D>;
+    data: D;
+    config: Readonly<MlvNotificationOpenConfig<D>>;
+}
+/** Content accepted by `MlvNotificationService.open()`. Strings are rendered as escaped text. */
+type MlvNotificationContent<D = unknown> = string | TemplateRef<MlvNotificationTemplateContext<D>> | Type<unknown>;
+/** Data available to component content opened through `MlvNotificationService.open()`. */
+declare const NOTIFICATION_DATA: InjectionToken<unknown>;
+/** Configuration available to component content opened through `MlvNotificationService.open()`. */
+declare const NOTIFICATION_CONFIG: InjectionToken<Readonly<MlvNotificationOpenConfig<unknown>>>;
+interface MlvInternalNotification extends MlvInternalBaseToast {
+    title: string;
+    description: string;
+    tone: MlvNotificationTone;
+    actions: MlvNotificationAction[];
+    showIcon: boolean;
+    /** Dynamic template/component content; strings use the existing title rendering path. */
+    content?: Exclude<MlvNotificationContent, string>;
+    /** Context supplied to dynamic template content. */
+    contentContext?: MlvNotificationTemplateContext;
+    /** Per-item injector supplied to dynamic template/component content. */
+    contentInjector?: Injector;
+}
+
+declare class MlvNotificationItem extends MlvAbstractToastItem<MlvInternalNotification> implements OnInit, OnDestroy {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: _angular_core.Signal<_malva_ui_i18n.MlvNotificationI18n>;
+    /** @protected Lucide icon class selected from the notification tone. */
+    protected readonly toneIcon: _angular_core.Signal<typeof LucideCircleCheck | typeof LucideCircleAlert | typeof LucideTriangleAlert | typeof LucideInfo>;
+    /** @protected Template branch of dynamic content, when supplied. */
+    protected readonly _templateContent: _angular_core.Signal<TemplateRef<_malva_ui_core_notification.MlvNotificationTemplateContext<unknown>> | null>;
+    /** @protected Component branch of dynamic content, when supplied. */
+    protected readonly _componentContent: _angular_core.Signal<_angular_core.Type<unknown> | null>;
+    /** @protected Invokes an action's callback and then dismisses the notification. */
+    protected onActionClick(action: MlvNotificationAction): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvNotificationItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvNotificationItem, "mlv-notification-item", never, {}, {}, never, never, true, never>;
+}
+
+type NotificationConfigWithoutTitleAndTone = Omit<MlvNotificationConfig, 'title' | 'tone'>;
+declare class MlvNotificationService extends MlvAbstractToastService<MlvNotificationConfig, MlvInternalNotification, MlvIAbstractToastComponent<MlvInternalNotification>, MlvNotificationRef> {
+    /** @protected Overlay container component reused from `@malva-ui/core/toast`. */
+    protected readonly containerType: typeof MlvToastContainer;
+    /** @protected Concrete item component the container renders for each notification. */
+    protected readonly toastItemType: typeof MlvNotificationItem;
+    /**
+     * @protected Announces the title, description, and the labels of any action
+     * buttons — a keyboard or screen-reader user needs to know an action exists,
+     * since notifications never steal focus. Returns `null` for template and
+     * component content, whose rendered text the service cannot read.
+     */
+    protected resolveAnnouncement(config: MlvNotificationConfig): {
+        message: string;
+        politeness: MlvToastPoliteness;
+    } | null;
+    /** @protected Builds a fully-resolved internal notification from user config, applying defaults. */
+    protected buildItem(id: string, config: MlvNotificationConfig, ref: MlvNotificationRef): MlvInternalNotification;
+    /**
+     * Opens escaped string, template, or component content as a notification.
+     *
+     * Template content receives `MlvNotificationTemplateContext`; component content
+     * can inject `MlvNotificationRef`, `NOTIFICATION_DATA`, and
+     * `NOTIFICATION_CONFIG`.
+     */
+    open<D = unknown>(content: MlvNotificationContent<D>, config?: MlvNotificationOpenConfig<D>): MlvNotificationRef<D>;
+    /** @protected Creates a data-aware reference for each notification. */
+    protected _createRef(id: string, position: MlvToastPosition, config: MlvNotificationConfig): MlvNotificationRef;
+    success(title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    error(title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    warning(title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    info(title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    tone(v: MlvNotificationTone, title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvNotificationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MlvNotificationService>;
+}
+
+export { MlvNotificationItem, MlvNotificationRef, MlvNotificationService, NOTIFICATION_CONFIG, NOTIFICATION_DATA };
+export type { MlvInternalNotification, MlvNotificationAction, MlvNotificationConfig, MlvNotificationContent, MlvNotificationOpenConfig, MlvNotificationTemplateContext, MlvNotificationTone };

package/types/malva-ui-core-number-input.d.ts

@@ -0,0 +1,167 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as _malva_ui_i18n from '@malva-ui/i18n';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { MlvSignalFormControlBase, MlvFormControl } from '@malva-ui/core/form-utils';
+import * as i1 from '@malva-ui/cdk/density';
+
+/** MlvLayout direction for the increment/decrement controls. */
+type MlvNumberInputControlStack = 'horizontal' | 'vertical';
+/** Side used for the vertical control stack. */
+type MlvNumberInputControlAlignment = 'left' | 'right';
+declare class MlvNumberInput extends MlvSignalFormControlBase<number | null> implements MlvFormControl {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: _angular_core.Signal<_malva_ui_i18n.MlvNumberInputI18n>;
+    /**
+     * Minimum allowed value. Also a signal-forms field binding: a `min` schema
+     * rule on the bound field binds this input (`NonNullable<number>|undefined`),
+     * so the write type widens to accept `undefined` (normalised to `null`).
+     */
+    readonly min: _angular_core.InputSignalWithTransform<number | null, number | null | undefined>;
+    /**
+     * Maximum allowed value. Also a signal-forms field binding: a `max` schema
+     * rule on the bound field binds this input (`NonNullable<number>|undefined`),
+     * so the write type widens to accept `undefined` (normalised to `null`).
+     */
+    readonly max: _angular_core.InputSignalWithTransform<number | null, number | null | undefined>;
+    /**
+     * Step increment for arrow keys and stepper buttons. Default: 1. Write type
+     * widened to accept `undefined` (normalised to the `1` default) for
+     * signal-forms constraint-binding parity with the other numeric inputs.
+     */
+    readonly step: _angular_core.InputSignalWithTransform<number, number | null | undefined>;
+    /**
+     * Large step for Shift+Arrow keys.
+     * Defaults to 10 × step when null.
+     */
+    readonly largeStep: _angular_core.InputSignal<number | null>;
+    /** Placeholder text shown when the input is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /**
+     * Decimal precision for displayed value.
+     * When null, precision is inferred from the step value.
+     */
+    readonly precision: _angular_core.InputSignal<number | null>;
+    /**
+     * Whether scroll-wheel stepping is enabled when the input is focused.
+     * Default: true.
+     */
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** MlvLayout direction for the increment/decrement controls. */
+    readonly stack: _angular_core.InputSignal<MlvNumberInputControlStack>;
+    /**
+     * Side used for the vertical control stack.
+     * Has no visual effect while `stack` is `'horizontal'`.
+     */
+    readonly controlAlignment: _angular_core.InputSignal<MlvNumberInputControlAlignment>;
+    /** @private Reference to the native input element. */
+    protected readonly _inputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    /**
+     * The committed numeric value — the signal-forms `FormValueControl` model
+     * (`null` when empty/cleared). Kept in sync with the bound field by
+     * `[formField]` / `[formControl]` / `ngModel`. Out-of-range form-side writes
+     * are re-clamped into `[min, max]` by the constructor effect (the
+     * replacement for the old CVA `writeValue` clamp).
+     */
+    readonly value: _angular_core.ModelSignal<number | null>;
+    /** @private Raw string held while the user is typing. */
+    protected readonly _internalStringValue: _angular_core.WritableSignal<string>;
+    /** @private Whether the input currently has focus. */
+    protected readonly _isFocused: _angular_core.WritableSignal<boolean>;
+    /** True when the current value equals or is below min. */
+    readonly isAtMin: _angular_core.Signal<boolean>;
+    /** True when the current value equals or is above max. */
+    readonly isAtMax: _angular_core.Signal<boolean>;
+    /** Effective large step: largeStep input or 10 × step. */
+    readonly effectiveLargeStep: _angular_core.Signal<number>;
+    /**
+     * Effective decimal precision.
+     * Uses the precision input if set; otherwise infers from the step string.
+     */
+    readonly effectivePrecision: _angular_core.Signal<number>;
+    /** @private DestroyRef used for long-press timer cleanup. */
+    private readonly _destroyRef;
+    private readonly _rtlService;
+    /** @private Long-press delay timer handle. */
+    private _longPressDelayTimer;
+    /** @private Long-press repeat interval handle. */
+    private _longPressIntervalTimer;
+    /** @private Timestamp when long-press started (for large-step threshold). */
+    private _longPressStartTime;
+    constructor();
+    /**
+     * Clears the current value. Called by the MlvFormControlWrapper clear button.
+     */
+    clearValue(): void;
+    /** Whether the control holds a clearable value — A numeric value is set. */
+    readonly hasValue: _angular_core.Signal<boolean>;
+    /**
+     * @protected Handles native input events — stores raw string while typing.
+     */
+    protected _onNativeInput(event: Event): void;
+    /**
+     * @protected Commits typed value on blur: parse, clamp, round, emit, then
+     * reports {@link MlvSignalFormUiControlBase.touch} (replaces CVA `onTouched`).
+     */
+    protected _onBlur(): void;
+    /**
+     * @protected Commits on Enter key press.
+     */
+    protected _onEnter(): void;
+    /**
+     * @protected Handles keyboard navigation on the native input.
+     */
+    protected _onKeydown(event: KeyboardEvent): void;
+    /**
+     * @protected Handles scroll-wheel input when scrollable and focused.
+     * The wheel listener is attached via fromEvent with { passive: false } so
+     * preventDefault() actually suppresses page scroll.
+     */
+    protected _onWheel(event: WheelEvent): void;
+    /**
+     * @protected Starts a long-press sequence for increment (positive delta) or decrement.
+     */
+    protected _onStepperPointerDown(delta: 1 | -1): void;
+    /**
+     * @protected Cancels long-press on pointer release.
+     */
+    protected _onStepperPointerUp(): void;
+    /**
+     * @private Parses the typed string, clamps, rounds, and commits to `value`.
+     */
+    private _commitTypedValue;
+    /**
+     * @private Applies a numeric delta to the current value, clamping the result.
+     */
+    private _step;
+    /**
+     * @private Sets the numeric value: clamp → round → commit to the `value`
+     * model (which propagates to the bound field).
+     */
+    private _setValue;
+    /**
+     * @private Clamps a value to [min, max].
+     */
+    private _clamp;
+    /**
+     * @private Rounds a value to the effective precision.
+     */
+    private _round;
+    /**
+     * @private Formats a number to the effective precision string.
+     */
+    private _format;
+    /**
+     * @private Clears long-press timers.
+     */
+    private _clearLongPress;
+    /**
+     * @private Focuses the native input after a stepper button click.
+     */
+    private _refocusInput;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MlvNumberInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MlvNumberInput, "mlv-number-input", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "largeStep": { "alias": "largeStep"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "precision": { "alias": "precision"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "stack": { "alias": "stack"; "required": false; "isSignal": true; }; "controlAlignment": { "alias": "controlAlignment"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof i1.MlvCompactComfortableDensity; inputs: { "mlvDensity": "mlvDensity"; }; outputs: {}; }]>;
+}
+
+export { MlvNumberInput };
+export type { MlvNumberInputControlAlignment, MlvNumberInputControlStack };