ngx-mask 22.0.2 → 22.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-mask",
-  "version": "22.0.2",
+  "version": "22.2.0",
   "description": "Input masking for modern Angular — Reactive, template-driven and Signal Forms, zoneless and SSR ready. Dates, numbers, separators, custom patterns.",
   "keywords": [
     "ng2-mask",
@@ -19,6 +19,7 @@
     "LICENSE",
     "README.md",
     "fesm2022/ngx-mask.mjs",
+    "fesm2022/ngx-mask.mjs.map",
     "types",
     "package.json"
   ],

package/types/ngx-mask.d.ts

@@ -138,19 +138,25 @@ declare class NgxMaskApplierService {
     protected percentage: (str: string) => boolean;
     getPrecision: (maskExpression: string) => number;
     private checkAndRemoveSuffix;
-    protected checkInputPrecision: (inputValue: string, precision: number, decimalMarker: NgxMaskConfig["decimalMarker"]) => string;
+    protected checkInputPrecision: (inputValue: string, precision: number) => string;
     protected _stripToDecimal(str: string): string;
     protected _charToRegExpExpression(char: string): string;
     protected _shiftStep(cursor: number): void;
     protected _compareOrIncludes<T>(value: T, comparedValue: T | T[], excludedValue: T): boolean;
     protected _validIP(valuesIP: string[]): boolean;
+    /**
+     * The single rule for "which decimal marker is active": the configured marker, or — for an
+     * array — the first configured marker present in `value` that is not the thousandSeparator,
+     * else the first configured marker that is not the thousandSeparator (#1653).
+     */
+    protected _activeDecimalMarker(value: string): DecimalMarkerChar;
     protected _splitPercentZero(value: string): string;
     protected _findFirstNonZeroAndDecimalIndex(inputString: string, decimalMarker: '.' | ','): {
         decimalMarkerIndex: number | null;
         nonZeroIndex: number | null;
     };
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxMaskApplierService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgxMaskApplierService>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 declare class NgxMaskService extends NgxMaskApplierService {
@@ -269,10 +275,10 @@ declare class NgxMaskService extends NgxMaskApplierService {
      */
     currentLocaleDecimalMarker(): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgxMaskService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NgxMaskService>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
-declare class NgxMaskDirective implements ControlValueAccessor, OnChanges, Validator, FormValueControl<string> {
+declare class NgxMaskDirective implements ControlValueAccessor, OnChanges, Validator, FormValueControl<string | number | null | undefined> {
     mask: _angular_core.InputSignal<string | null | undefined>;
     specialCharacters: _angular_core.InputSignal<string[] | readonly string[]>;
     patterns: _angular_core.InputSignal<Record<string, {
@@ -303,7 +309,19 @@ declare class NgxMaskDirective implements ControlValueAccessor, OnChanges, Valid
     keepCharacterPositions: _angular_core.InputSignal<boolean | null>;
     instantPrefix: _angular_core.InputSignal<boolean | null>;
     defaultValueOnBlur: _angular_core.InputSignal<string | null>;
-    value: _angular_core.ModelSignal<string>;
+    /**
+     * Signal Forms `FormValueControl` surface. At runtime `FormField` never drives this model
+     * when the directive is bound (it prefers the `NG_VALUE_ACCESSOR` provided above, see
+     * `_isCvaMode`), but the template type-checker treats any directive owning a `value` model
+     * as the field's custom control and checks the bound field's value type against it (#1640).
+     * The model therefore accepts exactly what `writeValue()` accepts — `string | number | null |
+     * undefined` — so numeric and nullable fields (`signal({ amount: 0 })`,
+     * `signal<number | null>(null)`, `signal<string | null>(null)`) compile under
+     * `strictTemplates`. Values pushed back into the model are always the unmasked string (see
+     * `_propagateToValueModel`), i.e. `value()` / `valueChange` are declared wider than what is
+     * emitted.
+     */
+    value: _angular_core.ModelSignal<string | number | null | undefined>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     touched: _angular_core.ModelSignal<boolean>;
     maskFilled: _angular_core.OutputEmitterRef<void>;
@@ -389,6 +407,34 @@ declare class NgxMaskDirective implements ControlValueAccessor, OnChanges, Valid
     onFocus(): void;
     onModelChange(value: unknown): void;
     onInput(e: Event): void;
+    /**
+     * #1488: locates the date/time field (DAY/MONTH/HOURS/HOUR/MINUTE/SECOND) that
+     * `position` falls within, scanning `maskExpression` left-to-right. A field spans
+     * its token plus its digit-pair companion — `0` for DAY/MONTH/MINUTE/SECOND (e.g.
+     * `d0`, `M0`, `m0`, `s0`), or `HOUR` for the combined `Hh` hour field. Matches any
+     * position from the field's first char up to and including its end (separator index),
+     * so both a still-mid-typing caret and the just-completed field are covered — the
+     * precise overflow decision (single first digit vs. completed 2-digit value) happens
+     * in `_isFieldOverflowing`. Returns null for non-date/time masks, a no-op for the caller.
+     */
+    private _findDateTimeFieldAt;
+    /**
+     * Per-token overflow thresholds, mirroring the ones `generic-pattern.handler.ts`
+     * already establishes (day 31, month 12, hour 23/12 w/ apm, minute/second 59) — kept
+     * as a small local table rather than importing from the handler (see design's
+     * Rejected Alternatives: the directive and the handler stay on separate sides of the
+     * display/parse boundary).
+     *
+     * Two overflow shapes are checked, mirroring how the handler itself decides mid-type:
+     * - `firstDigitValue`: when `position` is exactly one char past the field's start (the
+     *   just-typed char is the field's first digit), an out-of-range first digit alone
+     *   (e.g. month digit `3`, day digit `4`) already triggers the handler's own leadZero
+     *   pad within this same keystroke — `el.value` hasn't caught up yet at this point in
+     *   the pipeline, so the raw typed digit (`inputValue`) must be read instead.
+     * - `fieldValue`: once both digits of the field are present in `el.value`, an
+     *   out-of-range 2-digit value (e.g. day `33`, month `13`) triggers the shift directly.
+     */
+    private _isFieldOverflowing;
     /**
      * Whether any pattern slot of the current mask expression can accept a letter.
      * IME composition is only meaningful for such masks; for purely numeric masks
@@ -412,6 +458,15 @@ declare class NgxMaskDirective implements ControlValueAccessor, OnChanges, Valid
     private _applyDefaultValueOnBlur;
     onClick(e: Event): void;
     onKeyDown(event: Event): void;
+    /**
+     * #1641: on layouts whose decimal separator is a comma, the numeric keypad still emits
+     * a period, which a separator mask configured with a comma decimal marker rejects. The
+     * keypad decimal key (`key: 'Decimal'`, or a `.` from `code: 'NumpadDecimal'`) is
+     * therefore turned into the configured marker. Only the keypad key is intercepted: a
+     * period typed on the main keyboard keeps its normal behavior (e.g. as a thousand
+     * separator). Returns true when the key press was handled.
+     */
+    private _insertNumpadDecimalMarker;
     /**
      * Restores the control's pristine/untouched state after a writeValue-driven emission.
      *