@gnggln/ng-ui-system 1.0.0-alpha.2 → 1.0.0-alpha.21

package/esm2022/form-builder-editor/lib/components/form-builder/directives/currency-input.directive.mjs

@@ -0,0 +1,184 @@
+import { Directive, HostListener, Input, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Direttiva per formattazione input valuta.
+ *
+ * Formatta il valore numerico con separatori italiani (1.234,56)
+ * e simbolo valuta opzionale. In fase di focus l'utente modifica
+ * il valore raw, al blur viene riformattato.
+ *
+ * Implementa `ControlValueAccessor` per integrazione con Reactive Forms.
+ *
+ * @selector [uiCurrencyInput]
+ *
+ * @example
+ * ```html
+ * <input uiCurrencyInput currencySymbol="EUR" [decimalPlaces]="2" />
+ * ```
+ */
+export class UiCurrencyInputDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        /** Simbolo valuta visualizzato. @default 'EUR' */
+        this.currencySymbol = 'EUR';
+        /** Numero di decimali. @default 2 */
+        this.decimalPlaces = 2;
+        this.rawValue = null;
+        this.onChange = () => { };
+        this.onTouched = () => { };
+        this.isFocused = false;
+    }
+    ngOnInit() {
+        this.renderer.setStyle(this.el.nativeElement, 'text-align', 'right');
+    }
+    // ── ControlValueAccessor ──
+    writeValue(value) {
+        this.rawValue = value != null ? Number(value) : null;
+        if (!this.isFocused) {
+            this.displayFormatted();
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);
+    }
+    // ── Gestione eventi ──
+    onFocus() {
+        this.isFocused = true;
+        this.renderer.setStyle(this.el.nativeElement, 'text-align', 'left');
+        // Mostra valore raw per editing
+        if (this.rawValue != null) {
+            this.el.nativeElement.value = this.rawValue.toString().replace('.', ',');
+        }
+        else {
+            this.el.nativeElement.value = '';
+        }
+    }
+    onBlur() {
+        this.isFocused = false;
+        this.onTouched();
+        this.parseInput();
+        this.displayFormatted();
+        this.renderer.setStyle(this.el.nativeElement, 'text-align', 'right');
+    }
+    onInput(value) {
+        // Permetti solo cifre, virgola e punto (come separatore decimale)
+        const sanitized = value.replace(/[^0-9,.\-]/g, '');
+        if (sanitized !== value) {
+            this.el.nativeElement.value = sanitized;
+        }
+    }
+    onKeyDown(event) {
+        const allowed = [
+            'Backspace',
+            'Delete',
+            'Tab',
+            'Escape',
+            'Enter',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowUp',
+            'ArrowDown',
+            'Home',
+            'End',
+        ];
+        if (allowed.includes(event.key))
+            return;
+        // Permetti Ctrl+A, Ctrl+C, Ctrl+V, Ctrl+X
+        if (event.ctrlKey || event.metaKey)
+            return;
+        // Permetti cifre
+        if (/^\d$/.test(event.key))
+            return;
+        // Permetti virgola e punto (un solo separatore decimale)
+        if ((event.key === ',' || event.key === '.') && !this.el.nativeElement.value.includes(',')) {
+            return;
+        }
+        // Permetti segno meno solo all'inizio
+        if (event.key === '-' && this.el.nativeElement.selectionStart === 0) {
+            return;
+        }
+        event.preventDefault();
+    }
+    // ── Utilita interne ──
+    parseInput() {
+        const input = this.el.nativeElement.value.trim();
+        if (!input) {
+            this.rawValue = null;
+            this.onChange(null);
+            return;
+        }
+        // Normalizza: rimuovi punti migliaia, sostituisci virgola con punto
+        const normalized = input.replace(/\./g, '').replace(',', '.');
+        const num = parseFloat(normalized);
+        if (isNaN(num)) {
+            this.rawValue = null;
+            this.onChange(null);
+        }
+        else {
+            this.rawValue = num;
+            this.onChange(num);
+        }
+    }
+    /** Mostra il valore formattato con separatori italiani e simbolo. */
+    displayFormatted() {
+        if (this.rawValue == null) {
+            this.el.nativeElement.value = '';
+            return;
+        }
+        const formatted = this.formatItalian(this.rawValue, this.decimalPlaces);
+        this.el.nativeElement.value = this.currencySymbol ? `${formatted} ${this.currencySymbol}` : formatted;
+    }
+    /** Formattazione italiana: 1.234,56 */
+    formatItalian(value, decimals) {
+        const parts = value.toFixed(decimals).split('.');
+        const intPart = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, '.'); // NOSONAR - Used on controlled number strings from toFixed(), low ReDoS risk
+        return decimals > 0 ? `${intPart},${parts[1]}` : intPart;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiCurrencyInputDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: UiCurrencyInputDirective, isStandalone: true, selector: "[uiCurrencyInput]", inputs: { currencySymbol: "currencySymbol", decimalPlaces: "decimalPlaces" }, host: { listeners: { "focus": "onFocus()", "blur": "onBlur()", "input": "onInput($event.target.value)", "keydown": "onKeyDown($event)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => UiCurrencyInputDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiCurrencyInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[uiCurrencyInput]',
+                    standalone: true,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => UiCurrencyInputDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { currencySymbol: [{
+                type: Input
+            }], decimalPlaces: [{
+                type: Input
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event.target.value']]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"currency-input.directive.js","sourceRoot":"","sources":["../../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/directives/currency-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostListener, Input, OnInit, Renderer2, forwardRef } from '@angular/core';\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\r\n\r\n/**\r\n * Direttiva per formattazione input valuta.\r\n *\r\n * Formatta il valore numerico con separatori italiani (1.234,56)\r\n * e simbolo valuta opzionale. In fase di focus l'utente modifica\r\n * il valore raw, al blur viene riformattato.\r\n *\r\n * Implementa `ControlValueAccessor` per integrazione con Reactive Forms.\r\n *\r\n * @selector [uiCurrencyInput]\r\n *\r\n * @example\r\n * ```html\r\n * <input uiCurrencyInput currencySymbol=\"EUR\" [decimalPlaces]=\"2\" />\r\n * ```\r\n */\r\n@Directive({\r\n  selector: '[uiCurrencyInput]',\r\n  standalone: true,\r\n  providers: [\r\n    {\r\n      provide: NG_VALUE_ACCESSOR,\r\n      useExisting: forwardRef(() => UiCurrencyInputDirective),\r\n      multi: true,\r\n    },\r\n  ],\r\n})\r\nexport class UiCurrencyInputDirective implements ControlValueAccessor, OnInit {\r\n  /** Simbolo valuta visualizzato. @default 'EUR' */\r\n  @Input() currencySymbol = 'EUR';\r\n\r\n  /** Numero di decimali. @default 2 */\r\n  @Input() decimalPlaces = 2;\r\n\r\n  private rawValue: number | null = null;\r\n  private onChange: (value: number | null) => void = () => {};\r\n  private onTouched: () => void = () => {};\r\n  private isFocused = false;\r\n\r\n  constructor(\r\n    private el: ElementRef<HTMLInputElement>,\r\n    private renderer: Renderer2,\r\n  ) {}\r\n\r\n  ngOnInit(): void {\r\n    this.renderer.setStyle(this.el.nativeElement, 'text-align', 'right');\r\n  }\r\n\r\n  // ── ControlValueAccessor ──\r\n\r\n  writeValue(value: any): void {\r\n    this.rawValue = value != null ? Number(value) : null;\r\n    if (!this.isFocused) {\r\n      this.displayFormatted();\r\n    }\r\n  }\r\n\r\n  registerOnChange(fn: any): void {\r\n    this.onChange = fn;\r\n  }\r\n  registerOnTouched(fn: any): void {\r\n    this.onTouched = fn;\r\n  }\r\n\r\n  setDisabledState(isDisabled: boolean): void {\r\n    this.renderer.setProperty(this.el.nativeElement, 'disabled', isDisabled);\r\n  }\r\n\r\n  // ── Gestione eventi ──\r\n\r\n  @HostListener('focus')\r\n  onFocus(): void {\r\n    this.isFocused = true;\r\n    this.renderer.setStyle(this.el.nativeElement, 'text-align', 'left');\r\n    // Mostra valore raw per editing\r\n    if (this.rawValue != null) {\r\n      this.el.nativeElement.value = this.rawValue.toString().replace('.', ',');\r\n    } else {\r\n      this.el.nativeElement.value = '';\r\n    }\r\n  }\r\n\r\n  @HostListener('blur')\r\n  onBlur(): void {\r\n    this.isFocused = false;\r\n    this.onTouched();\r\n    this.parseInput();\r\n    this.displayFormatted();\r\n    this.renderer.setStyle(this.el.nativeElement, 'text-align', 'right');\r\n  }\r\n\r\n  @HostListener('input', ['$event.target.value'])\r\n  onInput(value: string): void {\r\n    // Permetti solo cifre, virgola e punto (come separatore decimale)\r\n    const sanitized = value.replace(/[^0-9,.\\-]/g, '');\r\n    if (sanitized !== value) {\r\n      this.el.nativeElement.value = sanitized;\r\n    }\r\n  }\r\n\r\n  @HostListener('keydown', ['$event'])\r\n  onKeyDown(event: KeyboardEvent): void {\r\n    const allowed = [\r\n      'Backspace',\r\n      'Delete',\r\n      'Tab',\r\n      'Escape',\r\n      'Enter',\r\n      'ArrowLeft',\r\n      'ArrowRight',\r\n      'ArrowUp',\r\n      'ArrowDown',\r\n      'Home',\r\n      'End',\r\n    ];\r\n    if (allowed.includes(event.key)) return;\r\n\r\n    // Permetti Ctrl+A, Ctrl+C, Ctrl+V, Ctrl+X\r\n    if (event.ctrlKey || event.metaKey) return;\r\n\r\n    // Permetti cifre\r\n    if (/^\\d$/.test(event.key)) return;\r\n\r\n    // Permetti virgola e punto (un solo separatore decimale)\r\n    if ((event.key === ',' || event.key === '.') && !this.el.nativeElement.value.includes(',')) {\r\n      return;\r\n    }\r\n\r\n    // Permetti segno meno solo all'inizio\r\n    if (event.key === '-' && this.el.nativeElement.selectionStart === 0) {\r\n      return;\r\n    }\r\n\r\n    event.preventDefault();\r\n  }\r\n\r\n  // ── Utilita interne ──\r\n\r\n  private parseInput(): void {\r\n    const input = this.el.nativeElement.value.trim();\r\n    if (!input) {\r\n      this.rawValue = null;\r\n      this.onChange(null);\r\n      return;\r\n    }\r\n\r\n    // Normalizza: rimuovi punti migliaia, sostituisci virgola con punto\r\n    const normalized = input.replace(/\\./g, '').replace(',', '.');\r\n    const num = parseFloat(normalized);\r\n\r\n    if (isNaN(num)) {\r\n      this.rawValue = null;\r\n      this.onChange(null);\r\n    } else {\r\n      this.rawValue = num;\r\n      this.onChange(num);\r\n    }\r\n  }\r\n\r\n  /** Mostra il valore formattato con separatori italiani e simbolo. */\r\n  private displayFormatted(): void {\r\n    if (this.rawValue == null) {\r\n      this.el.nativeElement.value = '';\r\n      return;\r\n    }\r\n\r\n    const formatted = this.formatItalian(this.rawValue, this.decimalPlaces);\r\n    this.el.nativeElement.value = this.currencySymbol ? `${formatted} ${this.currencySymbol}` : formatted;\r\n  }\r\n\r\n  /** Formattazione italiana: 1.234,56 */\r\n  private formatItalian(value: number, decimals: number): string {\r\n    const parts = value.toFixed(decimals).split('.');\r\n    const intPart = parts[0].replace(/\\B(?=(\\d{3})+(?!\\d))/g, '.'); // NOSONAR - Used on controlled number strings from toFixed(), low ReDoS risk\r\n    return decimals > 0 ? `${intPart},${parts[1]}` : intPart;\r\n  }\r\n}\r\n"]}