tmw-numeric 0.1.1

package/AI_BUILD_PLAN.md

@@ -0,0 +1,127 @@
+# AI_BUILD_PLAN — tmw-numeric
+
+Sostituto di `@eqproject/eqp-numeric`, nato non da un'iniziativa dedicata come tmw-select/tmw-table/
+tmw-attachments, ma come tassello di un'indagine più ampia: rimozione sicura dei pacchetti
+`@eqproject/*` da TMED (v. `Tmed.Web/TmedClient/package.json`), tenendo solo `eqp-filters` e
+`eqp-dynamic-module` (quest'ultimo non rimovibile — è il motore dei form dinamici, non un widget).
+
+## Cosa sostituisce
+
+`EqpNumericDirective` (selettore `[eqpNumericMask]`) — **non** un componente, una direttiva
+`ControlValueAccessor` su `<input>` per la mascheratura di valori numerici/valuta (separatori
+migliaia/decimali, prefisso/suffisso, precisione, min/max, modalità di digitazione FINANCIAL/
+NATURAL). Documentata in `node_modules/@eqproject/eqp-numeric/README.md` (stessa forma/API di
+`ngx-currency`/`ng2-currency-mask`).
+
+## Audit uso reale in TMED (prima di scrivere una riga di codice)
+
+5 punti d'uso reali, tutti campi prezzo (fatturazione/ambulatori, **fuori** da `projects/tmed-therapy`
+— nessun impatto clinico/MDR):
+- `invoice-generate.component.html:64`
+- `add-outpatientclinics.component.html:562,1768,1776`
+- `create-invoice-fattureincloud.component.html:136`
+
+Tutti e 5 passano **lo stesso** `[options]="{ prefix: '€ ', thousands: '.', decimal: ',' }"` (formato
+euro) — nessuno usa i default nudi del pacchetto (`$`/`,`/`.`) né chiama `EqpNumericModule.forRoot()`.
+Wiring in `src/modules/shared.module.ts` (import + `imports`/`exports` di `SharedModule`).
+
+## Decisioni
+
+1. **Direttiva standalone**, stesso principio delle altre `tmw-*` (niente `TmwNumericModule`,
+   si importa `TmwNumericMaskDirective` direttamente).
+2. **Selettore** `[tmwNumericMask]` (rename `eqpNumericMask`→`tmwNumericMask`, stesso principio
+   `eqp-xxx`→`tmw-xxx` delle altre). **`[options]` e i nomi delle sue proprietà (`align`,
+   `allowNegative`, `decimal`, `precision`, `prefix`, `suffix`, `thousands`, `nullable`, `min`,
+   `max`, `inputMode`) restano INVARIATI** — compatibilità byte-per-byte con i binding esistenti,
+   il rename tocca solo l'attributo/selettore.
+3. **Nessun `forRoot()`**: nessun consumer reale lo usava, i default (`TMW_NUMERIC_DEFAULT_OPTIONS`)
+   bastano com'erano nell'originale.
+4. **`TmwNumericInputMode`** (rename `EqpNumericInputMode`) con gli stessi due valori
+   `FINANCIAL`/`NATURAL` e comportamento identico.
+
+## Bug scoperti e corretti durante la verifica funzionale (Playwright, non solo tsc)
+
+La prima bozza (formattazione a piena precisione ad ogni tasto anche in modalità NATURAL) si è
+rivelata **rotta digitando davvero** (verificato con `page.type()`, non solo lettura del codice):
+
+1. **Cifre perse durante la digitazione (NATURAL)**: arrotondare/paddare a `precision` ad OGNI
+   `input` event faceva sì che digitare `"1"` su un campo vuoto producesse subito `"$ 0.00"` —
+   la cifra veniva arrotondata via prima ancora di poter comporre un numero. Fix: formattazione
+   **live** durante la digitazione (nessun padding/arrotondamento, si preservano le cifre esatte
+   digitate, capped a `precision` cifre decimali) e formattazione **piena** (padding/arrotondamento
+   `toFixed`) solo a `blur`/`writeValue`/cambio opzioni. La modalità FINANCIAL non soffriva di
+   questo bug (si ricalcola sempre da zero dalle sole cifre, insensibile alla formattazione
+   precedente) — lì il formato pieno ad ogni tasto è corretto fin da subito.
+2. **Segno negativo mai riconosciuto**: `rawValue.startsWith('-')` non funziona MAI, perché il
+   segno digitato dall'utente finisce sempre DOPO un eventuale prefisso (es. `"$ -5"`, non
+   `"-$ 5"` nella stringa grezza del campo) — il controllo iniziale falliva sempre silenziosamente.
+   Fix: `rawValue.includes('-')`.
+
+Entrambi scoperti SOLO grazie a un test funzionale che digita davvero nel campo (Playwright
+`page.locator(...).type(...)`) — una verifica solo statica/tsc non li avrebbe mai presi.
+
+## Verifica
+
+Playground `test-tmw-numeric` in `tmw-suite` (route `/tmw-numeric`, 3 casi: default TMED — euro,
+virgola decimale, punto migliaia, no `[options]` custom oltre a quello reale —, custom con
+`nullable`+`allowNegative:false`, FINANCIAL). Verificato via Playwright headless (Chromium 1228 già
+installato in TMED, non serve emulazione mobile qui): digitazione carattere per carattere,
+`fill('')`+`type(...)`+`blur()`, controllo sia del valore visualizzato sia del model (`ngModel`)
+sottostante. Tutti i casi passano dopo il fix, incluso il caso reale esatto usato in TMED (prefisso
+`€ `, migliaia `.`, decimale `,`). Zero errori console.
+
+## Sync in TMED
+
+`tmw-numeric` 0.1.0, build produzione, `npm pack` → tarball locale (non pubblicato su npm reale,
+a differenza di tmw-attachments — l'utente non l'ha richiesto per questo pacchetto, resta per
+quando lo chiederà a parte, stesso principio di tmw-table/tmw-select prima della pubblicazione).
+`TmedClient/package.json`: rimosso `@eqproject/eqp-numeric`, aggiunto `tmw-numeric` (tarball).
+`shared.module.ts`: `EqpNumericModule`→`TmwNumericMaskDirective`. 5 template: `eqpNumericMask`→
+`tmwNumericMask` (`[options]` invariato). `tsc --noEmit --skipLibCheck`: 27 errori pre-esistenti
+invariati, zero nuovi. `ng serve` (heap 16GB, v. `project_ng_serve_perf` in memoria — necessario,
+altrimenti OOM) pulito, `Compiled successfully`.
+
+**Non verificato dal vivo in TMED** (stesso limite onesto di altre sincronizzazioni): nessuna
+credenziale e2e reale disponibile in questa sessione (`e2e/.auth/credentials.json` assente) — la
+verifica del comportamento REALE nei 5 campi prezzo si basa su tsc pulito + AOT compile pulito +
+verifica funzionale esaustiva nel playground con la STESSA identica configurazione `[options]`
+usata in produzione (prefisso `€ `, migliaia `.`, decimale `,`), non su un click reale in TMED.
+
+## Round mobile/tablet (2026-07-15, stessa giornata) — v0.1.0 → v0.1.1
+
+L'utente ha chiesto esplicitamente se il componente fosse pensato per mobile/tablet — risposta
+onesta: non ancora. Analisi e fix:
+
+1. **Nessun hint di tastiera numerica**: un `<input>` senza `type`/`inputmode` mostra la tastiera
+   alfanumerica completa su mobile/tablet — sbagliato per un campo numerico, e nessuno dei 5 usi
+   reali in TMED imposta `type`/`inputmode` proprio. Fix: la direttiva imposta
+   `inputmode="decimal"` nel costruttore, MA SOLO se il consumer non ha già messo un proprio
+   `type`/`inputmode` nel template (nessun conflitto, nessun binding Angular duplicato sullo
+   stesso attributo).
+
+2. **Bug reale scoperto testando su viewport mobile con tastiera touch**: le tastiere numeriche
+   mobile mostrano quasi sempre "." come tasto decimale, a prescindere dalla configurazione locale
+   — un primo fix ("accetta sia il separatore configurato sia `.` come decimale") si è rivelato
+   **rotto per la configurazione ESATTA usata in produzione** (`thousands: '.'`, `decimal: ','` —
+   formato euro): il punto delle migliaia già inserito dal render "live" veniva confuso con il
+   punto decimale appena digitato (entrambi lo stesso carattere), producendo un parsing
+   completamente sbagliato (digitare `"1234.5"` risultava in `"€ 1,23"` invece di
+   `"€ 1.234,50"`). **Fix corretto**: stato persistente `_hasDecimalState`, impostato SOLO quando
+   `event.data` (il carattere/testo appena digitato/incollato, non l'intera stringa già
+   formattata) corrisponde al separatore decimale configurato o a `'.'` — una volta noto che un
+   separatore decimale esiste, si cerca la sua ULTIMA occorrenza nella stringa (le migliaia, anche
+   quando coincidono con `'.'`, possono comparire SOLO prima del separatore decimale reale, mai
+   dopo — la formattazione non raggruppa mai le cifre decimali). Gestito anche il caso di
+   backspace sul separatore (torna correttamente a "nessun decimale", verificato: cancellare la
+   virgola e digitare una cifra la rimette nella parte intera, non in quella decimale).
+
+**Cosa NON serviva**: nessun CSS responsive/breakpoint — la direttiva non possiede overlay/modali/
+dropdown propri (a differenza di tmw-attachments/tmw-select/tmw-table), è un attributo su un
+`<input>` che il consumer stila autonomamente; non c'è "chrome" della libreria che possa rompersi
+su schermi piccoli.
+
+**Verifica**: Playwright con device emulation (`iPhone 13`, `hasTouch:true`) — confermato
+`inputmode="decimal"` presente, digitazione carattere per carattere del formato euro reale
+(`"1234.5"` e `"1234,5"`) entrambe producono `"€ 1.234,50"` / modello `1234.5`, backspace sul
+separatore verificato, zero errori console. Bump a v0.1.1, tarball rigenerata, risincronizzata in
+TMED (`tsc` pulito, 27 errori pre-esistenti invariati).

package/esm2020/lib/models/tmw-numeric-options.model.mjs

@@ -0,0 +1,37 @@
+/**
+ * Modalità di digitazione — nomi/valori/comportamento invariati rispetto a
+ * `@eqproject/eqp-numeric` (`EqpNumericInputMode`), per parità di comportamento.
+ */
+export 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).
+ */
+export const TMW_NUMERIC_DEFAULT_OPTIONS = {
+    align: 'right',
+    allowNegative: true,
+    decimal: '.',
+    precision: 2,
+    prefix: '$ ',
+    suffix: '',
+    thousands: ',',
+    nullable: false,
+    min: undefined,
+    max: undefined,
+    inputMode: TmwNumericInputMode.NATURAL,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/tmw-numeric-mask.directive.mjs

@@ -0,0 +1,272 @@
+import { Directive, HostListener, Input, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { TMW_NUMERIC_DEFAULT_OPTIONS, TmwNumericInputMode } 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 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']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tmw-numeric-mask.directive.js","sourceRoot":"","sources":["../../../../projects/tmw-numeric/src/lib/tmw-numeric-mask.directive.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,6 @@
+/*
+ * Public API Surface of tmw-numeric
+ */
+export * from './lib/tmw-numeric-mask.directive';
+export * from './lib/models/tmw-numeric-options.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3Rtdy1udW1lcmljL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLHdDQUF3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiB0bXctbnVtZXJpY1xuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3Rtdy1udW1lcmljLW1hc2suZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscy90bXctbnVtZXJpYy1vcHRpb25zLm1vZGVsJztcbiJdfQ==

package/esm2020/tmw-numeric.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG13LW51bWVyaWMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy90bXctbnVtZXJpYy9zcmMvdG13LW51bWVyaWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==