tmw-numeric 0.1.1

package/fesm2020/tmw-numeric.mjs

@@ -0,0 +1,319 @@
+import * as i0 from '@angular/core';
+import { forwardRef, Directive, Input, HostListener } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+
+/**
+ * Modalità di digitazione — nomi/valori/comportamento invariati rispetto a
+ * `@eqproject/eqp-numeric` (`EqpNumericInputMode`), per parità di comportamento.
+ */
+var TmwNumericInputMode;
+(function (TmwNumericInputMode) {
+    /**
+     * I numeri partono dalla precisione più alta (i decimali): digitare uno shifta tutto a
+     * sinistra, il carattere decimale digitato viene ignorato. Es. `'12'` → `'0.12'`,
+     * `'1234'` → `'12.34'`.
+     */
+    TmwNumericInputMode["FINANCIAL"] = "FINANCIAL";
+    /**
+     * I numeri partono a sinistra del separatore decimale, come un campo di testo qualunque.
+     * Es. `'1234'` → `'1234'`, `'12.34'` → `'12.34'`.
+     */
+    TmwNumericInputMode["NATURAL"] = "NATURAL";
+})(TmwNumericInputMode || (TmwNumericInputMode = {}));
+/**
+ * Default identici a `@eqproject/eqp-numeric` — nessun consumer TMED chiamava
+ * `EqpNumericModule.forRoot(...)` né passava `[options]`, quindi questi default SONO il
+ * comportamento reale in produzione (v. AI_BUILD_PLAN.md per i 5 punti d'uso reali).
+ */
+const TMW_NUMERIC_DEFAULT_OPTIONS = {
+    align: 'right',
+    allowNegative: true,
+    decimal: '.',
+    precision: 2,
+    prefix: '$ ',
+    suffix: '',
+    thousands: ',',
+    nullable: false,
+    min: undefined,
+    max: undefined,
+    inputMode: TmwNumericInputMode.NATURAL,
+};
+
+/**
+ * Sostituto di `[eqpNumericMask]` (`@eqproject/eqp-numeric`) — stesso `[options]`, stessi nomi
+ * di opzione, stessi default (v. `TMW_NUMERIC_DEFAULT_OPTIONS`). Nessun `forRoot()`: nessun
+ * consumer reale in TMED lo usava, i default del pacchetto originale erano già il comportamento
+ * effettivo in produzione.
+ *
+ * Formatta un `<input>` come numero mascherato (valuta/decimale) mantenendo il model
+ * (`ngModel`/`formControlName`) come `number | null` — l'utente vede `'$ 1,234.56'`, il form
+ * riceve `1234.56`.
+ *
+ * In modalità NATURAL la formattazione "live" (durante la digitazione) NON forza il padding a
+ * piena precisione: farlo ad ogni tasto arrotonderebbe via le cifre appena digitate (es. digitare
+ * "1" su un campo vuoto renderizzerebbe subito "0.00", perdendo la cifra) — il padding/
+ * arrotondamento pieno avviene solo al `blur`/`writeValue`. In modalità FINANCIAL questo problema
+ * non esiste (il valore si ricalcola sempre da zero dalle sole cifre digitate, insensibile alla
+ * formattazione precedente), quindi lì si usa direttamente il formato pieno ad ogni tasto.
+ */
+class TmwNumericMaskDirective {
+    set options(value) {
+        this._options = { ...TMW_NUMERIC_DEFAULT_OPTIONS, ...(value ?? {}) };
+        this._applyAlignment();
+        this._renderFinal(this._value);
+    }
+    constructor(_elementRef, _renderer) {
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        this._options = { ...TMW_NUMERIC_DEFAULT_OPTIONS };
+        this._value = null;
+        this._onChange = () => { };
+        this._onTouched = () => { };
+        this._disabled = false;
+        /**
+         * Stato PERSISTENTE (non ri-derivato ogni volta dalla stringa già formattata): true dal
+         * momento in cui l'utente ha digitato/incollato un carattere decimale, false quando il campo
+         * è vuoto o quel carattere viene cancellato. Necessario perché in formato euro `thousands` e
+         * l'alternativa mobile-friendly per `decimal` possono coincidere entrambi su `'.'` — v.
+         * `_tokenize` per come risolve l'ambiguità usando questo stato invece di ri-cercare "il primo
+         * punto" nella stringa (che potrebbe essere un separatore delle migliaia già inserito da noi).
+         */
+        this._hasDecimalState = false;
+        this._applyAlignment();
+        // Senza un hint esplicito, mobile/tablet mostrano la tastiera alfanumerica completa per un
+        // <input> senza type/inputmode — sbagliato per un campo numerico. Impostato solo se il
+        // consumer non ha già messo il proprio `type`/`inputmode` nel template (es. `type="tel"`,
+        // suggerito anche dal README dell'originale `eqp-numeric` per Ionic).
+        const el = this._elementRef.nativeElement;
+        if (!el.hasAttribute('inputmode') && !el.hasAttribute('type')) {
+            this._renderer.setAttribute(el, 'inputmode', 'decimal');
+        }
+    }
+    //#region ControlValueAccessor
+    writeValue(value) {
+        this._value = this._roundToPrecision(this._clampRange(value == null ? null : Number(value)));
+        this._hasDecimalState = false;
+        this._renderFinal(this._value);
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this._disabled = isDisabled;
+        this._renderer.setProperty(this._elementRef.nativeElement, 'disabled', isDisabled);
+    }
+    //#endregion
+    onInput(event) {
+        if (this._disabled) {
+            return;
+        }
+        const rawValue = event.target.value;
+        const caretFromEnd = this._captureCaretFromEnd();
+        if (this._options.inputMode === TmwNumericInputMode.FINANCIAL) {
+            this._value = this._clampRange(this._parseFinancial(rawValue));
+            this._onChange(this._value);
+            this._renderFinal(this._value);
+        }
+        else {
+            const { decimal } = this._options;
+            const insertedText = event.data;
+            // Il carattere/testo appena digitato o incollato (`event.data`) dice INEQUIVOCABILMENTE se
+            // l'utente sta esprimendo l'intento "questo è il separatore decimale" — a differenza di
+            // ri-cercare "il primo punto" nell'intera stringa già formattata, che in formato euro
+            // (`thousands: '.'`) confonderebbe un punto delle migliaia già inserito da noi con il
+            // punto decimale appena digitato (v. commento su `_hasDecimalState`).
+            if (insertedText && (insertedText.includes(decimal) || insertedText.includes('.'))) {
+                this._hasDecimalState = true;
+            }
+            if (rawValue.length === 0) {
+                this._hasDecimalState = false;
+            }
+            const { integerDigits, decimalDigits, hasDecimalSeparator, isNegative } = this._tokenize(rawValue, this._hasDecimalState);
+            this._hasDecimalState = hasDecimalSeparator;
+            this._value = this._clampRange(this._toNumber(integerDigits, decimalDigits, isNegative));
+            this._onChange(this._value);
+            this._renderLive(integerDigits, decimalDigits, hasDecimalSeparator, isNegative);
+        }
+        this._restoreCaretFromEnd(caretFromEnd);
+    }
+    onBlur() {
+        this._onTouched();
+        this._value = this._roundToPrecision(this._value);
+        this._onChange(this._value);
+        this._renderFinal(this._value);
+    }
+    _applyAlignment() {
+        this._renderer.setStyle(this._elementRef.nativeElement, 'text-align', this._options.align);
+    }
+    /**
+     * Modalità FINANCIAL: TUTTE le cifre della stringa (incluse quelle già formattate dal render
+     * precedente — prefisso/migliaia/decimali) vengono lette come un unico intero in centesimi
+     * (o nella più piccola unità di `precision`) e ridivise per `10^precision` — è quello che dà
+     * l'effetto "shift da destra" tipico delle casse, insensibile a qualunque formattazione
+     * precedente (a differenza di NATURAL non serve un formato "live" separato).
+     */
+    _parseFinancial(rawValue) {
+        const { precision, allowNegative, nullable } = this._options;
+        const isNegative = allowNegative && this._hasTypedMinus(rawValue);
+        const digitsOnly = rawValue.replace(/[^0-9]/g, '');
+        if (digitsOnly.length === 0) {
+            return nullable ? null : 0;
+        }
+        const units = parseInt(digitsOnly, 10);
+        const value = units / Math.pow(10, precision);
+        return isNegative ? -value : value;
+    }
+    /**
+     * `rawValue.startsWith('-')` non basta: il segno digitato dall'utente finisce SEMPRE dopo un
+     * eventuale prefisso (es. `"$ -5"`), mai a inizio stringa assoluto — si cerca quindi il
+     * carattere ovunque nella stringa.
+     */
+    _hasTypedMinus(rawValue) {
+        return rawValue.includes('-');
+    }
+    /**
+     * Estrae dalla stringa grezza le sole cifre intere/decimali digitate. Usato SOLO in modalità
+     * NATURAL. `hasDecimalHint` (stato persistente, v. `_hasDecimalState`) dice se un separatore
+     * decimale è già stato digitato in un keystroke precedente:
+     *
+     * - `false`: nessun separatore ancora — si scartano TUTTI i caratteri non-cifra (incluso un
+     *   eventuale punto delle migliaia già presente dal render precedente), tutto ciò che resta è
+     *   parte intera.
+     * - `true`: si cerca l'ULTIMA occorrenza di `decimal` o `'.'` nella stringa — mai la prima. Le
+     *   migliaia (anche quando coincidono con `'.'`, formato euro) possono comparire SOLO PRIMA del
+     *   separatore decimale reale (la formattazione non raggruppa mai le cifre decimali), quindi
+     *   l'ultima occorrenza è sempre quella vera, senza ambiguità. Se non se ne trova più nessuna
+     *   (l'utente ha cancellato il separatore), si ritorna a "nessun decimale".
+     */
+    _tokenize(rawValue, hasDecimalHint) {
+        const { decimal, allowNegative, precision } = this._options;
+        const isNegative = allowNegative && this._hasTypedMinus(rawValue);
+        if (!hasDecimalHint) {
+            return { integerDigits: rawValue.replace(/[^0-9]/g, ''), decimalDigits: '', hasDecimalSeparator: false, isNegative };
+        }
+        let splitIndex = -1;
+        for (let i = rawValue.length - 1; i >= 0; i--) {
+            if (rawValue[i] === decimal || rawValue[i] === '.') {
+                splitIndex = i;
+                break;
+            }
+        }
+        if (splitIndex === -1) {
+            return { integerDigits: rawValue.replace(/[^0-9]/g, ''), decimalDigits: '', hasDecimalSeparator: false, isNegative };
+        }
+        const integerDigits = rawValue.slice(0, splitIndex).replace(/[^0-9]/g, '');
+        const decimalDigits = rawValue.slice(splitIndex + 1).replace(/[^0-9]/g, '').slice(0, precision);
+        return { integerDigits, decimalDigits, hasDecimalSeparator: true, isNegative };
+    }
+    _toNumber(integerDigits, decimalDigits, isNegative) {
+        if (integerDigits.length === 0 && decimalDigits.length === 0) {
+            return this._options.nullable ? null : 0;
+        }
+        const value = parseFloat(`${integerDigits || '0'}.${decimalDigits || '0'}`);
+        return isNegative ? -value : value;
+    }
+    /** Applica solo `allowNegative`/`min`/`max` — NON arrotonda a `precision` (v. commento di classe). */
+    _clampRange(value) {
+        if (value == null) {
+            return value;
+        }
+        const { min, max, allowNegative } = this._options;
+        let result = value;
+        if (!allowNegative && result < 0) {
+            result = -result;
+        }
+        if (min != null && result < min) {
+            result = min;
+        }
+        if (max != null && result > max) {
+            result = max;
+        }
+        return result;
+    }
+    _roundToPrecision(value) {
+        if (value == null) {
+            return value;
+        }
+        const factor = Math.pow(10, this._options.precision);
+        return Math.round(value * factor) / factor;
+    }
+    /** Formato "live", usato in NATURAL durante la digitazione: nessun padding/arrotondamento. */
+    _renderLive(integerDigits, decimalDigits, hasDecimalSeparator, isNegative) {
+        const { prefix, suffix, thousands, decimal, precision } = this._options;
+        const groupedInteger = integerDigits.replace(/\B(?=(\d{3})+(?!\d))/g, thousands);
+        const decimalSegment = precision > 0 && hasDecimalSeparator ? decimal + decimalDigits : '';
+        const formatted = `${isNegative ? '-' : ''}${prefix}${groupedInteger}${decimalSegment}${suffix}`;
+        this._renderer.setProperty(this._elementRef.nativeElement, 'value', formatted);
+    }
+    /** Formato pieno (padding a `precision`, arrotondato) — usato a `blur`/`writeValue`/opzioni cambiate. */
+    _renderFinal(value) {
+        const formatted = value == null ? '' : this._formatFull(value);
+        this._renderer.setProperty(this._elementRef.nativeElement, 'value', formatted);
+    }
+    _formatFull(value) {
+        const { prefix, suffix, thousands, decimal, precision } = this._options;
+        const isNegative = value < 0;
+        const fixed = Math.abs(value).toFixed(precision);
+        const [integerPart, decimalPart] = fixed.split('.');
+        const groupedInteger = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, thousands);
+        const decimalSegment = precision > 0 ? decimal + decimalPart : '';
+        return `${isNegative ? '-' : ''}${prefix}${groupedInteger}${decimalSegment}${suffix}`;
+    }
+    _captureCaretFromEnd() {
+        const el = this._elementRef.nativeElement;
+        const caret = el.selectionStart ?? el.value.length;
+        return el.value.length - caret;
+    }
+    _restoreCaretFromEnd(distanceFromEnd) {
+        const el = this._elementRef.nativeElement;
+        const position = Math.max(0, el.value.length - distanceFromEnd);
+        // Il reformat avviene sincronamente nello stesso ciclo dell'evento `input`: il browser
+        // applica la posizione del cursore SUBITO dopo, senza bisogno di un setTimeout/microtask.
+        el.setSelectionRange(position, position);
+    }
+}
+TmwNumericMaskDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TmwNumericMaskDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+TmwNumericMaskDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: TmwNumericMaskDirective, isStandalone: true, selector: "[tmwNumericMask]", inputs: { options: "options" }, host: { listeners: { "input": "onInput($event)", "blur": "onBlur()" } }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => TmwNumericMaskDirective),
+            multi: true,
+        },
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TmwNumericMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tmwNumericMask]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => TmwNumericMaskDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { options: [{
+                type: Input,
+                args: ['options']
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }] } });
+
+/*
+ * Public API Surface of tmw-numeric
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { TMW_NUMERIC_DEFAULT_OPTIONS, TmwNumericInputMode, TmwNumericMaskDirective };
+//# sourceMappingURL=tmw-numeric.mjs.map

package/fesm2020/tmw-numeric.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tmw-numeric.mjs","sources":["../../../projects/tmw-numeric/src/lib/models/tmw-numeric-options.model.ts","../../../projects/tmw-numeric/src/lib/tmw-numeric-mask.directive.ts","../../../projects/tmw-numeric/src/public-api.ts","../../../projects/tmw-numeric/src/tmw-numeric.ts"],"sourcesContent":["/**\n * Modalità di digitazione — nomi/valori/comportamento invariati rispetto a\n * `@eqproject/eqp-numeric` (`EqpNumericInputMode`), per parità di comportamento.\n */\nexport enum TmwNumericInputMode {\n  /**\n   * I numeri partono dalla precisione più alta (i decimali): digitare uno shifta tutto a\n   * sinistra, il carattere decimale digitato viene ignorato. Es. `'12'` → `'0.12'`,\n   * `'1234'` → `'12.34'`.\n   */\n  FINANCIAL = 'FINANCIAL',\n  /**\n   * I numeri partono a sinistra del separatore decimale, come un campo di testo qualunque.\n   * Es. `'1234'` → `'1234'`, `'12.34'` → `'12.34'`.\n   */\n  NATURAL = 'NATURAL',\n}\n\nexport interface TmwNumericOptions {\n  /** Allineamento testo nell'input. Default `'right'`. */\n  align?: 'left' | 'right';\n  /** Se `true` consente valori negativi. Default `true`. */\n  allowNegative?: boolean;\n  /** Separatore dei decimali. Default `'.'`. */\n  decimal?: string;\n  /** Numero di cifre decimali. Default `2`. */\n  precision?: number;\n  /** Prefisso (es. simbolo valuta). Default `'$ '`. */\n  prefix?: string;\n  /** Suffisso. Default `''`. */\n  suffix?: string;\n  /** Separatore delle migliaia. Default `','`. */\n  thousands?: string;\n  /** Se `true`, un campo vuoto produce `null` invece di `0`. Default `false`. */\n  nullable?: boolean;\n  /** Valore minimo consentito. Default `undefined` (nessun limite). */\n  min?: number;\n  /** Valore massimo consentito. Default `undefined` (nessun limite). */\n  max?: number;\n  /** Modalità di digitazione. Default `NATURAL`. */\n  inputMode?: TmwNumericInputMode;\n}\n\n/**\n * Default identici a `@eqproject/eqp-numeric` — nessun consumer TMED chiamava\n * `EqpNumericModule.forRoot(...)` né passava `[options]`, quindi questi default SONO il\n * comportamento reale in produzione (v. AI_BUILD_PLAN.md per i 5 punti d'uso reali).\n */\nexport const TMW_NUMERIC_DEFAULT_OPTIONS: Required<TmwNumericOptions> = {\n  align: 'right',\n  allowNegative: true,\n  decimal: '.',\n  precision: 2,\n  prefix: '$ ',\n  suffix: '',\n  thousands: ',',\n  nullable: false,\n  min: undefined as unknown as number,\n  max: undefined as unknown as number,\n  inputMode: TmwNumericInputMode.NATURAL,\n};\n","import { Directive, ElementRef, HostListener, Input, Renderer2, forwardRef } from '@angular/core';\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\nimport { TMW_NUMERIC_DEFAULT_OPTIONS, TmwNumericInputMode, TmwNumericOptions } from './models/tmw-numeric-options.model';\n\n/**\n * Sostituto di `[eqpNumericMask]` (`@eqproject/eqp-numeric`) — stesso `[options]`, stessi nomi\n * di opzione, stessi default (v. `TMW_NUMERIC_DEFAULT_OPTIONS`). Nessun `forRoot()`: nessun\n * consumer reale in TMED lo usava, i default del pacchetto originale erano già il comportamento\n * effettivo in produzione.\n *\n * Formatta un `<input>` come numero mascherato (valuta/decimale) mantenendo il model\n * (`ngModel`/`formControlName`) come `number | null` — l'utente vede `'$ 1,234.56'`, il form\n * riceve `1234.56`.\n *\n * In modalità NATURAL la formattazione \"live\" (durante la digitazione) NON forza il padding a\n * piena precisione: farlo ad ogni tasto arrotonderebbe via le cifre appena digitate (es. digitare\n * \"1\" su un campo vuoto renderizzerebbe subito \"0.00\", perdendo la cifra) — il padding/\n * arrotondamento pieno avviene solo al `blur`/`writeValue`. In modalità FINANCIAL questo problema\n * non esiste (il valore si ricalcola sempre da zero dalle sole cifre digitate, insensibile alla\n * formattazione precedente), quindi lì si usa direttamente il formato pieno ad ogni tasto.\n */\n@Directive({\n  selector: '[tmwNumericMask]',\n  standalone: true,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => TmwNumericMaskDirective),\n      multi: true,\n    },\n  ],\n})\nexport class TmwNumericMaskDirective implements ControlValueAccessor {\n  private _options: Required<TmwNumericOptions> = { ...TMW_NUMERIC_DEFAULT_OPTIONS };\n\n  @Input('options')\n  set options(value: TmwNumericOptions | undefined) {\n    this._options = { ...TMW_NUMERIC_DEFAULT_OPTIONS, ...(value ?? {}) };\n    this._applyAlignment();\n    this._renderFinal(this._value);\n  }\n\n  private _value: number | null = null;\n  private _onChange: (value: number | null) => void = () => {};\n  private _onTouched: () => void = () => {};\n  private _disabled = false;\n  /**\n   * Stato PERSISTENTE (non ri-derivato ogni volta dalla stringa già formattata): true dal\n   * momento in cui l'utente ha digitato/incollato un carattere decimale, false quando il campo\n   * è vuoto o quel carattere viene cancellato. Necessario perché in formato euro `thousands` e\n   * l'alternativa mobile-friendly per `decimal` possono coincidere entrambi su `'.'` — v.\n   * `_tokenize` per come risolve l'ambiguità usando questo stato invece di ri-cercare \"il primo\n   * punto\" nella stringa (che potrebbe essere un separatore delle migliaia già inserito da noi).\n   */\n  private _hasDecimalState = false;\n\n  constructor(private _elementRef: ElementRef<HTMLInputElement>, private _renderer: Renderer2) {\n    this._applyAlignment();\n    // Senza un hint esplicito, mobile/tablet mostrano la tastiera alfanumerica completa per un\n    // <input> senza type/inputmode — sbagliato per un campo numerico. Impostato solo se il\n    // consumer non ha già messo il proprio `type`/`inputmode` nel template (es. `type=\"tel\"`,\n    // suggerito anche dal README dell'originale `eqp-numeric` per Ionic).\n    const el = this._elementRef.nativeElement;\n    if (!el.hasAttribute('inputmode') && !el.hasAttribute('type')) {\n      this._renderer.setAttribute(el, 'inputmode', 'decimal');\n    }\n  }\n\n  //#region ControlValueAccessor\n\n  writeValue(value: number | null): void {\n    this._value = this._roundToPrecision(this._clampRange(value == null ? null : Number(value)));\n    this._hasDecimalState = false;\n    this._renderFinal(this._value);\n  }\n\n  registerOnChange(fn: (value: number | null) => void): void {\n    this._onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this._onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this._disabled = isDisabled;\n    this._renderer.setProperty(this._elementRef.nativeElement, 'disabled', isDisabled);\n  }\n\n  //#endregion\n\n  @HostListener('input', ['$event'])\n  onInput(event: InputEvent): void {\n    if (this._disabled) {\n      return;\n    }\n    const rawValue = (event.target as HTMLInputElement).value;\n    const caretFromEnd = this._captureCaretFromEnd();\n\n    if (this._options.inputMode === TmwNumericInputMode.FINANCIAL) {\n      this._value = this._clampRange(this._parseFinancial(rawValue));\n      this._onChange(this._value);\n      this._renderFinal(this._value);\n    } else {\n      const { decimal } = this._options;\n      const insertedText = event.data;\n      // Il carattere/testo appena digitato o incollato (`event.data`) dice INEQUIVOCABILMENTE se\n      // l'utente sta esprimendo l'intento \"questo è il separatore decimale\" — a differenza di\n      // ri-cercare \"il primo punto\" nell'intera stringa già formattata, che in formato euro\n      // (`thousands: '.'`) confonderebbe un punto delle migliaia già inserito da noi con il\n      // punto decimale appena digitato (v. commento su `_hasDecimalState`).\n      if (insertedText && (insertedText.includes(decimal) || insertedText.includes('.'))) {\n        this._hasDecimalState = true;\n      }\n      if (rawValue.length === 0) {\n        this._hasDecimalState = false;\n      }\n      const { integerDigits, decimalDigits, hasDecimalSeparator, isNegative } = this._tokenize(rawValue, this._hasDecimalState);\n      this._hasDecimalState = hasDecimalSeparator;\n      this._value = this._clampRange(this._toNumber(integerDigits, decimalDigits, isNegative));\n      this._onChange(this._value);\n      this._renderLive(integerDigits, decimalDigits, hasDecimalSeparator, isNegative);\n    }\n    this._restoreCaretFromEnd(caretFromEnd);\n  }\n\n  @HostListener('blur')\n  onBlur(): void {\n    this._onTouched();\n    this._value = this._roundToPrecision(this._value);\n    this._onChange(this._value);\n    this._renderFinal(this._value);\n  }\n\n  private _applyAlignment(): void {\n    this._renderer.setStyle(this._elementRef.nativeElement, 'text-align', this._options.align);\n  }\n\n  /**\n   * Modalità FINANCIAL: TUTTE le cifre della stringa (incluse quelle già formattate dal render\n   * precedente — prefisso/migliaia/decimali) vengono lette come un unico intero in centesimi\n   * (o nella più piccola unità di `precision`) e ridivise per `10^precision` — è quello che dà\n   * l'effetto \"shift da destra\" tipico delle casse, insensibile a qualunque formattazione\n   * precedente (a differenza di NATURAL non serve un formato \"live\" separato).\n   */\n  private _parseFinancial(rawValue: string): number | null {\n    const { precision, allowNegative, nullable } = this._options;\n    const isNegative = allowNegative && this._hasTypedMinus(rawValue);\n    const digitsOnly = rawValue.replace(/[^0-9]/g, '');\n    if (digitsOnly.length === 0) {\n      return nullable ? null : 0;\n    }\n    const units = parseInt(digitsOnly, 10);\n    const value = units / Math.pow(10, precision);\n    return isNegative ? -value : value;\n  }\n\n  /**\n   * `rawValue.startsWith('-')` non basta: il segno digitato dall'utente finisce SEMPRE dopo un\n   * eventuale prefisso (es. `\"$ -5\"`), mai a inizio stringa assoluto — si cerca quindi il\n   * carattere ovunque nella stringa.\n   */\n  private _hasTypedMinus(rawValue: string): boolean {\n    return rawValue.includes('-');\n  }\n\n  /**\n   * Estrae dalla stringa grezza le sole cifre intere/decimali digitate. Usato SOLO in modalità\n   * NATURAL. `hasDecimalHint` (stato persistente, v. `_hasDecimalState`) dice se un separatore\n   * decimale è già stato digitato in un keystroke precedente:\n   *\n   * - `false`: nessun separatore ancora — si scartano TUTTI i caratteri non-cifra (incluso un\n   *   eventuale punto delle migliaia già presente dal render precedente), tutto ciò che resta è\n   *   parte intera.\n   * - `true`: si cerca l'ULTIMA occorrenza di `decimal` o `'.'` nella stringa — mai la prima. Le\n   *   migliaia (anche quando coincidono con `'.'`, formato euro) possono comparire SOLO PRIMA del\n   *   separatore decimale reale (la formattazione non raggruppa mai le cifre decimali), quindi\n   *   l'ultima occorrenza è sempre quella vera, senza ambiguità. Se non se ne trova più nessuna\n   *   (l'utente ha cancellato il separatore), si ritorna a \"nessun decimale\".\n   */\n  private _tokenize(rawValue: string, hasDecimalHint: boolean): {\n    integerDigits: string;\n    decimalDigits: string;\n    hasDecimalSeparator: boolean;\n    isNegative: boolean;\n  } {\n    const { decimal, allowNegative, precision } = this._options;\n    const isNegative = allowNegative && this._hasTypedMinus(rawValue);\n\n    if (!hasDecimalHint) {\n      return { integerDigits: rawValue.replace(/[^0-9]/g, ''), decimalDigits: '', hasDecimalSeparator: false, isNegative };\n    }\n\n    let splitIndex = -1;\n    for (let i = rawValue.length - 1; i >= 0; i--) {\n      if (rawValue[i] === decimal || rawValue[i] === '.') {\n        splitIndex = i;\n        break;\n      }\n    }\n    if (splitIndex === -1) {\n      return { integerDigits: rawValue.replace(/[^0-9]/g, ''), decimalDigits: '', hasDecimalSeparator: false, isNegative };\n    }\n    const integerDigits = rawValue.slice(0, splitIndex).replace(/[^0-9]/g, '');\n    const decimalDigits = rawValue.slice(splitIndex + 1).replace(/[^0-9]/g, '').slice(0, precision);\n    return { integerDigits, decimalDigits, hasDecimalSeparator: true, isNegative };\n  }\n\n  private _toNumber(integerDigits: string, decimalDigits: string, isNegative: boolean): number | null {\n    if (integerDigits.length === 0 && decimalDigits.length === 0) {\n      return this._options.nullable ? null : 0;\n    }\n    const value = parseFloat(`${integerDigits || '0'}.${decimalDigits || '0'}`);\n    return isNegative ? -value : value;\n  }\n\n  /** Applica solo `allowNegative`/`min`/`max` — NON arrotonda a `precision` (v. commento di classe). */\n  private _clampRange(value: number | null): number | null {\n    if (value == null) {\n      return value;\n    }\n    const { min, max, allowNegative } = this._options;\n    let result = value;\n    if (!allowNegative && result < 0) {\n      result = -result;\n    }\n    if (min != null && result < min) {\n      result = min;\n    }\n    if (max != null && result > max) {\n      result = max;\n    }\n    return result;\n  }\n\n  private _roundToPrecision(value: number | null): number | null {\n    if (value == null) {\n      return value;\n    }\n    const factor = Math.pow(10, this._options.precision);\n    return Math.round(value * factor) / factor;\n  }\n\n  /** Formato \"live\", usato in NATURAL durante la digitazione: nessun padding/arrotondamento. */\n  private _renderLive(integerDigits: string, decimalDigits: string, hasDecimalSeparator: boolean, isNegative: boolean): void {\n    const { prefix, suffix, thousands, decimal, precision } = this._options;\n    const groupedInteger = integerDigits.replace(/\\B(?=(\\d{3})+(?!\\d))/g, thousands);\n    const decimalSegment = precision > 0 && hasDecimalSeparator ? decimal + decimalDigits : '';\n    const formatted = `${isNegative ? '-' : ''}${prefix}${groupedInteger}${decimalSegment}${suffix}`;\n    this._renderer.setProperty(this._elementRef.nativeElement, 'value', formatted);\n  }\n\n  /** Formato pieno (padding a `precision`, arrotondato) — usato a `blur`/`writeValue`/opzioni cambiate. */\n  private _renderFinal(value: number | null): void {\n    const formatted = value == null ? '' : this._formatFull(value);\n    this._renderer.setProperty(this._elementRef.nativeElement, 'value', formatted);\n  }\n\n  private _formatFull(value: number): string {\n    const { prefix, suffix, thousands, decimal, precision } = this._options;\n    const isNegative = value < 0;\n    const fixed = Math.abs(value).toFixed(precision);\n    const [integerPart, decimalPart] = fixed.split('.');\n    const groupedInteger = integerPart.replace(/\\B(?=(\\d{3})+(?!\\d))/g, thousands);\n    const decimalSegment = precision > 0 ? decimal + decimalPart : '';\n    return `${isNegative ? '-' : ''}${prefix}${groupedInteger}${decimalSegment}${suffix}`;\n  }\n\n  private _captureCaretFromEnd(): number {\n    const el = this._elementRef.nativeElement;\n    const caret = el.selectionStart ?? el.value.length;\n    return el.value.length - caret;\n  }\n\n  private _restoreCaretFromEnd(distanceFromEnd: number): void {\n    const el = this._elementRef.nativeElement;\n    const position = Math.max(0, el.value.length - distanceFromEnd);\n    // Il reformat avviene sincronamente nello stesso ciclo dell'evento `input`: il browser\n    // applica la posizione del cursore SUBITO dopo, senza bisogno di un setTimeout/microtask.\n    el.setSelectionRange(position, position);\n  }\n}\n","/*\n * Public API Surface of tmw-numeric\n */\n\nexport * from './lib/tmw-numeric-mask.directive';\nexport * from './lib/models/tmw-numeric-options.model';\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":"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"}

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="tmw-numeric" />
+export * from './public-api';

package/lib/models/tmw-numeric-options.model.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Modalità di digitazione — nomi/valori/comportamento invariati rispetto a
+ * `@eqproject/eqp-numeric` (`EqpNumericInputMode`), per parità di comportamento.
+ */
+export declare enum TmwNumericInputMode {
+    /**
+     * I numeri partono dalla precisione più alta (i decimali): digitare uno shifta tutto a
+     * sinistra, il carattere decimale digitato viene ignorato. Es. `'12'` → `'0.12'`,
+     * `'1234'` → `'12.34'`.
+     */
+    FINANCIAL = "FINANCIAL",
+    /**
+     * I numeri partono a sinistra del separatore decimale, come un campo di testo qualunque.
+     * Es. `'1234'` → `'1234'`, `'12.34'` → `'12.34'`.
+     */
+    NATURAL = "NATURAL"
+}
+export interface TmwNumericOptions {
+    /** Allineamento testo nell'input. Default `'right'`. */
+    align?: 'left' | 'right';
+    /** Se `true` consente valori negativi. Default `true`. */
+    allowNegative?: boolean;
+    /** Separatore dei decimali. Default `'.'`. */
+    decimal?: string;
+    /** Numero di cifre decimali. Default `2`. */
+    precision?: number;
+    /** Prefisso (es. simbolo valuta). Default `'$ '`. */
+    prefix?: string;
+    /** Suffisso. Default `''`. */
+    suffix?: string;
+    /** Separatore delle migliaia. Default `','`. */
+    thousands?: string;
+    /** Se `true`, un campo vuoto produce `null` invece di `0`. Default `false`. */
+    nullable?: boolean;
+    /** Valore minimo consentito. Default `undefined` (nessun limite). */
+    min?: number;
+    /** Valore massimo consentito. Default `undefined` (nessun limite). */
+    max?: number;
+    /** Modalità di digitazione. Default `NATURAL`. */
+    inputMode?: TmwNumericInputMode;
+}
+/**
+ * Default identici a `@eqproject/eqp-numeric` — nessun consumer TMED chiamava
+ * `EqpNumericModule.forRoot(...)` né passava `[options]`, quindi questi default SONO il
+ * comportamento reale in produzione (v. AI_BUILD_PLAN.md per i 5 punti d'uso reali).
+ */
+export declare const TMW_NUMERIC_DEFAULT_OPTIONS: Required<TmwNumericOptions>;

package/lib/tmw-numeric-mask.directive.d.ts

@@ -0,0 +1,90 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { TmwNumericOptions } from './models/tmw-numeric-options.model';
+import * as i0 from "@angular/core";
+/**
+ * Sostituto di `[eqpNumericMask]` (`@eqproject/eqp-numeric`) — stesso `[options]`, stessi nomi
+ * di opzione, stessi default (v. `TMW_NUMERIC_DEFAULT_OPTIONS`). Nessun `forRoot()`: nessun
+ * consumer reale in TMED lo usava, i default del pacchetto originale erano già il comportamento
+ * effettivo in produzione.
+ *
+ * Formatta un `<input>` come numero mascherato (valuta/decimale) mantenendo il model
+ * (`ngModel`/`formControlName`) come `number | null` — l'utente vede `'$ 1,234.56'`, il form
+ * riceve `1234.56`.
+ *
+ * In modalità NATURAL la formattazione "live" (durante la digitazione) NON forza il padding a
+ * piena precisione: farlo ad ogni tasto arrotonderebbe via le cifre appena digitate (es. digitare
+ * "1" su un campo vuoto renderizzerebbe subito "0.00", perdendo la cifra) — il padding/
+ * arrotondamento pieno avviene solo al `blur`/`writeValue`. In modalità FINANCIAL questo problema
+ * non esiste (il valore si ricalcola sempre da zero dalle sole cifre digitate, insensibile alla
+ * formattazione precedente), quindi lì si usa direttamente il formato pieno ad ogni tasto.
+ */
+export declare class TmwNumericMaskDirective implements ControlValueAccessor {
+    private _elementRef;
+    private _renderer;
+    private _options;
+    set options(value: TmwNumericOptions | undefined);
+    private _value;
+    private _onChange;
+    private _onTouched;
+    private _disabled;
+    /**
+     * Stato PERSISTENTE (non ri-derivato ogni volta dalla stringa già formattata): true dal
+     * momento in cui l'utente ha digitato/incollato un carattere decimale, false quando il campo
+     * è vuoto o quel carattere viene cancellato. Necessario perché in formato euro `thousands` e
+     * l'alternativa mobile-friendly per `decimal` possono coincidere entrambi su `'.'` — v.
+     * `_tokenize` per come risolve l'ambiguità usando questo stato invece di ri-cercare "il primo
+     * punto" nella stringa (che potrebbe essere un separatore delle migliaia già inserito da noi).
+     */
+    private _hasDecimalState;
+    constructor(_elementRef: ElementRef<HTMLInputElement>, _renderer: Renderer2);
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: InputEvent): void;
+    onBlur(): void;
+    private _applyAlignment;
+    /**
+     * Modalità FINANCIAL: TUTTE le cifre della stringa (incluse quelle già formattate dal render
+     * precedente — prefisso/migliaia/decimali) vengono lette come un unico intero in centesimi
+     * (o nella più piccola unità di `precision`) e ridivise per `10^precision` — è quello che dà
+     * l'effetto "shift da destra" tipico delle casse, insensibile a qualunque formattazione
+     * precedente (a differenza di NATURAL non serve un formato "live" separato).
+     */
+    private _parseFinancial;
+    /**
+     * `rawValue.startsWith('-')` non basta: il segno digitato dall'utente finisce SEMPRE dopo un
+     * eventuale prefisso (es. `"$ -5"`), mai a inizio stringa assoluto — si cerca quindi il
+     * carattere ovunque nella stringa.
+     */
+    private _hasTypedMinus;
+    /**
+     * Estrae dalla stringa grezza le sole cifre intere/decimali digitate. Usato SOLO in modalità
+     * NATURAL. `hasDecimalHint` (stato persistente, v. `_hasDecimalState`) dice se un separatore
+     * decimale è già stato digitato in un keystroke precedente:
+     *
+     * - `false`: nessun separatore ancora — si scartano TUTTI i caratteri non-cifra (incluso un
+     *   eventuale punto delle migliaia già presente dal render precedente), tutto ciò che resta è
+     *   parte intera.
+     * - `true`: si cerca l'ULTIMA occorrenza di `decimal` o `'.'` nella stringa — mai la prima. Le
+     *   migliaia (anche quando coincidono con `'.'`, formato euro) possono comparire SOLO PRIMA del
+     *   separatore decimale reale (la formattazione non raggruppa mai le cifre decimali), quindi
+     *   l'ultima occorrenza è sempre quella vera, senza ambiguità. Se non se ne trova più nessuna
+     *   (l'utente ha cancellato il separatore), si ritorna a "nessun decimale".
+     */
+    private _tokenize;
+    private _toNumber;
+    /** Applica solo `allowNegative`/`min`/`max` — NON arrotonda a `precision` (v. commento di classe). */
+    private _clampRange;
+    private _roundToPrecision;
+    /** Formato "live", usato in NATURAL durante la digitazione: nessun padding/arrotondamento. */
+    private _renderLive;
+    /** Formato pieno (padding a `precision`, arrotondato) — usato a `blur`/`writeValue`/opzioni cambiate. */
+    private _renderFinal;
+    private _formatFull;
+    private _captureCaretFromEnd;
+    private _restoreCaretFromEnd;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TmwNumericMaskDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TmwNumericMaskDirective, "[tmwNumericMask]", never, { "options": "options"; }, {}, never, never, true, never>;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "tmw-numeric",
+  "version": "0.1.1",
+  "description": "Masked numeric/currency input directive for Angular — no Material, no CDK, standalone, form-ready",
+  "author": {
+    "name": "EqProject"
+  },
+  "peerDependencies": {
+    "@angular/common": "^15.2.0",
+    "@angular/core": "^15.2.0",
+    "@angular/forms": "^15.2.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2015/tmw-numeric.mjs",
+  "es2020": "fesm2020/tmw-numeric.mjs",
+  "esm2020": "esm2020/tmw-numeric.mjs",
+  "fesm2020": "fesm2020/tmw-numeric.mjs",
+  "fesm2015": "fesm2015/tmw-numeric.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2020": "./esm2020/tmw-numeric.mjs",
+      "es2020": "./fesm2020/tmw-numeric.mjs",
+      "es2015": "./fesm2015/tmw-numeric.mjs",
+      "node": "./fesm2015/tmw-numeric.mjs",
+      "default": "./fesm2020/tmw-numeric.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/tmw-numeric-mask.directive';
+export * from './lib/models/tmw-numeric-options.model';