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

package/esm2022/lib/components/form-builder/index.mjs

@@ -1,19 +1,24 @@
 // ── Componenti ──
-export { UiFormBuilderComponent, UiFormErrorStateMatcher } from './form-builder.component';
+export { UiFormBuilderComponent } from './form-builder.component';
+export { UiFormErrorStateMatcher } from './services/form-error-state.matcher';
 export { UiFormWizardComponent } from './form-wizard.component';
 export { UiFormErrorSummaryComponent } from './sub-components/error-summary/form-error-summary.component';
 export { UiFileInputComponent } from './sub-components/file-input/file-input.component';
 export { UiSpecificaTerritorialeComponent } from './sub-components/specifica-territoriale/specifica-territoriale.component';
 export { UiTableTerritorialeComponent } from './sub-components/table-territoriale/table-territoriale.component';
+export { UiLocationGeocodedComponent } from './sub-components/location-geocoded/location-geocoded.component';
+export { UiFormTextFieldComponent, UiFormTextareaFieldComponent, UiFormNumberFieldComponent, UiFormSelectFieldComponent, UiFormRadioFieldComponent } from './sub-components/form-fields/index';
 // ── Servizi ──
 export { UiFormConditionService } from './services/form-condition.service';
 export { UiFormValidationService } from './services/form-validation.service';
+export { UiFormFieldErrorService } from './services/form-field-error.service';
 export { UiLocationService, } from './services/location.service';
 export { UiWizardSyncService, } from './services/wizard-sync.service';
+export { UiNominatimGeocodingService } from './services/nominatim-geocoding.service';
 // ── Direttive ──
 export { UiCurrencyInputDirective } from './directives/currency-input.directive';
 // ── Adapter e formati data ──
 export { UiItalianDateAdapter, UI_IT_DATE_FORMATS } from './adapters/it-date-adapter';
 // ── Tipi ──
 export * from './types/index';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-builder/services/form-error-state.matcher.mjs

@@ -0,0 +1,10 @@
+/**
+ * ErrorStateMatcher condiviso tra form-builder e campi atomici.
+ * Mostra errore quando il controllo è invalido e (touched o dirty).
+ */
+export class UiFormErrorStateMatcher {
+    isErrorState(control, _form) {
+        return !!(control && control.invalid && (control.touched || control.dirty));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1lcnJvci1zdGF0ZS5tYXRjaGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctdWktc3lzdGVtL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWJ1aWxkZXIvc2VydmljZXMvZm9ybS1lcnJvci1zdGF0ZS5tYXRjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7R0FHRztBQUNILE1BQU0sT0FBTyx1QkFBdUI7SUFDbEMsWUFBWSxDQUFDLE9BQTJCLEVBQUUsS0FBeUM7UUFDakYsT0FBTyxDQUFDLENBQUMsQ0FBQyxPQUFPLElBQUksT0FBTyxDQUFDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLElBQUksT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDOUUsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybUNvbnRyb2wsIEZvcm1Hcm91cERpcmVjdGl2ZSwgTmdGb3JtIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQgeyBFcnJvclN0YXRlTWF0Y2hlciB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2NvcmUnO1xyXG5cclxuLyoqXHJcbiAqIEVycm9yU3RhdGVNYXRjaGVyIGNvbmRpdmlzbyB0cmEgZm9ybS1idWlsZGVyIGUgY2FtcGkgYXRvbWljaS5cclxuICogTW9zdHJhIGVycm9yZSBxdWFuZG8gaWwgY29udHJvbGxvIMOoIGludmFsaWRvIGUgKHRvdWNoZWQgbyBkaXJ0eSkuXHJcbiAqL1xyXG5leHBvcnQgY2xhc3MgVWlGb3JtRXJyb3JTdGF0ZU1hdGNoZXIgaW1wbGVtZW50cyBFcnJvclN0YXRlTWF0Y2hlciB7XHJcbiAgaXNFcnJvclN0YXRlKGNvbnRyb2w6IEZvcm1Db250cm9sIHwgbnVsbCwgX2Zvcm06IEZvcm1Hcm91cERpcmVjdGl2ZSB8IE5nRm9ybSB8IG51bGwpOiBib29sZWFuIHtcclxuICAgIHJldHVybiAhIShjb250cm9sICYmIGNvbnRyb2wuaW52YWxpZCAmJiAoY29udHJvbC50b3VjaGVkIHx8IGNvbnRyb2wuZGlydHkpKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/lib/components/form-builder/services/form-field-error.service.mjs

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Servizio condiviso per messaggi di errore, visibilità errori e conteggio caratteri
+ * dei campi form-builder e dei componenti atomici standalone.
+ */
+export class UiFormFieldErrorService {
+    /**
+     * Restituisce i messaggi di errore user-facing per un controllo.
+     *
+     * @param control Controllo Angular del campo
+     * @param rules Regole di validazione dichiarative (messaggi custom dallo schema)
+     */
+    getFieldErrors(control, rules = []) {
+        if (!control?.errors)
+            return [];
+        const messages = [];
+        for (const [errorKey, errorValue] of Object.entries(control.errors)) {
+            const rule = rules.find((r) => this.normalizeValidationKey(r.type) === errorKey ||
+                (r.type === 'crossField' && errorKey === 'crossField'));
+            if (rule?.message) {
+                messages.push(rule.message);
+            }
+            else {
+                messages.push(this.getDefaultErrorMessage(errorKey, errorValue));
+            }
+        }
+        return messages;
+    }
+    /**
+     * Indica se mostrare gli errori per un controllo (invalid + touched/dirty/prevalorizzato).
+     */
+    shouldShowFieldErrors(control, options = {}) {
+        if (!control)
+            return false;
+        return (control.invalid &&
+            (control.dirty || control.touched || options.treatAsPrevalorized === true));
+    }
+    /**
+     * Conteggio caratteri corrente/massimo per campi text/textarea con maxLength.
+     */
+    getCharCount(control, maxLength) {
+        if (maxLength == null || maxLength <= 0)
+            return null;
+        const current = String(control?.value ?? '').length;
+        return { current, max: maxLength };
+    }
+    /** Estrae maxLength dalle regole schema. */
+    resolveMaxLength(rules = []) {
+        const rule = rules.find((r) => r.type === 'maxLength');
+        return rule?.value != null ? Number(rule.value) : undefined;
+    }
+    normalizeValidationKey(schemaType) {
+        const keyMap = {
+            minLength: 'minlength',
+            maxLength: 'maxlength',
+        };
+        return keyMap[schemaType] || schemaType;
+    }
+    getDefaultErrorMessage(errorKey, errorValue) {
+        if (typeof errorValue === 'string') {
+            return errorValue;
+        }
+        const ev = errorValue;
+        switch (errorKey) {
+            case 'required':
+                return 'Campo obbligatorio';
+            case 'email':
+                return 'Formato email non valido';
+            case 'min':
+                return `Valore minimo: ${ev?.['min']}`;
+            case 'max':
+                return `Valore massimo: ${ev?.['max']}`;
+            case 'minlength':
+                return `Lunghezza minima: ${ev?.['requiredLength']} caratteri`;
+            case 'maxlength':
+                return `Lunghezza massima: ${ev?.['requiredLength']} caratteri`;
+            case 'pattern':
+                return 'Formato non valido';
+            case 'crossField':
+                return 'Valore non coerente con il campo correlato';
+            case 'date-min':
+                return ev?.['message'] || 'Data troppo remota';
+            case 'date-max':
+                return ev?.['message'] || 'Data troppo avanzata';
+            case 'fileSize':
+                return `Dimensione massima: ${ev?.['maxSizeFormatted']}`;
+            case 'fileType':
+                return 'Formato file non accettato';
+            case 'fileCount':
+                return `Massimo ${ev?.['maxCount']} file`;
+            default:
+                return 'Valore non valido';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormFieldErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormFieldErrorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiFormFieldErrorService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-field-error.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/form-field-error.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { AbstractControl } from '@angular/forms';\r\nimport { UiValidationRule } from '../types/validation.types';\r\n\r\n/** Opzioni per la visibilità degli errori di un campo. */\r\nexport interface UiFieldErrorDisplayOptions {\r\n  /** Tratta il campo come prevalorizzato (mostra errori anche senza touched). */\r\n  treatAsPrevalorized?: boolean;\r\n}\r\n\r\n/**\r\n * Servizio condiviso per messaggi di errore, visibilità errori e conteggio caratteri\r\n * dei campi form-builder e dei componenti atomici standalone.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiFormFieldErrorService {\r\n  /**\r\n   * Restituisce i messaggi di errore user-facing per un controllo.\r\n   *\r\n   * @param control Controllo Angular del campo\r\n   * @param rules Regole di validazione dichiarative (messaggi custom dallo schema)\r\n   */\r\n  getFieldErrors(control: AbstractControl | null, rules: UiValidationRule[] = []): string[] {\r\n    if (!control?.errors) return [];\r\n\r\n    const messages: string[] = [];\r\n    for (const [errorKey, errorValue] of Object.entries(control.errors)) {\r\n      const rule = rules.find(\r\n        (r) =>\r\n          this.normalizeValidationKey(r.type) === errorKey ||\r\n          (r.type === 'crossField' && errorKey === 'crossField'),\r\n      );\r\n      if (rule?.message) {\r\n        messages.push(rule.message);\r\n      } else {\r\n        messages.push(this.getDefaultErrorMessage(errorKey, errorValue));\r\n      }\r\n    }\r\n    return messages;\r\n  }\r\n\r\n  /**\r\n   * Indica se mostrare gli errori per un controllo (invalid + touched/dirty/prevalorizzato).\r\n   */\r\n  shouldShowFieldErrors(\r\n    control: AbstractControl | null,\r\n    options: UiFieldErrorDisplayOptions = {},\r\n  ): boolean {\r\n    if (!control) return false;\r\n    return (\r\n      control.invalid &&\r\n      (control.dirty || control.touched || options.treatAsPrevalorized === true)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Conteggio caratteri corrente/massimo per campi text/textarea con maxLength.\r\n   */\r\n  getCharCount(\r\n    control: AbstractControl | null,\r\n    maxLength?: number,\r\n  ): { current: number; max: number } | null {\r\n    if (maxLength == null || maxLength <= 0) return null;\r\n    const current = String(control?.value ?? '').length;\r\n    return { current, max: maxLength };\r\n  }\r\n\r\n  /** Estrae maxLength dalle regole schema. */\r\n  resolveMaxLength(rules: UiValidationRule[] = []): number | undefined {\r\n    const rule = rules.find((r) => r.type === 'maxLength');\r\n    return rule?.value != null ? Number(rule.value) : undefined;\r\n  }\r\n\r\n  private normalizeValidationKey(schemaType: string): string {\r\n    const keyMap: Record<string, string> = {\r\n      minLength: 'minlength',\r\n      maxLength: 'maxlength',\r\n    };\r\n    return keyMap[schemaType] || schemaType;\r\n  }\r\n\r\n  private getDefaultErrorMessage(errorKey: string, errorValue: unknown): string {\r\n    if (typeof errorValue === 'string') {\r\n      return errorValue;\r\n    }\r\n\r\n    const ev = errorValue as Record<string, unknown> | null | undefined;\r\n\r\n    switch (errorKey) {\r\n      case 'required':\r\n        return 'Campo obbligatorio';\r\n      case 'email':\r\n        return 'Formato email non valido';\r\n      case 'min':\r\n        return `Valore minimo: ${ev?.['min']}`;\r\n      case 'max':\r\n        return `Valore massimo: ${ev?.['max']}`;\r\n      case 'minlength':\r\n        return `Lunghezza minima: ${ev?.['requiredLength']} caratteri`;\r\n      case 'maxlength':\r\n        return `Lunghezza massima: ${ev?.['requiredLength']} caratteri`;\r\n      case 'pattern':\r\n        return 'Formato non valido';\r\n      case 'crossField':\r\n        return 'Valore non coerente con il campo correlato';\r\n      case 'date-min':\r\n        return (ev?.['message'] as string) || 'Data troppo remota';\r\n      case 'date-max':\r\n        return (ev?.['message'] as string) || 'Data troppo avanzata';\r\n      case 'fileSize':\r\n        return `Dimensione massima: ${ev?.['maxSizeFormatted']}`;\r\n      case 'fileType':\r\n        return 'Formato file non accettato';\r\n      case 'fileCount':\r\n        return `Massimo ${ev?.['maxCount']} file`;\r\n      default:\r\n        return 'Valore non valido';\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/components/form-builder/services/location.service.mjs

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core';
-import * as nazioniData from '../../../sources/nazioni.opt.json';
 import * as locationData from '../../../sources/location-data.opt.json';
+import * as nazioniData from '../../../sources/nazioni.opt.json';
 import * as i0 from "@angular/core";
 /**
  * Servizio per la gestione dei dati geografici italiani
@@ -74,11 +74,12 @@ export class UiLocationService {
                 return this.nazioniCache.get(id) ?? null;
             case 'provincia':
                 return this.provinceCache.get(id) ?? null;
-            case 'comune':
+            case 'comune': {
                 if (!provinciaId)
                     return this.comuniCache.get(id) ?? null;
                 const comuni = await this.getComuniByProvincia(provinciaId);
                 return comuni.find((c) => c.codiceComunePk === id) ?? null;
+            }
             default:
                 return null;
         }
@@ -137,4 +138,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"location.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/location.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport * as nazioniData from '../../../sources/nazioni.opt.json';\r\nimport * as locationData from '../../../sources/location-data.opt.json';\r\n\r\n// ─── Interfacce JSON ottimizzate ──────────────────────────────────\r\n\r\n/** Voce nazione nel JSON ottimizzato. */\r\nexport interface MinifiedNazioneOption {\r\n  /** Codice nazione (es. `'ITA'`). */\r\n  x: string;\r\n  /** Descrizione (es. `'Italia'`). */\r\n  d: string;\r\n}\r\n\r\n/** Voce provincia/comune nel JSON ottimizzato. */\r\nexport interface MinifiedSelectOption {\r\n  /** Codice (provincia o comune). */\r\n  x: string;\r\n  /** Descrizione. */\r\n  d: string;\r\n  /** CAP singolo o multipli. */\r\n  c?: string | string[];\r\n}\r\n\r\ninterface MinifiedLocationMap {\r\n  province: MinifiedSelectOption[];\r\n  comuniPerProvincia: Record<string, MinifiedSelectOption[]>;\r\n}\r\n\r\ninterface MinifiedNazioniMap {\r\n  nazioni: MinifiedNazioneOption[];\r\n}\r\n\r\n// ─── Interfacce pubbliche (formato legacy compatibile) ───────────\r\n\r\n/** Nazione. */\r\nexport interface UiNazione {\r\n  codStatoPk: string;\r\n  codiceCatastale: string;\r\n  descrizione: string;\r\n}\r\n\r\n/** Provincia. */\r\nexport interface UiProvincia {\r\n  codiceProvinciaPk: string;\r\n  nomeProvincia: string;\r\n  siglaProvincia: string;\r\n  visibile: boolean;\r\n}\r\n\r\n/** Comune. */\r\nexport interface UiComune {\r\n  codiceCatastale: string;\r\n  codiceComunePk: string;\r\n  comuneSoppresso: boolean;\r\n  nomeComune: string;\r\n  prov: UiProvincia;\r\n  visibile: boolean;\r\n}\r\n\r\n/**\r\n * Servizio per la gestione dei dati geografici italiani\r\n * da file JSON statici ottimizzati.\r\n *\r\n * Elimina la necessita di chiamate backend per nazioni,\r\n * province, comuni e CAP. I dati vengono caricati in memoria\r\n * al primo accesso e poi serviti dalla cache.\r\n *\r\n * @providedIn 'root'\r\n *\r\n * @example\r\n * ```typescript\r\n * const nazioni = await this.locationService.getNazioni();\r\n * const province = await this.locationService.getProvince();\r\n * const comuni = await this.locationService.getComuniByProvincia('015');\r\n * const caps = await this.locationService.getCapList('015146');\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiLocationService {\r\n  private readonly nazioniMap: MinifiedNazioniMap;\r\n  private readonly locationMap: MinifiedLocationMap;\r\n  private readonly nazioniCache = new Map<string, UiNazione>();\r\n  private readonly provinceCache = new Map<string, UiProvincia>();\r\n  private readonly comuniCache = new Map<string, UiComune>();\r\n\r\n  constructor() {\r\n    this.nazioniMap = nazioniData as MinifiedNazioniMap;\r\n    this.locationMap = locationData as any;\r\n    this.initializeCaches();\r\n  }\r\n\r\n  // ─── API pubblica ──────────────────────────────────────────────\r\n\r\n  /** Elenco completo delle nazioni (Italia prima). */\r\n  async getNazioni(): Promise<{ data: UiNazione[] }> {\r\n    const nazioni = Array.from(this.nazioniCache.values());\r\n    return { data: this.sortNazioniItaliaFirst(nazioni) };\r\n  }\r\n\r\n  /** Elenco completo delle province, ordinate alfabeticamente. */\r\n  async getProvince(): Promise<{ content: UiProvincia[] }> {\r\n    const province = Array.from(this.provinceCache.values()).sort((a, b) =>\r\n      a.nomeProvincia.localeCompare(b.nomeProvincia, 'it'),\r\n    );\r\n    return { content: province };\r\n  }\r\n\r\n  /** Elenco dei comuni per una specifica provincia. */\r\n  async getComuniByProvincia(provinciaId: string): Promise<UiComune[]> {\r\n    const comuniMin = this.locationMap.comuniPerProvincia[provinciaId] || [];\r\n    const provincia = this.provinceCache.get(provinciaId);\r\n    if (!provincia) return [];\r\n\r\n    return comuniMin\r\n      .map((c) => ({\r\n        codiceCatastale: c.x,\r\n        codiceComunePk: c.x,\r\n        comuneSoppresso: false,\r\n        nomeComune: c.d,\r\n        prov: provincia,\r\n        visibile: true,\r\n      }))\r\n      .sort((a, b) => a.nomeComune.localeCompare(b.nomeComune, 'it'));\r\n  }\r\n\r\n  /** Elenco dei CAP per un comune. */\r\n  async getCapList(comuneId: string): Promise<string[]> {\r\n    for (const comuni of Object.values(this.locationMap.comuniPerProvincia)) {\r\n      const comune = comuni.find((c) => c.x === comuneId);\r\n      if (comune?.c) {\r\n        return Array.isArray(comune.c) ? comune.c : [comune.c];\r\n      }\r\n    }\r\n    return [];\r\n  }\r\n\r\n  /** Dati completi di una location (nazione, provincia o comune). */\r\n  async getLocationFullData(\r\n    type: 'nazione' | 'provincia' | 'comune',\r\n    id: string,\r\n    provinciaId?: string,\r\n  ): Promise<UiNazione | UiProvincia | UiComune | null> {\r\n    switch (type) {\r\n      case 'nazione':\r\n        return this.nazioniCache.get(id) ?? null;\r\n      case 'provincia':\r\n        return this.provinceCache.get(id) ?? null;\r\n      case 'comune':\r\n        if (!provinciaId) return this.comuniCache.get(id) ?? null;\r\n        const comuni = await this.getComuniByProvincia(provinciaId);\r\n        return comuni.find((c) => c.codiceComunePk === id) ?? null;\r\n      default:\r\n        return null;\r\n    }\r\n  }\r\n\r\n  // ─── Inizializzazione cache ────────────────────────────────────\r\n\r\n  private initializeCaches(): void {\r\n    // Nazioni\r\n    for (const n of this.nazioniMap.nazioni) {\r\n      this.nazioniCache.set(n.x, {\r\n        codStatoPk: n.x,\r\n        codiceCatastale: n.x,\r\n        descrizione: n.d,\r\n      });\r\n    }\r\n\r\n    // Province\r\n    for (const p of this.locationMap.province) {\r\n      this.provinceCache.set(p.x, {\r\n        codiceProvinciaPk: p.x,\r\n        nomeProvincia: p.d,\r\n        siglaProvincia: p.x,\r\n        visibile: true,\r\n      });\r\n    }\r\n\r\n    // Comuni (con riferimento alla provincia)\r\n    for (const [provinciaId, comuni] of Object.entries(this.locationMap.comuniPerProvincia)) {\r\n      const provincia = this.provinceCache.get(provinciaId);\r\n      if (!provincia) continue;\r\n      for (const c of comuni) {\r\n        this.comuniCache.set(c.x, {\r\n          codiceCatastale: c.x,\r\n          codiceComunePk: c.x,\r\n          comuneSoppresso: false,\r\n          nomeComune: c.d,\r\n          prov: provincia,\r\n          visibile: true,\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  private sortNazioniItaliaFirst(nazioni: UiNazione[]): UiNazione[] {\r\n    return nazioni.sort((a, b) => {\r\n      const aItalia = a.descrizione?.toLowerCase().includes('italia') || a.codStatoPk === 'ITA';\r\n      const bItalia = b.descrizione?.toLowerCase().includes('italia') || b.codStatoPk === 'ITA';\r\n      if (aItalia && !bItalia) return -1;\r\n      if (!aItalia && bItalia) return 1;\r\n      return (a.descrizione || '').localeCompare(b.descrizione || '', 'it', { sensitivity: 'base' });\r\n    });\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"location.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/location.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport * as locationData from '../../../sources/location-data.opt.json';\r\nimport * as nazioniData from '../../../sources/nazioni.opt.json';\r\n\r\n// ─── Interfacce JSON ottimizzate ──────────────────────────────────\r\n\r\n/** Voce nazione nel JSON ottimizzato. */\r\nexport interface MinifiedNazioneOption {\r\n  /** Codice nazione (es. `'ITA'`). */\r\n  x: string;\r\n  /** Descrizione (es. `'Italia'`). */\r\n  d: string;\r\n}\r\n\r\n/** Voce provincia/comune nel JSON ottimizzato. */\r\nexport interface MinifiedSelectOption {\r\n  /** Codice (provincia o comune). */\r\n  x: string;\r\n  /** Descrizione. */\r\n  d: string;\r\n  /** CAP singolo o multipli. */\r\n  c?: string | string[];\r\n}\r\n\r\ninterface MinifiedLocationMap {\r\n  province: MinifiedSelectOption[];\r\n  comuniPerProvincia: Record<string, MinifiedSelectOption[]>;\r\n}\r\n\r\ninterface MinifiedNazioniMap {\r\n  nazioni: MinifiedNazioneOption[];\r\n}\r\n\r\n// ─── Interfacce pubbliche (formato legacy compatibile) ───────────\r\n\r\n/** Nazione. */\r\nexport interface UiNazione {\r\n  codStatoPk: string;\r\n  codiceCatastale: string;\r\n  descrizione: string;\r\n}\r\n\r\n/** Provincia. */\r\nexport interface UiProvincia {\r\n  codiceProvinciaPk: string;\r\n  nomeProvincia: string;\r\n  siglaProvincia: string;\r\n  visibile: boolean;\r\n}\r\n\r\n/** Comune. */\r\nexport interface UiComune {\r\n  codiceCatastale: string;\r\n  codiceComunePk: string;\r\n  comuneSoppresso: boolean;\r\n  nomeComune: string;\r\n  prov: UiProvincia;\r\n  visibile: boolean;\r\n}\r\n\r\n/**\r\n * Servizio per la gestione dei dati geografici italiani\r\n * da file JSON statici ottimizzati.\r\n *\r\n * Elimina la necessita di chiamate backend per nazioni,\r\n * province, comuni e CAP. I dati vengono caricati in memoria\r\n * al primo accesso e poi serviti dalla cache.\r\n *\r\n * @providedIn 'root'\r\n *\r\n * @example\r\n * ```typescript\r\n * const nazioni = await this.locationService.getNazioni();\r\n * const province = await this.locationService.getProvince();\r\n * const comuni = await this.locationService.getComuniByProvincia('015');\r\n * const caps = await this.locationService.getCapList('015146');\r\n * ```\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiLocationService {\r\n  private readonly nazioniMap: MinifiedNazioniMap;\r\n  private readonly locationMap: MinifiedLocationMap;\r\n  private readonly nazioniCache = new Map<string, UiNazione>();\r\n  private readonly provinceCache = new Map<string, UiProvincia>();\r\n  private readonly comuniCache = new Map<string, UiComune>();\r\n\r\n  constructor() {\r\n    this.nazioniMap = nazioniData as MinifiedNazioniMap;\r\n    this.locationMap = locationData as any;\r\n    this.initializeCaches();\r\n  }\r\n\r\n  // ─── API pubblica ──────────────────────────────────────────────\r\n\r\n  /** Elenco completo delle nazioni (Italia prima). */\r\n  async getNazioni(): Promise<{ data: UiNazione[] }> {\r\n    const nazioni = Array.from(this.nazioniCache.values());\r\n    return { data: this.sortNazioniItaliaFirst(nazioni) };\r\n  }\r\n\r\n  /** Elenco completo delle province, ordinate alfabeticamente. */\r\n  async getProvince(): Promise<{ content: UiProvincia[] }> {\r\n    const province = Array.from(this.provinceCache.values()).sort((a, b) =>\r\n      a.nomeProvincia.localeCompare(b.nomeProvincia, 'it'),\r\n    );\r\n    return { content: province };\r\n  }\r\n\r\n  /** Elenco dei comuni per una specifica provincia. */\r\n  async getComuniByProvincia(provinciaId: string): Promise<UiComune[]> {\r\n    const comuniMin = this.locationMap.comuniPerProvincia[provinciaId] || [];\r\n    const provincia = this.provinceCache.get(provinciaId);\r\n    if (!provincia) return [];\r\n\r\n    return comuniMin\r\n      .map((c) => ({\r\n        codiceCatastale: c.x,\r\n        codiceComunePk: c.x,\r\n        comuneSoppresso: false,\r\n        nomeComune: c.d,\r\n        prov: provincia,\r\n        visibile: true,\r\n      }))\r\n      .sort((a, b) => a.nomeComune.localeCompare(b.nomeComune, 'it'));\r\n  }\r\n\r\n  /** Elenco dei CAP per un comune. */\r\n  async getCapList(comuneId: string): Promise<string[]> {\r\n    for (const comuni of Object.values(this.locationMap.comuniPerProvincia)) {\r\n      const comune = comuni.find((c) => c.x === comuneId);\r\n      if (comune?.c) {\r\n        return Array.isArray(comune.c) ? comune.c : [comune.c];\r\n      }\r\n    }\r\n    return [];\r\n  }\r\n\r\n  /** Dati completi di una location (nazione, provincia o comune). */\r\n  async getLocationFullData(\r\n    type: 'nazione' | 'provincia' | 'comune',\r\n    id: string,\r\n    provinciaId?: string,\r\n  ): Promise<UiNazione | UiProvincia | UiComune | null> {\r\n    switch (type) {\r\n      case 'nazione':\r\n        return this.nazioniCache.get(id) ?? null;\r\n      case 'provincia':\r\n        return this.provinceCache.get(id) ?? null;\r\n      case 'comune': {\r\n        if (!provinciaId) return this.comuniCache.get(id) ?? null;\r\n        const comuni = await this.getComuniByProvincia(provinciaId);\r\n        return comuni.find((c) => c.codiceComunePk === id) ?? null;\r\n      }\r\n      default:\r\n        return null;\r\n    }\r\n  }\r\n\r\n  // ─── Inizializzazione cache ────────────────────────────────────\r\n\r\n  private initializeCaches(): void {\r\n    // Nazioni\r\n    for (const n of this.nazioniMap.nazioni) {\r\n      this.nazioniCache.set(n.x, {\r\n        codStatoPk: n.x,\r\n        codiceCatastale: n.x,\r\n        descrizione: n.d,\r\n      });\r\n    }\r\n\r\n    // Province\r\n    for (const p of this.locationMap.province) {\r\n      this.provinceCache.set(p.x, {\r\n        codiceProvinciaPk: p.x,\r\n        nomeProvincia: p.d,\r\n        siglaProvincia: p.x,\r\n        visibile: true,\r\n      });\r\n    }\r\n\r\n    // Comuni (con riferimento alla provincia)\r\n    for (const [provinciaId, comuni] of Object.entries(this.locationMap.comuniPerProvincia)) {\r\n      const provincia = this.provinceCache.get(provinciaId);\r\n      if (!provincia) continue;\r\n      for (const c of comuni) {\r\n        this.comuniCache.set(c.x, {\r\n          codiceCatastale: c.x,\r\n          codiceComunePk: c.x,\r\n          comuneSoppresso: false,\r\n          nomeComune: c.d,\r\n          prov: provincia,\r\n          visibile: true,\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  private sortNazioniItaliaFirst(nazioni: UiNazione[]): UiNazione[] {\r\n    return nazioni.sort((a, b) => {\r\n      const aItalia = a.descrizione?.toLowerCase().includes('italia') || a.codStatoPk === 'ITA';\r\n      const bItalia = b.descrizione?.toLowerCase().includes('italia') || b.codStatoPk === 'ITA';\r\n      if (aItalia && !bItalia) return -1;\r\n      if (!aItalia && bItalia) return 1;\r\n      return (a.descrizione || '').localeCompare(b.descrizione || '', 'it', { sensitivity: 'base' });\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2022/lib/components/form-builder/services/nominatim-geocoding.service.mjs

@@ -0,0 +1,120 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { map } from 'rxjs';
+import * as i0 from "@angular/core";
+const DEFAULT_BASE = 'https://nominatim.openstreetmap.org';
+/**
+ * Integrazione con l'API pubblica Nominatim (OpenStreetMap) per la ricerca indirizzi.
+ * Mappa i risultati sul tipo {@link UiGeocodedLocationType}.
+ *
+ * In browser è consigliato usare un proxy same-origin per CORS e User-Agent;
+ * vedi {@link UiLocationGeocodedFieldConfig.nominatimBaseUrl}.
+ *
+ * @providedIn root
+ */
+export class UiNominatimGeocodingService {
+    constructor() {
+        this.http = inject(HttpClient);
+    }
+    /**
+     * Cerca indirizzi in base alla query testuale.
+     *
+     * @param query - Testo libero inserito dall'utente
+     * @param config - Opzioni di ricerca e base URL
+     */
+    search(query, config = {}) {
+        const trimmed = query.trim();
+        const base = (config.nominatimBaseUrl ?? DEFAULT_BASE).replace(/\/$/, '');
+        const limit = config.limit ?? 5;
+        let params = new HttpParams()
+            .set('q', trimmed)
+            .set('format', 'json')
+            .set('addressdetails', '1')
+            .set('limit', String(limit));
+        if (config.biasCountry) {
+            params = params.set('countrycodes', config.biasCountry.toLowerCase());
+        }
+        if (config.biasProximity) {
+            const { lat, lng } = config.biasProximity;
+            const pad = 0.05;
+            const left = lng - pad;
+            const right = lng + pad;
+            const top = lat + pad;
+            const bottom = lat - pad;
+            params = params.set('viewbox', `${left},${top},${right},${bottom}`).set('bounded', '1');
+        }
+        const url = `${base}/search`;
+        return this.http.get(url, { params }).pipe(map((items) => items.map((item) => this.mapItem(item))));
+    }
+    /** Converte un risultato Nominatim in {@link UiGeocodedLocationType}. */
+    mapItem(item) {
+        const addr = item.address ?? {};
+        const lat = parseFloat(item.lat);
+        const lon = parseFloat(item.lon);
+        const bb = item.boundingbox;
+        let boundingBox;
+        if (bb && bb.length >= 4) {
+            const south = parseFloat(bb[0]);
+            const north = parseFloat(bb[1]);
+            const west = parseFloat(bb[2]);
+            const east = parseFloat(bb[3]);
+            if (!Number.isNaN(south + north + west + east)) {
+                boundingBox = { south, north, west, east };
+            }
+        }
+        const city = addr['city'] ||
+            addr['town'] ||
+            addr['village'] ||
+            addr['municipality'] ||
+            addr['hamlet'] ||
+            addr['suburb'];
+        const confidence = typeof item.importance === 'number' ? Math.min(1, Math.max(0, item.importance / 0.75)) : undefined;
+        const ccRaw = addr['country_code'];
+        const countryCode = typeof ccRaw === 'string' ? ccRaw.toUpperCase() : undefined;
+        const isItalian = countryCode === 'IT';
+        const italian = isItalian
+            ? {
+                comune: city,
+                provincia: addr['county'] || addr['state_district'] || addr['province'],
+                regione: addr['state'],
+            }
+            : undefined;
+        const foreign = !isItalian
+            ? {
+                locality: city,
+                adminArea: addr['state'] || addr['state_district'] || addr['county'],
+                countryCode,
+            }
+            : undefined;
+        return {
+            label: item.display_name,
+            latitude: lat,
+            longitude: lon,
+            formattedAddress: item.display_name,
+            territory: isItalian ? 'italian' : 'foreign',
+            italian,
+            foreign,
+            street: addr['road'] || addr['pedestrian'] || addr['path'],
+            streetNumber: addr['house_number'],
+            postalCode: addr['postcode'],
+            city,
+            municipality: addr['municipality'],
+            province: addr['state_district'] || addr['county'],
+            region: addr['state'],
+            country: addr['country'],
+            countryCode,
+            placeId: String(item.place_id),
+            confidence,
+            boundingBox,
+            source: 'nominatim',
+            raw: item,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiNominatimGeocodingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiNominatimGeocodingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UiNominatimGeocodingService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nominatim-geocoding.service.js","sourceRoot":"","sources":["../../../../../../../packages/ng-ui-system/src/lib/components/form-builder/services/nominatim-geocoding.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpParams } from '@angular/common/http';\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { Observable, map } from 'rxjs';\r\nimport type {\r\n  UiGeocodedForeignDetails,\r\n  UiGeocodedItalianDetails,\r\n  UiGeocodedLocationType,\r\n  UiLocationGeocodedFieldConfig,\r\n} from '../types/geocoded-location.types';\r\n\r\n/** Risposta elementare dell'API search di Nominatim (format=json). */\r\ninterface NominatimSearchItem {\r\n  place_id: number;\r\n  lat: string;\r\n  lon: string;\r\n  display_name: string;\r\n  importance?: number;\r\n  boundingbox?: [string, string, string, string];\r\n  address?: Record<string, string>;\r\n}\r\n\r\nconst DEFAULT_BASE = 'https://nominatim.openstreetmap.org';\r\n\r\n/**\r\n * Integrazione con l'API pubblica Nominatim (OpenStreetMap) per la ricerca indirizzi.\r\n * Mappa i risultati sul tipo {@link UiGeocodedLocationType}.\r\n *\r\n * In browser è consigliato usare un proxy same-origin per CORS e User-Agent;\r\n * vedi {@link UiLocationGeocodedFieldConfig.nominatimBaseUrl}.\r\n *\r\n * @providedIn root\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class UiNominatimGeocodingService {\r\n  private readonly http = inject(HttpClient);\r\n\r\n  /**\r\n   * Cerca indirizzi in base alla query testuale.\r\n   *\r\n   * @param query - Testo libero inserito dall'utente\r\n   * @param config - Opzioni di ricerca e base URL\r\n   */\r\n  search(query: string, config: UiLocationGeocodedFieldConfig = {}): Observable<UiGeocodedLocationType[]> {\r\n    const trimmed = query.trim();\r\n    const base = (config.nominatimBaseUrl ?? DEFAULT_BASE).replace(/\\/$/, '');\r\n    const limit = config.limit ?? 5;\r\n\r\n    let params = new HttpParams()\r\n      .set('q', trimmed)\r\n      .set('format', 'json')\r\n      .set('addressdetails', '1')\r\n      .set('limit', String(limit));\r\n\r\n    if (config.biasCountry) {\r\n      params = params.set('countrycodes', config.biasCountry.toLowerCase());\r\n    }\r\n\r\n    if (config.biasProximity) {\r\n      const { lat, lng } = config.biasProximity;\r\n      const pad = 0.05;\r\n      const left = lng - pad;\r\n      const right = lng + pad;\r\n      const top = lat + pad;\r\n      const bottom = lat - pad;\r\n      params = params.set('viewbox', `${left},${top},${right},${bottom}`).set('bounded', '1');\r\n    }\r\n\r\n    const url = `${base}/search`;\r\n\r\n    return this.http.get<NominatimSearchItem[]>(url, { params }).pipe(map((items) => items.map((item) => this.mapItem(item))));\r\n  }\r\n\r\n  /** Converte un risultato Nominatim in {@link UiGeocodedLocationType}. */\r\n  mapItem(item: NominatimSearchItem): UiGeocodedLocationType {\r\n    const addr = item.address ?? {};\r\n    const lat = parseFloat(item.lat);\r\n    const lon = parseFloat(item.lon);\r\n    const bb = item.boundingbox;\r\n\r\n    let boundingBox: UiGeocodedLocationType['boundingBox'];\r\n    if (bb && bb.length >= 4) {\r\n      const south = parseFloat(bb[0]);\r\n      const north = parseFloat(bb[1]);\r\n      const west = parseFloat(bb[2]);\r\n      const east = parseFloat(bb[3]);\r\n      if (!Number.isNaN(south + north + west + east)) {\r\n        boundingBox = { south, north, west, east };\r\n      }\r\n    }\r\n\r\n    const city =\r\n      addr['city'] ||\r\n      addr['town'] ||\r\n      addr['village'] ||\r\n      addr['municipality'] ||\r\n      addr['hamlet'] ||\r\n      addr['suburb'];\r\n\r\n    const confidence =\r\n      typeof item.importance === 'number' ? Math.min(1, Math.max(0, item.importance / 0.75)) : undefined;\r\n\r\n    const ccRaw = addr['country_code'];\r\n    const countryCode = typeof ccRaw === 'string' ? ccRaw.toUpperCase() : undefined;\r\n    const isItalian = countryCode === 'IT';\r\n\r\n    const italian: UiGeocodedItalianDetails | undefined = isItalian\r\n      ? {\r\n          comune: city,\r\n          provincia: addr['county'] || addr['state_district'] || addr['province'],\r\n          regione: addr['state'],\r\n        }\r\n      : undefined;\r\n\r\n    const foreign: UiGeocodedForeignDetails | undefined = !isItalian\r\n      ? {\r\n          locality: city,\r\n          adminArea: addr['state'] || addr['state_district'] || addr['county'],\r\n          countryCode,\r\n        }\r\n      : undefined;\r\n\r\n    return {\r\n      label: item.display_name,\r\n      latitude: lat,\r\n      longitude: lon,\r\n      formattedAddress: item.display_name,\r\n      territory: isItalian ? 'italian' : 'foreign',\r\n      italian,\r\n      foreign,\r\n      street: addr['road'] || addr['pedestrian'] || addr['path'],\r\n      streetNumber: addr['house_number'],\r\n      postalCode: addr['postcode'],\r\n      city,\r\n      municipality: addr['municipality'],\r\n      province: addr['state_district'] || addr['county'],\r\n      region: addr['state'],\r\n      country: addr['country'],\r\n      countryCode,\r\n      placeId: String(item.place_id),\r\n      confidence,\r\n      boundingBox,\r\n      source: 'nominatim',\r\n      raw: item,\r\n    };\r\n  }\r\n}\r\n"]}