@senior-agronegocio/angular-components 1.0.7 → 1.0.9

package/LLM_LIBRARY_GUIDES.md

@@ -2,7 +2,16 @@
 
 - Guia do componente de lista de produtores em modal:
   - [components/producer-list-modal/README.md](./components/producer-list-modal/README.md)
+  - [components/producer-list-modal/INSTRUCTION.md](./components/producer-list-modal/INSTRUCTION.md)
 - Instrucoes gerais para utilitarios de `common`:
   - [common/COMMON_LLM_INSTRUCTIONS.md](./common/COMMON_LLM_INSTRUCTIONS.md)
 - Guia dos componentes modais de notas fiscais PJ (`ModalInvoicePj`):
-  - [components/modal-invoice-pj/README.md](./components/modal-invoice-pj/README.md)
+  - [components/modal-invoice-pj/README.md](./components/modal-invoice-pj/README.md)
+- Guia de integracao dos Lookup Fields reutilizaveis:
+  - [fields/lookups/README.md](./fields/lookups/README.md)
+- Relatorio de gap entre lookups do agro-origination e da biblioteca:
+  - [fields/lookups/ORIGINATION_GAP_ANALYSIS.md](./fields/lookups/ORIGINATION_GAP_ANALYSIS.md)
+- Manual para criacao de Lookup Fields customizados no projeto host:
+  - [fields/lookups/CUSTOM_LOOKUP_FIELDS_MANUAL.md](./fields/lookups/CUSTOM_LOOKUP_FIELDS_MANUAL.md)
+- Instruction para LLMs criarem lookups customizados com classes base da biblioteca:
+  - [../../.github/instructions/custom-lookup-fields.instructions.md](../../.github/instructions/custom-lookup-fields.instructions.md)

package/README.md

@@ -20,6 +20,11 @@ After building your library with `ng build angular-components`, go to the dist f
 
 Run `ng test angular-components` to execute the unit tests via [Karma](https://karma-runner.github.io).
 
+## Guides
+
+- [Lookup Fields integration guide](./fields/lookups/README.md)
+- [Library guides index](./LLM_LIBRARY_GUIDES.md)
+
 ## Further help
 
 To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

package/agro-angular-components.module.d.ts

@@ -1,10 +1,8 @@
-import { ModuleWithProviders, InjectionToken } from "@angular/core";
+import { ModuleWithProviders } from "@angular/core";
+import { HostProjectConfigs } from "./lib-config.token";
 import * as i0 from "@angular/core";
-export interface HostProjectConfigs {
-    domain: string;
-    service: string;
-}
-export declare const LIB_CONFIG: InjectionToken<HostProjectConfigs>;
+export type { HostProjectConfigs } from "./lib-config.token";
+export { LIB_CONFIG } from "./lib-config.token";
 export declare class AgroAngularComponentsModule {
     static forRoot(config: HostProjectConfigs): ModuleWithProviders<AgroAngularComponentsModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AgroAngularComponentsModule, never>;

package/esm2022/agro-angular-components.module.mjs

@@ -1,6 +1,7 @@
-import { NgModule, InjectionToken } from "@angular/core";
+import { NgModule } from "@angular/core";
+import { LIB_CONFIG } from "./lib-config.token";
 import * as i0 from "@angular/core";
-export const LIB_CONFIG = new InjectionToken("AgroAngularComponentsConfig");
+export { LIB_CONFIG } from "./lib-config.token";
 export class AgroAngularComponentsModule {
     static forRoot(config) {
         return {
@@ -21,4 +22,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: NgModule,
             args: [{}]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdyby1hbmd1bGFyLWNvbXBvbmVudHMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2Fncm8tYW5ndWxhci1jb21wb25lbnRzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXVCLFFBQVEsRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTzlFLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxJQUFJLGNBQWMsQ0FBcUIsNkJBQTZCLENBQUMsQ0FBQztBQUloRyxNQUFNLE9BQU8sMkJBQTJCO0lBQ3BDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBMEI7UUFDckMsT0FBTztZQUNILFFBQVEsRUFBRSwyQkFBMkI7WUFDckMsU0FBUyxFQUFFO2dCQUNQO29CQUNJLE9BQU8sRUFBRSxVQUFVO29CQUNuQixRQUFRLEVBQUUsTUFBTTtpQkFDbkI7YUFDSjtTQUNKLENBQUM7SUFDTixDQUFDO3dHQVhRLDJCQUEyQjt5R0FBM0IsMkJBQTJCO3lHQUEzQiwyQkFBMkI7OzRGQUEzQiwyQkFBMkI7a0JBRnZDLFFBQVE7bUJBQUMsRUFDVCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vZHVsZVdpdGhQcm92aWRlcnMsIE5nTW9kdWxlLCBJbmplY3Rpb25Ub2tlbiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEhvc3RQcm9qZWN0Q29uZmlncyB7XHJcbiAgICBkb21haW46IHN0cmluZztcclxuICAgIHNlcnZpY2U6IHN0cmluZztcclxufVxyXG5cclxuZXhwb3J0IGNvbnN0IExJQl9DT05GSUcgPSBuZXcgSW5qZWN0aW9uVG9rZW48SG9zdFByb2plY3RDb25maWdzPihcIkFncm9Bbmd1bGFyQ29tcG9uZW50c0NvbmZpZ1wiKTtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBBZ3JvQW5ndWxhckNvbXBvbmVudHNNb2R1bGUge1xyXG4gICAgc3RhdGljIGZvclJvb3QoY29uZmlnOiBIb3N0UHJvamVjdENvbmZpZ3MpOiBNb2R1bGVXaXRoUHJvdmlkZXJzPEFncm9Bbmd1bGFyQ29tcG9uZW50c01vZHVsZT4ge1xyXG4gICAgICAgIHJldHVybiB7XHJcbiAgICAgICAgICAgIG5nTW9kdWxlOiBBZ3JvQW5ndWxhckNvbXBvbmVudHNNb2R1bGUsXHJcbiAgICAgICAgICAgIHByb3ZpZGVyczogW1xyXG4gICAgICAgICAgICAgICAge1xyXG4gICAgICAgICAgICAgICAgICAgIHByb3ZpZGU6IExJQl9DT05GSUcsXHJcbiAgICAgICAgICAgICAgICAgICAgdXNlVmFsdWU6IGNvbmZpZ1xyXG4gICAgICAgICAgICAgICAgfVxyXG4gICAgICAgICAgICBdXHJcbiAgICAgICAgfTtcclxuICAgIH1cclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdyby1hbmd1bGFyLWNvbXBvbmVudHMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2Fncm8tYW5ndWxhci1jb21wb25lbnRzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXVCLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUM5RCxPQUFPLEVBQXNCLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDOztBQUdwRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFJaEQsTUFBTSxPQUFPLDJCQUEyQjtJQUNwQyxNQUFNLENBQUMsT0FBTyxDQUFDLE1BQTBCO1FBQ3JDLE9BQU87WUFDSCxRQUFRLEVBQUUsMkJBQTJCO1lBQ3JDLFNBQVMsRUFBRTtnQkFDUDtvQkFDSSxPQUFPLEVBQUUsVUFBVTtvQkFDbkIsUUFBUSxFQUFFLE1BQU07aUJBQ25CO2FBQ0o7U0FDSixDQUFDO0lBQ04sQ0FBQzt3R0FYUSwyQkFBMkI7eUdBQTNCLDJCQUEyQjt5R0FBM0IsMkJBQTJCOzs0RkFBM0IsMkJBQTJCO2tCQUZ2QyxRQUFRO21CQUFDLEVBQ1QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb2R1bGVXaXRoUHJvdmlkZXJzLCBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IEhvc3RQcm9qZWN0Q29uZmlncywgTElCX0NPTkZJRyB9IGZyb20gXCIuL2xpYi1jb25maWcudG9rZW5cIjtcclxuXHJcbmV4cG9ydCB0eXBlIHsgSG9zdFByb2plY3RDb25maWdzIH0gZnJvbSBcIi4vbGliLWNvbmZpZy50b2tlblwiO1xyXG5leHBvcnQgeyBMSUJfQ09ORklHIH0gZnJvbSBcIi4vbGliLWNvbmZpZy50b2tlblwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxufSlcclxuZXhwb3J0IGNsYXNzIEFncm9Bbmd1bGFyQ29tcG9uZW50c01vZHVsZSB7XHJcbiAgICBzdGF0aWMgZm9yUm9vdChjb25maWc6IEhvc3RQcm9qZWN0Q29uZmlncyk6IE1vZHVsZVdpdGhQcm92aWRlcnM8QWdyb0FuZ3VsYXJDb21wb25lbnRzTW9kdWxlPiB7XHJcbiAgICAgICAgcmV0dXJuIHtcclxuICAgICAgICAgICAgbmdNb2R1bGU6IEFncm9Bbmd1bGFyQ29tcG9uZW50c01vZHVsZSxcclxuICAgICAgICAgICAgcHJvdmlkZXJzOiBbXHJcbiAgICAgICAgICAgICAgICB7XHJcbiAgICAgICAgICAgICAgICAgICAgcHJvdmlkZTogTElCX0NPTkZJRyxcclxuICAgICAgICAgICAgICAgICAgICB1c2VWYWx1ZTogY29uZmlnXHJcbiAgICAgICAgICAgICAgICB9XHJcbiAgICAgICAgICAgIF1cclxuICAgICAgICB9O1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2022/components/producer-list-modal/producer-list-modal.component.mjs

@@ -32,7 +32,14 @@ export class ProducerListModalComponent {
             .join(' ');
     }
     getInitials(name) {
-        return AgroNameUtils.getInitials(name)?.slice(0, 2) ?? '?';
+        const onlyLetters = (name ?? "")
+            .replace(/[^\p{L}\s]/gu, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        if (onlyLetters) {
+            return AgroNameUtils.getInitials(onlyLetters)?.slice(0, 2) ?? "?";
+        }
+        return AgroNameUtils.getInitials(name)?.slice(0, 2) ?? "?";
     }
     trackByProducerId(_index, producer) {
         return producer.id;
@@ -49,4 +56,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         }], propDecorators: { data: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"producer-list-modal.component.js","sourceRoot":"","sources":["../../../../projects/angular-components/components/producer-list-modal/producer-list-modal.component.ts","../../../../projects/angular-components/components/producer-list-modal/producer-list-modal.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACrG,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;;;AAWnE,MAAM,OAAO,0BAA0B;IAClB,GAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAChC,YAAY,GAAG,MAAM,CAAC,YAAY,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAClE,OAAO,GAAG,IAAI,CAAC;IACd,KAAK,GAA0B;QACnC,KAAK,EAAE,EAAE;QACT,qBAAqB,EAAE,KAAK;QAC5B,SAAS,EAAE,EAAE;KAChB,CAAC;IAEF,IACW,IAAI,CAAC,KAA4B;QACxC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC5B,CAAC;IAED,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAEM,cAAc,CAAC,IAAY;QAC9B,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,qBAAqB;YAC5C,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,IAAI;YAC5C,CAAC,CAAC,IAAI,CAAC;QAEX,OAAO,OAAO;aACT,KAAK,CAAC,GAAG,CAAC;aACV,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;aAC9D,IAAI,CAAC,GAAG,CAAC,CAAC;IACnB,CAAC;IAEM,WAAW,CAAC,IAAY;QAC3B,MAAM,WAAW,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC;aAC3B,OAAO,CAAC,cAAc,EAAE,GAAG,CAAC;aAC5B,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC;aACpB,IAAI,EAAE,CAAC;QAEZ,IAAI,WAAW,EAAE,CAAC;YACd,OAAO,aAAa,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,GAAG,CAAC;QACtE,CAAC;QAED,OAAO,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,GAAG,CAAC;IAC/D,CAAC;IAEM,iBAAiB,CAAC,MAAc,EAAE,QAA0B;QAC/D,OAAO,QAAQ,CAAC,EAAE,CAAC;IACvB,CAAC;IAEM,WAAW;QACd,IAAI,CAAC,YAAY,EAAE,KAAK,EAAE,CAAC;IAC/B,CAAC;wGAlDQ,0BAA0B;4FAA1B,0BAA0B,2GChBvC,62CAwCA,giCD1Bc,YAAY,gQAAE,eAAe,kLAAE,eAAe;;4FAE/C,0BAA0B;kBARtC,SAAS;+BACI,uBAAuB,mBAGhB,uBAAuB,CAAC,MAAM,cACnC,IAAI,WACP,CAAC,YAAY,EAAE,eAAe,EAAE,eAAe,CAAC;8BAa9C,IAAI;sBADd,KAAK","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Input, inject } from \"@angular/core\";\r\nimport { CommonModule } from \"@angular/common\";\r\nimport { ButtonComponent } from \"@seniorsistemas/angular-components/button\";\r\nimport { DialogComponent } from \"@seniorsistemas/angular-components/dialog\";\r\nimport { ActiveDialog } from \"@seniorsistemas/angular-components/dialog\";\r\nimport { AgroNameUtils } from \"../../common/agro-name-utils.class\";\r\nimport { ProducerListItem, ProducerListModalData } from \"./producer-list-modal-data.interface\";\r\n\r\n@Component({\r\n    selector: \"s-producer-list-modal\",\r\n    templateUrl: \"./producer-list-modal.component.html\",\r\n    styleUrls: [\"./producer-list-modal.component.scss\"],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    standalone: true,\r\n    imports: [CommonModule, DialogComponent, ButtonComponent],\r\n})\r\nexport class ProducerListModalComponent {\r\n    private readonly cdr = inject(ChangeDetectorRef);\r\n    private readonly activeDialog = inject(ActiveDialog, { optional: true });\r\n    public visible = true;\r\n    private _data: ProducerListModalData = {\r\n        title: \"\",\r\n        shouldAbbreviateNames: false,\r\n        producers: [],\r\n    };\r\n\r\n    @Input()\r\n    public set data(value: ProducerListModalData) {\r\n        this._data = value;\r\n        this.cdr.markForCheck();\r\n    }\r\n\r\n    public get data(): ProducerListModalData {\r\n        return this._data;\r\n    }\r\n\r\n    public getDisplayName(name: string): string {\r\n        const display = this.data?.shouldAbbreviateNames\r\n            ? AgroNameUtils.abbreviateName(name) ?? name\r\n            : name;\r\n\r\n        return display\r\n            .split(' ')\r\n            .map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())\r\n            .join(' ');\r\n    }\r\n\r\n    public getInitials(name: string): string {\r\n        const onlyLetters = (name ?? \"\")\r\n            .replace(/[^\\p{L}\\s]/gu, \" \")\r\n            .replace(/\\s+/g, \" \")\r\n            .trim();\r\n\r\n        if (onlyLetters) {\r\n            return AgroNameUtils.getInitials(onlyLetters)?.slice(0, 2) ?? \"?\";\r\n        }\r\n\r\n        return AgroNameUtils.getInitials(name)?.slice(0, 2) ?? \"?\";\r\n    }\r\n\r\n    public trackByProducerId(_index: number, producer: ProducerListItem): string {\r\n        return producer.id;\r\n    }\r\n\r\n    public handleClose(): void {\r\n        this.activeDialog?.close();\r\n    }\r\n}","<s-dialog\r\n    [header]=\"data.title\"\r\n    size=\"md\"\r\n>\r\n    <section class=\"producer-list-content\">\r\n        <ul\r\n            *ngIf=\"data.producers.length; else emptyState\"\r\n            class=\"producer-list\"\r\n        >\r\n            <li\r\n                *ngFor=\"let producer of data.producers; trackBy: trackByProducerId\"\r\n                class=\"producer-item\"\r\n                [attr.data-producer]=\"producer.id\"\r\n            >\r\n                <span\r\n                    class=\"producer-avatar\"\r\n                    [attr.data-initials]=\"getInitials(producer.name)\"\r\n                    >{{ getInitials(producer.name) }}</span\r\n                >\r\n                <span class=\"producer-name\">{{ getDisplayName(producer.name) }}</span>\r\n            </li>\r\n        </ul>\r\n\r\n        <ng-template #emptyState>\r\n            <div class=\"empty-state\">\r\n                <i class=\"fa fa-users empty-state-icon\"></i>\r\n                <p class=\"empty-state-text\">Nenhum produtor informado.</p>\r\n            </div>\r\n        </ng-template>\r\n    </section>\r\n\r\n    <ng-template sTemplate=\"footer\">\r\n        aaaaa\r\n        <s-button\r\n            label=\"Fechar\"\r\n            priority=\"primary\"\r\n            (clicked)=\"handleClose()\"\r\n        ></s-button>\r\n    </ng-template>\r\n</s-dialog>\r\n"]}

package/esm2022/fields/lookups/config/lookup-host-project-config.mjs

@@ -0,0 +1,7 @@
+export function resolveLookupHostProjectConfig(config, serviceName) {
+    if (config?.domain && config?.service) {
+        return config;
+    }
+    throw new Error(`${serviceName}: HostProjectConfigs is required. Configure AgroAngularComponentsModule.forRoot({ domain, service }).`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9va3VwLWhvc3QtcHJvamVjdC1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvZmllbGRzL2xvb2t1cHMvY29uZmlnL2xvb2t1cC1ob3N0LXByb2plY3QtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSw4QkFBOEIsQ0FBQyxNQUE2QyxFQUFFLFdBQW1CO0lBQzdHLElBQUksTUFBTSxFQUFFLE1BQU0sSUFBSSxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7UUFDcEMsT0FBTyxNQUFNLENBQUM7SUFDbEIsQ0FBQztJQUVELE1BQU0sSUFBSSxLQUFLLENBQ1gsR0FBRyxXQUFXLHVHQUF1RyxDQUN4SCxDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEhvc3RQcm9qZWN0Q29uZmlncyB9IGZyb20gJy4uLy4uLy4uL2Fncm8tYW5ndWxhci1jb21wb25lbnRzLm1vZHVsZSc7XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gcmVzb2x2ZUxvb2t1cEhvc3RQcm9qZWN0Q29uZmlnKGNvbmZpZzogSG9zdFByb2plY3RDb25maWdzIHwgbnVsbCB8IHVuZGVmaW5lZCwgc2VydmljZU5hbWU6IHN0cmluZyk6IEhvc3RQcm9qZWN0Q29uZmlncyB7XHJcbiAgICBpZiAoY29uZmlnPy5kb21haW4gJiYgY29uZmlnPy5zZXJ2aWNlKSB7XHJcbiAgICAgICAgcmV0dXJuIGNvbmZpZztcclxuICAgIH1cclxuXHJcbiAgICB0aHJvdyBuZXcgRXJyb3IoXHJcbiAgICAgICAgYCR7c2VydmljZU5hbWV9OiBIb3N0UHJvamVjdENvbmZpZ3MgaXMgcmVxdWlyZWQuIENvbmZpZ3VyZSBBZ3JvQW5ndWxhckNvbXBvbmVudHNNb2R1bGUuZm9yUm9vdCh7IGRvbWFpbiwgc2VydmljZSB9KS5gXHJcbiAgICApO1xyXG59XHJcbiJdfQ==

package/esm2022/fields/lookups/core/agro-base-lookup-field.mjs

@@ -0,0 +1,385 @@
+import { Subject } from 'rxjs';
+import { pairwise, startWith, debounceTime } from 'rxjs/operators';
+import { createGenericOnLookupRequest, createGenericOnSearchRequest } from './lookup-field.handlers';
+import { getLabelValueRequest, mergeUnique } from '../utils/agro-lookup-utils';
+import { formatCPFCNPJWithMask } from '../utils';
+const LOOKUP_DEBOUNCE_MS = 300;
+const LOOKUP_DOCUMENT_FIELDS_TO_FORMAT = ['cnpCpf', 'numCgc'];
+export class AgroBaseLookupField {
+    config;
+    translate;
+    suggestionsSubject = new Subject();
+    searchSubject = new Subject();
+    hasDependencyListenerStarted = false;
+    constructor(config, translate) {
+        this.config = config;
+        this.translate = translate;
+    }
+    isLookupValueValid(value) {
+        if (value === null || value === undefined || value === '') {
+            return false;
+        }
+        if (Array.isArray(value)) {
+            return value.length > 0 && value.every((item) => item && typeof item === 'object' && item.id !== undefined && item.id !== null);
+        }
+        return typeof value === 'object' && value.id !== undefined && value.id !== null;
+    }
+    formatEntityDocumentFields(entity) {
+        if (!entity || typeof entity !== 'object' || Array.isArray(entity)) {
+            return entity;
+        }
+        let formattedEntity = entity;
+        LOOKUP_DOCUMENT_FIELDS_TO_FORMAT.forEach((fieldName) => {
+            if (!Object.hasOwn(entity, fieldName)) {
+                return;
+            }
+            const originalValue = entity[fieldName];
+            if (originalValue === null || originalValue === undefined || originalValue === '') {
+                return;
+            }
+            const formattedValue = formatCPFCNPJWithMask(originalValue);
+            if (formattedValue !== originalValue) {
+                if (formattedEntity === entity) {
+                    formattedEntity = { ...entity };
+                }
+                formattedEntity[fieldName] = formattedValue;
+            }
+        });
+        return formattedEntity;
+    }
+    normalizeLookupValue(value) {
+        if (Array.isArray(value)) {
+            let hasChanges = false;
+            const normalizedArray = value.map((item) => {
+                const normalizedItem = this.normalizeLookupValue(item);
+                hasChanges = hasChanges || normalizedItem !== item;
+                return normalizedItem;
+            });
+            return hasChanges ? normalizedArray : value;
+        }
+        return this.formatEntityDocumentFields(value);
+    }
+    syncControlValueWithNormalization(control) {
+        if (!control) {
+            return null;
+        }
+        const normalizedValue = this.normalizeLookupValue(control.value);
+        if (normalizedValue !== control.value) {
+            control.setValue(normalizedValue, { emitEvent: false });
+        }
+        return normalizedValue;
+    }
+    hasUserInteraction(control) {
+        if (!control) {
+            return false;
+        }
+        return control.dirty || control.touched;
+    }
+    markControlAsUserInteracted(control) {
+        if (!control) {
+            return;
+        }
+        if (!control.dirty) {
+            control.markAsDirty({ onlySelf: true });
+        }
+        if (!control.touched) {
+            control.markAsTouched({ onlySelf: true });
+        }
+    }
+    isControlFilled(value) {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        if (typeof value === 'string') {
+            return value.trim() !== '';
+        }
+        if (Array.isArray(value)) {
+            return value.length > 0;
+        }
+        return true;
+    }
+    areDependenciesReady() {
+        const dependsOf = this.config.dependsOf ?? [];
+        if (dependsOf.length === 0) {
+            return true;
+        }
+        return dependsOf.every((fieldName) => {
+            const control = this.config.formGroup.get(fieldName);
+            return this.isLookupValueValid(this.syncControlValueWithNormalization(control));
+        });
+    }
+    isAutofillEnabled() {
+        return this.config.autofill !== false;
+    }
+    buildDependencyQuery() {
+        const dependencies = this.config.dependencies ?? [];
+        return dependencies
+            .map(({ formControlName, apiField }) => {
+            const dependencyId = this.config.formGroup.get(formControlName)?.value?.id;
+            return dependencyId ? `${apiField} eq '${dependencyId}'` : '';
+        })
+            .filter(Boolean)
+            .join(' and ');
+    }
+    buildCustomFilterQuery() {
+        const query = this.config.customFilterQuery?.();
+        return typeof query === 'string' ? query.trim() : '';
+    }
+    combineFilterQueries(...queries) {
+        return queries.filter((query) => !!query).join(' and ');
+    }
+    tryAutofillWhenSingleResult() {
+        if (!this.isAutofillEnabled()) {
+            return;
+        }
+        const dependsOf = this.config.dependsOf ?? [];
+        if (dependsOf.length === 0) {
+            return;
+        }
+        const targetControl = this.config.formGroup.get(this.config.name);
+        if (!targetControl || targetControl.disabled || this.isLookupValueValid(targetControl.value)) {
+            return;
+        }
+        const dependencyQuery = this.buildDependencyQuery();
+        const customQuery = this.buildCustomFilterQuery();
+        const filterQuery = this.combineFilterQueries(dependencyQuery, customQuery);
+        if (!filterQuery) {
+            return;
+        }
+        const sort = this.config.lookupDisplayFields.map((field) => ({ field, order: 1 }));
+        const displayFields = mergeUnique(this.config.lookupDisplayFields, this.config.advancedDisplayFields);
+        this.config.service
+            .list({ page: 0, size: 2, sort, filterQuery, displayFields })
+            .subscribe((list) => {
+            const contents = list?.contents ?? [];
+            if (contents.length !== 1) {
+                return;
+            }
+            const [singleValue] = getLabelValueRequest(contents, this.config.lookupDisplayFields);
+            if (singleValue) {
+                targetControl.setValue(this.normalizeLookupValue(singleValue), { emitEvent: true });
+            }
+        });
+    }
+    isPrefilledAndIndependent(hasAnyUserInteraction, targetIsValid, targetIsFilled) {
+        return !hasAnyUserInteraction && (targetIsValid || targetIsFilled);
+    }
+    handleDependenciesState(forceReset = false) {
+        const targetControl = this.config.formGroup.get(this.config.name);
+        if (!targetControl) {
+            return;
+        }
+        const dependsOf = this.config.dependsOf ?? [];
+        if (dependsOf.length === 0) {
+            return;
+        }
+        const hasAnyUserInteraction = dependsOf.some((fieldName) => this.hasUserInteraction(this.config.formGroup.get(fieldName)));
+        const targetValue = this.syncControlValueWithNormalization(targetControl);
+        const targetIsValid = this.isLookupValueValid(targetValue);
+        const targetIsFilled = this.isControlFilled(targetValue);
+        if (forceReset) {
+            targetControl.setValue(null, { emitEvent: false });
+            targetControl.disable({ emitEvent: false });
+            return;
+        }
+        // Rule: dependent fields start disabled, except when already filled/valid (prefilled scenario).
+        if (this.isPrefilledAndIndependent(hasAnyUserInteraction, targetIsValid, targetIsFilled)) {
+            targetControl.enable({ emitEvent: false });
+            this.tryAutofillWhenSingleResult();
+            return;
+        }
+        if (this.areDependenciesReady()) {
+            targetControl.enable({ emitEvent: false });
+            this.tryAutofillWhenSingleResult();
+            return;
+        }
+        // Keep prefilled values; clear only when there is user interaction or value is invalid for lookup.
+        if (hasAnyUserInteraction || (targetIsFilled && !targetIsValid)) {
+            targetControl.setValue(null, { emitEvent: false });
+        }
+        targetControl.disable({ emitEvent: false });
+    }
+    clearTargetKeepingEnabled() {
+        const targetControl = this.config.formGroup.get(this.config.name);
+        if (!targetControl) {
+            return;
+        }
+        targetControl.setValue(null, { emitEvent: true });
+        if (this.areDependenciesReady()) {
+            targetControl.enable({ emitEvent: false });
+            this.tryAutofillWhenSingleResult();
+        }
+    }
+    getComparableLookupValue(value) {
+        const normalizedValue = this.normalizeLookupValue(value);
+        if (normalizedValue === null || normalizedValue === undefined || normalizedValue === '') {
+            return null;
+        }
+        if (Array.isArray(normalizedValue)) {
+            return normalizedValue.map((item) => this.getComparableLookupValue(item));
+        }
+        if (typeof normalizedValue === 'object') {
+            if (normalizedValue.id !== undefined && normalizedValue.id !== null) {
+                return normalizedValue.id;
+            }
+            return JSON.stringify(normalizedValue);
+        }
+        return normalizedValue;
+    }
+    didDependencyValueChange(previousComparable, currentComparable) {
+        return JSON.stringify(previousComparable) !== JSON.stringify(currentComparable);
+    }
+    startDependenciesListener() {
+        if (this.hasDependencyListenerStarted) {
+            return;
+        }
+        const dependsOf = this.config.dependsOf ?? [];
+        if (dependsOf.length === 0) {
+            return;
+        }
+        this.hasDependencyListenerStarted = true;
+        // Observe each dependency directly and compare previous/current values.
+        dependsOf.forEach((fieldName) => {
+            const control = this.config.formGroup.get(fieldName);
+            control?.valueChanges.pipe(startWith(control.value), debounceTime(LOOKUP_DEBOUNCE_MS), pairwise()).subscribe(([previousValue, currentValue]) => {
+                const normalizedPreviousValue = this.normalizeLookupValue(previousValue);
+                const normalizedCurrentValue = this.normalizeLookupValue(currentValue);
+                if (normalizedCurrentValue !== currentValue) {
+                    control.setValue(normalizedCurrentValue, { emitEvent: false });
+                }
+                const previousValidity = this.isLookupValueValid(normalizedPreviousValue);
+                const currentValidity = this.isLookupValueValid(normalizedCurrentValue);
+                const previousComparable = this.getComparableLookupValue(normalizedPreviousValue);
+                const currentComparable = this.getComparableLookupValue(normalizedCurrentValue);
+                const didValueChange = this.didDependencyValueChange(previousComparable, currentComparable);
+                if (previousValidity && !currentValidity) {
+                    this.handleDependenciesState(true);
+                    return;
+                }
+                if (previousValidity && currentValidity && didValueChange) {
+                    this.clearTargetKeepingEnabled();
+                    return;
+                }
+                if (!previousValidity && currentValidity) {
+                    this.handleDependenciesState(false);
+                }
+            });
+            control?.statusChanges.subscribe(() => {
+                if (this.areDependenciesReady()) {
+                    this.handleDependenciesState(false);
+                }
+            });
+        });
+        // Evaluate once after init to honor prefilled valid dependencies without forcing resets.
+        this.handleDependenciesState(false);
+    }
+    makeIt() {
+        this.startDependenciesListener();
+        return {
+            name: this.config.name,
+            formControlName: this.config.name, // Explicitly set formControlName for s-dynamic-form binding
+            filterFieldName: this.config.filterFieldName ?? this.config.name,
+            required: this.config.required ?? (() => false),
+            size: this.config.size ?? { sm: 4, md: 4, lg: 4, xl: 4 },
+            dependsOf: this.config.dependsOf ?? [],
+            label: this.translate.instant(this.config.labelKey),
+            type: 'lookup',
+            dataKey: 'id',
+            lookupDisplayField: 'label',
+            searchTitle: this.translate.instant(this.config.searchTitleKey),
+            searchEmptyTitle: this.translate.instant('agro.angular_components.lookup_nothing_found'),
+            filterLabel: this.translate.instant('agro.angular_components.lookup_filter'),
+            filterTitle: this.translate.instant('agro.angular_components.lookup_filters'),
+            clearLabel: this.translate.instant('agro.angular_components.lookup_clear'),
+            cancelLabel: this.translate.instant('agro.angular_components.lookup_cancel'),
+            selectLabel: this.translate.instant('agro.angular_components.lookup_select'),
+            suggestionsObservable: this.suggestionsSubject.asObservable(),
+            searchObservable: this.searchSubject.asObservable(),
+            onLookupRequest: createGenericOnLookupRequest({
+                config: this.config,
+                suggestionsSubject: this.suggestionsSubject,
+                searchSubject: this.searchSubject,
+            }),
+            onSearchRequest: createGenericOnSearchRequest({
+                config: this.config,
+                suggestionsSubject: this.suggestionsSubject,
+                searchSubject: this.searchSubject,
+            }),
+            onBlur: (event) => {
+                const control = this.config.formGroup.get(this.config.name);
+                if (control) {
+                    this.markControlAsUserInteracted(control);
+                    const uiRawValue = event?.target?.value ?? event?.value ?? '';
+                    const uiTextValue = typeof uiRawValue === 'string' ? uiRawValue.trim() : uiRawValue;
+                    const isUiEmpty = !uiTextValue;
+                    const currentValue = this.syncControlValueWithNormalization(control);
+                    const isValueValid = this.isLookupValueValid(currentValue);
+                    // If UI was cleared but control still has a value, force sync to null.
+                    if (isUiEmpty && currentValue != null && currentValue !== '') {
+                        control.setValue(null, { emitEvent: true });
+                        control.updateValueAndValidity({ emitEvent: true });
+                        return;
+                    }
+                    // If the control has a value but it's not a valid lookup object, clear it
+                    // This catches cases where the UI cleared the field but the FormControl wasn't updated
+                    if (currentValue && !isValueValid) {
+                        this.config.formGroup.patchValue({ [this.config.name]: null }, { emitEvent: true });
+                    }
+                }
+            },
+            onSelectHandler: (event) => {
+                const actualValue = event?.value || event;
+                const control = this.config.formGroup.get(this.config.name);
+                if (control && actualValue && typeof actualValue === 'object' && actualValue.id) {
+                    const normalizedValue = this.normalizeLookupValue(actualValue);
+                    this.markControlAsUserInteracted(control);
+                    control.setValue(normalizedValue, { emitEvent: true });
+                }
+            },
+            onSelect: (event) => {
+                const actualValue = event?.value || event;
+                const control = this.config.formGroup.get(this.config.name);
+                if (control && actualValue && typeof actualValue === 'object' && actualValue.id) {
+                    const normalizedValue = this.normalizeLookupValue(actualValue);
+                    this.markControlAsUserInteracted(control);
+                    control.setValue(normalizedValue, { emitEvent: true });
+                }
+            },
+            onClear: () => {
+                const control = this.config.formGroup.get(this.config.name);
+                if (control) {
+                    this.markControlAsUserInteracted(control);
+                    control.setValue(null, { emitEvent: true });
+                }
+            },
+            onChange: (event) => {
+                const control = this.config.formGroup.get(this.config.name);
+                const actualValue = event?.value || event;
+                if (control && actualValue && typeof actualValue === 'object') {
+                    const normalizedValue = this.normalizeLookupValue(actualValue);
+                    if (normalizedValue !== actualValue) {
+                        this.markControlAsUserInteracted(control);
+                        control.setValue(normalizedValue, { emitEvent: true });
+                        return;
+                    }
+                }
+                if (control && !actualValue) {
+                    this.markControlAsUserInteracted(control);
+                    control.setValue(null, { emitEvent: true });
+                }
+            },
+            onUnselect: () => {
+                const control = this.config.formGroup.get(this.config.name);
+                if (control) {
+                    this.markControlAsUserInteracted(control);
+                    control.setValue(null, { emitEvent: true });
+                }
+            },
+            searchFields: this.config.searchFields,
+            searchGridFields: this.config.searchFields,
+            appendTo: 'body',
+            baseZIndex: 10000,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agro-base-lookup-field.js","sourceRoot":"","sources":["../../../../../projects/angular-components/fields/lookups/core/agro-base-lookup-field.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject } from 'rxjs';\r\nimport { AbstractControl } from '@angular/forms';\r\nimport { LibTranslationService } from '../../../services/lib-translation.service';\r\nimport { pairwise, startWith, debounceTime } from 'rxjs/operators';\r\nimport { GenericLookupFieldConfig } from './lookup-field.types';\r\nimport { createGenericOnLookupRequest, createGenericOnSearchRequest } from './lookup-field.handlers';\r\nimport { getLabelValueRequest, mergeUnique } from '../utils/agro-lookup-utils';\r\nimport { formatCPFCNPJWithMask } from '../utils';\r\n\r\nconst LOOKUP_DEBOUNCE_MS = 300;\r\nconst LOOKUP_DOCUMENT_FIELDS_TO_FORMAT = ['cnpCpf', 'numCgc'];\r\n\r\nexport class AgroBaseLookupField {\r\n    private readonly suggestionsSubject = new Subject<any[]>();\r\n    private readonly searchSubject = new Subject<any>();\r\n    private hasDependencyListenerStarted = false;\r\n\r\n    constructor(\r\n        private readonly config: GenericLookupFieldConfig,\r\n        private readonly translate: LibTranslationService\r\n    ) { }\r\n\r\n    private isLookupValueValid(value: any): boolean {\r\n        if (value === null || value === undefined || value === '') {\r\n            return false;\r\n        }\r\n\r\n        if (Array.isArray(value)) {\r\n            return value.length > 0 && value.every((item) => item && typeof item === 'object' && item.id !== undefined && item.id !== null);\r\n        }\r\n\r\n        return typeof value === 'object' && value.id !== undefined && value.id !== null;\r\n    }\r\n\r\n    private formatEntityDocumentFields(entity: any): any {\r\n        if (!entity || typeof entity !== 'object' || Array.isArray(entity)) {\r\n            return entity;\r\n        }\r\n\r\n        let formattedEntity = entity;\r\n\r\n        LOOKUP_DOCUMENT_FIELDS_TO_FORMAT.forEach((fieldName) => {\r\n            if (!Object.hasOwn(entity, fieldName)) {\r\n                return;\r\n            }\r\n\r\n            const originalValue = entity[fieldName];\r\n            if (originalValue === null || originalValue === undefined || originalValue === '') {\r\n                return;\r\n            }\r\n\r\n            const formattedValue = formatCPFCNPJWithMask(originalValue);\r\n            if (formattedValue !== originalValue) {\r\n                if (formattedEntity === entity) {\r\n                    formattedEntity = { ...entity };\r\n                }\r\n\r\n                formattedEntity[fieldName] = formattedValue;\r\n            }\r\n        });\r\n\r\n        return formattedEntity;\r\n    }\r\n\r\n    private normalizeLookupValue(value: any): any {\r\n        if (Array.isArray(value)) {\r\n            let hasChanges = false;\r\n            const normalizedArray = value.map((item) => {\r\n                const normalizedItem = this.normalizeLookupValue(item);\r\n                hasChanges = hasChanges || normalizedItem !== item;\r\n                return normalizedItem;\r\n            });\r\n\r\n            return hasChanges ? normalizedArray : value;\r\n        }\r\n\r\n        return this.formatEntityDocumentFields(value);\r\n    }\r\n\r\n    private syncControlValueWithNormalization(control: AbstractControl | null): any {\r\n        if (!control) {\r\n            return null;\r\n        }\r\n\r\n        const normalizedValue = this.normalizeLookupValue(control.value);\r\n        if (normalizedValue !== control.value) {\r\n            control.setValue(normalizedValue, { emitEvent: false });\r\n        }\r\n\r\n        return normalizedValue;\r\n    }\r\n\r\n    private hasUserInteraction(control: AbstractControl | null): boolean {\r\n        if (!control) {\r\n            return false;\r\n        }\r\n\r\n        return control.dirty || control.touched;\r\n    }\r\n\r\n    private markControlAsUserInteracted(control: AbstractControl | null): void {\r\n        if (!control) {\r\n            return;\r\n        }\r\n\r\n        if (!control.dirty) {\r\n            control.markAsDirty({ onlySelf: true });\r\n        }\r\n\r\n        if (!control.touched) {\r\n            control.markAsTouched({ onlySelf: true });\r\n        }\r\n    }\r\n\r\n    private isControlFilled(value: any): boolean {\r\n        if (value === null || value === undefined) {\r\n            return false;\r\n        }\r\n\r\n        if (typeof value === 'string') {\r\n            return value.trim() !== '';\r\n        }\r\n\r\n        if (Array.isArray(value)) {\r\n            return value.length > 0;\r\n        }\r\n\r\n        return true;\r\n    }\r\n\r\n    private areDependenciesReady(): boolean {\r\n        const dependsOf = this.config.dependsOf ?? [];\r\n        if (dependsOf.length === 0) {\r\n            return true;\r\n        }\r\n\r\n        return dependsOf.every((fieldName) => {\r\n            const control = this.config.formGroup.get(fieldName);\r\n            return this.isLookupValueValid(this.syncControlValueWithNormalization(control));\r\n        });\r\n    }\r\n\r\n    private isAutofillEnabled(): boolean {\r\n        return this.config.autofill !== false;\r\n    }\r\n\r\n    private buildDependencyQuery(): string {\r\n        const dependencies = this.config.dependencies ?? [];\r\n        return dependencies\r\n            .map(({ formControlName, apiField }) => {\r\n                const dependencyId = this.config.formGroup.get(formControlName)?.value?.id;\r\n                return dependencyId ? `${apiField} eq '${dependencyId}'` : '';\r\n            })\r\n            .filter(Boolean)\r\n            .join(' and ');\r\n    }\r\n\r\n    private buildCustomFilterQuery(): string {\r\n        const query = this.config.customFilterQuery?.();\r\n        return typeof query === 'string' ? query.trim() : '';\r\n    }\r\n\r\n    private combineFilterQueries(...queries: string[]): string {\r\n        return queries.filter((query) => !!query).join(' and ');\r\n    }\r\n\r\n    private tryAutofillWhenSingleResult(): void {\r\n        if (!this.isAutofillEnabled()) {\r\n            return;\r\n        }\r\n\r\n        const dependsOf = this.config.dependsOf ?? [];\r\n        if (dependsOf.length === 0) {\r\n            return;\r\n        }\r\n\r\n        const targetControl = this.config.formGroup.get(this.config.name);\r\n        if (!targetControl || targetControl.disabled || this.isLookupValueValid(targetControl.value)) {\r\n            return;\r\n        }\r\n\r\n        const dependencyQuery = this.buildDependencyQuery();\r\n        const customQuery = this.buildCustomFilterQuery();\r\n        const filterQuery = this.combineFilterQueries(dependencyQuery, customQuery);\r\n        if (!filterQuery) {\r\n            return;\r\n        }\r\n\r\n        const sort = this.config.lookupDisplayFields.map((field: string) => ({ field, order: 1 }));\r\n        const displayFields = mergeUnique(this.config.lookupDisplayFields, this.config.advancedDisplayFields);\r\n\r\n        this.config.service\r\n            .list({ page: 0, size: 2, sort, filterQuery, displayFields })\r\n            .subscribe((list: any) => {\r\n                const contents = list?.contents ?? [];\r\n                if (contents.length !== 1) {\r\n                    return;\r\n                }\r\n\r\n                const [singleValue] = getLabelValueRequest(contents, this.config.lookupDisplayFields);\r\n                if (singleValue) {\r\n                    targetControl.setValue(this.normalizeLookupValue(singleValue), { emitEvent: true });\r\n                }\r\n            });\r\n    }\r\n\r\n    private isPrefilledAndIndependent(hasAnyUserInteraction: boolean, targetIsValid: boolean, targetIsFilled: boolean): boolean {\r\n        return !hasAnyUserInteraction && (targetIsValid || targetIsFilled);\r\n    }\r\n\r\n    private handleDependenciesState(forceReset = false): void {\r\n        const targetControl = this.config.formGroup.get(this.config.name);\r\n        if (!targetControl) {\r\n            return;\r\n        }\r\n\r\n        const dependsOf = this.config.dependsOf ?? [];\r\n        if (dependsOf.length === 0) {\r\n            return;\r\n        }\r\n\r\n        const hasAnyUserInteraction = dependsOf.some((fieldName) => this.hasUserInteraction(this.config.formGroup.get(fieldName)));\r\n        const targetValue = this.syncControlValueWithNormalization(targetControl);\r\n        const targetIsValid = this.isLookupValueValid(targetValue);\r\n        const targetIsFilled = this.isControlFilled(targetValue);\r\n\r\n        if (forceReset) {\r\n            targetControl.setValue(null, { emitEvent: false });\r\n            targetControl.disable({ emitEvent: false });\r\n            return;\r\n        }\r\n\r\n        // Rule: dependent fields start disabled, except when already filled/valid (prefilled scenario).\r\n        if (this.isPrefilledAndIndependent(hasAnyUserInteraction, targetIsValid, targetIsFilled)) {\r\n            targetControl.enable({ emitEvent: false });\r\n            this.tryAutofillWhenSingleResult();\r\n            return;\r\n        }\r\n\r\n        if (this.areDependenciesReady()) {\r\n            targetControl.enable({ emitEvent: false });\r\n            this.tryAutofillWhenSingleResult();\r\n            return;\r\n        }\r\n\r\n        // Keep prefilled values; clear only when there is user interaction or value is invalid for lookup.\r\n        if (hasAnyUserInteraction || (targetIsFilled && !targetIsValid)) {\r\n            targetControl.setValue(null, { emitEvent: false });\r\n        }\r\n\r\n        targetControl.disable({ emitEvent: false });\r\n    }\r\n\r\n    private clearTargetKeepingEnabled(): void {\r\n        const targetControl = this.config.formGroup.get(this.config.name);\r\n        if (!targetControl) {\r\n            return;\r\n        }\r\n\r\n        targetControl.setValue(null, { emitEvent: true });\r\n\r\n        if (this.areDependenciesReady()) {\r\n            targetControl.enable({ emitEvent: false });\r\n            this.tryAutofillWhenSingleResult();\r\n        }\r\n    }\r\n\r\n    private getComparableLookupValue(value: any): any {\r\n        const normalizedValue = this.normalizeLookupValue(value);\r\n\r\n        if (normalizedValue === null || normalizedValue === undefined || normalizedValue === '') {\r\n            return null;\r\n        }\r\n\r\n        if (Array.isArray(normalizedValue)) {\r\n            return normalizedValue.map((item) => this.getComparableLookupValue(item));\r\n        }\r\n\r\n        if (typeof normalizedValue === 'object') {\r\n            if (normalizedValue.id !== undefined && normalizedValue.id !== null) {\r\n                return normalizedValue.id;\r\n            }\r\n\r\n            return JSON.stringify(normalizedValue);\r\n        }\r\n\r\n        return normalizedValue;\r\n    }\r\n\r\n    private didDependencyValueChange(previousComparable: any, currentComparable: any): boolean {\r\n        return JSON.stringify(previousComparable) !== JSON.stringify(currentComparable);\r\n    }\r\n\r\n    private startDependenciesListener(): void {\r\n        if (this.hasDependencyListenerStarted) {\r\n            return;\r\n        }\r\n\r\n        const dependsOf = this.config.dependsOf ?? [];\r\n        if (dependsOf.length === 0) {\r\n            return;\r\n        }\r\n\r\n        this.hasDependencyListenerStarted = true;\r\n\r\n        // Observe each dependency directly and compare previous/current values.\r\n        dependsOf.forEach((fieldName) => {\r\n            const control = this.config.formGroup.get(fieldName);\r\n                control?.valueChanges.pipe(\r\n                    startWith(control.value),\r\n                    debounceTime(LOOKUP_DEBOUNCE_MS),\r\n                    pairwise()\r\n                ).subscribe(([previousValue, currentValue]) => {\r\n                const normalizedPreviousValue = this.normalizeLookupValue(previousValue);\r\n                const normalizedCurrentValue = this.normalizeLookupValue(currentValue);\r\n\r\n                if (normalizedCurrentValue !== currentValue) {\r\n                    control.setValue(normalizedCurrentValue, { emitEvent: false });\r\n                }\r\n\r\n                const previousValidity = this.isLookupValueValid(normalizedPreviousValue);\r\n                const currentValidity = this.isLookupValueValid(normalizedCurrentValue);\r\n                const previousComparable = this.getComparableLookupValue(normalizedPreviousValue);\r\n                const currentComparable = this.getComparableLookupValue(normalizedCurrentValue);\r\n                const didValueChange = this.didDependencyValueChange(previousComparable, currentComparable);\r\n\r\n                if (previousValidity && !currentValidity) {\r\n                    this.handleDependenciesState(true);\r\n                    return;\r\n                }\r\n\r\n                if (previousValidity && currentValidity && didValueChange) {\r\n                    this.clearTargetKeepingEnabled();\r\n                    return;\r\n                }\r\n\r\n                if (!previousValidity && currentValidity) {\r\n                    this.handleDependenciesState(false);\r\n                }\r\n            });\r\n\r\n            control?.statusChanges.subscribe(() => {\r\n                if (this.areDependenciesReady()) {\r\n                    this.handleDependenciesState(false);\r\n                }\r\n            });\r\n        });\r\n\r\n        // Evaluate once after init to honor prefilled valid dependencies without forcing resets.\r\n        this.handleDependenciesState(false);\r\n    }\r\n\r\n    makeIt(): any {\r\n        this.startDependenciesListener();\r\n\r\n        return {\r\n            name: this.config.name,\r\n            formControlName: this.config.name,  // Explicitly set formControlName for s-dynamic-form binding\r\n            filterFieldName: this.config.filterFieldName ?? this.config.name,\r\n            required: this.config.required ?? (() => false),\r\n            size: this.config.size ?? { sm: 4, md: 4, lg: 4, xl: 4 },\r\n            dependsOf: this.config.dependsOf ?? [],\r\n            label: this.translate.instant(this.config.labelKey),\r\n            type: 'lookup',\r\n            dataKey: 'id',\r\n            lookupDisplayField: 'label',\r\n            searchTitle: this.translate.instant(this.config.searchTitleKey),\r\n            searchEmptyTitle: this.translate.instant('agro.angular_components.lookup_nothing_found'),\r\n            filterLabel: this.translate.instant('agro.angular_components.lookup_filter'),\r\n            filterTitle: this.translate.instant('agro.angular_components.lookup_filters'),\r\n            clearLabel: this.translate.instant('agro.angular_components.lookup_clear'),\r\n            cancelLabel: this.translate.instant('agro.angular_components.lookup_cancel'),\r\n            selectLabel: this.translate.instant('agro.angular_components.lookup_select'),\r\n            suggestionsObservable: this.suggestionsSubject.asObservable(),\r\n            searchObservable: this.searchSubject.asObservable(),\r\n            onLookupRequest: createGenericOnLookupRequest({\r\n                config: this.config,\r\n                suggestionsSubject: this.suggestionsSubject,\r\n                searchSubject: this.searchSubject,\r\n            }),\r\n            onSearchRequest: createGenericOnSearchRequest({\r\n                config: this.config,\r\n                suggestionsSubject: this.suggestionsSubject,\r\n                searchSubject: this.searchSubject,\r\n            }),\r\n            onBlur: (event: any) => {\r\n                const control = this.config.formGroup.get(this.config.name);\r\n                if (control) {\r\n                    this.markControlAsUserInteracted(control);\r\n                    const uiRawValue = event?.target?.value ?? event?.value ?? '';\r\n                    const uiTextValue = typeof uiRawValue === 'string' ? uiRawValue.trim() : uiRawValue;\r\n                    const isUiEmpty = !uiTextValue;\r\n                    const currentValue = this.syncControlValueWithNormalization(control);\r\n                    const isValueValid = this.isLookupValueValid(currentValue);\r\n\r\n                    // If UI was cleared but control still has a value, force sync to null.\r\n                    if (isUiEmpty && currentValue != null && currentValue !== '') {\r\n                        control.setValue(null, { emitEvent: true });\r\n                        control.updateValueAndValidity({ emitEvent: true });\r\n                        return;\r\n                    }\r\n\r\n                    // If the control has a value but it's not a valid lookup object, clear it\r\n                    // This catches cases where the UI cleared the field but the FormControl wasn't updated\r\n                    if (currentValue && !isValueValid) {\r\n                        this.config.formGroup.patchValue({ [this.config.name]: null }, { emitEvent: true });\r\n                    }\r\n                }\r\n            },\r\n            onSelectHandler: (event: any) => {\r\n                const actualValue = event?.value || event;\r\n                const control = this.config.formGroup.get(this.config.name);\r\n                if (control && actualValue && typeof actualValue === 'object' && actualValue.id) {\r\n                    const normalizedValue = this.normalizeLookupValue(actualValue);\r\n                    this.markControlAsUserInteracted(control);\r\n                    control.setValue(normalizedValue, { emitEvent: true });\r\n                }\r\n            },\r\n            onSelect: (event: any) => {\r\n                const actualValue = event?.value || event;\r\n                const control = this.config.formGroup.get(this.config.name);\r\n                if (control && actualValue && typeof actualValue === 'object' && actualValue.id) {\r\n                    const normalizedValue = this.normalizeLookupValue(actualValue);\r\n                    this.markControlAsUserInteracted(control);\r\n                    control.setValue(normalizedValue, { emitEvent: true });\r\n                }\r\n            },\r\n            onClear: () => {\r\n                const control = this.config.formGroup.get(this.config.name);\r\n                if (control) {\r\n                    this.markControlAsUserInteracted(control);\r\n                    control.setValue(null, { emitEvent: true });\r\n                }\r\n            },\r\n            onChange: (event: any) => {\r\n                const control = this.config.formGroup.get(this.config.name);\r\n                const actualValue = event?.value || event;\r\n\r\n                if (control && actualValue && typeof actualValue === 'object') {\r\n                    const normalizedValue = this.normalizeLookupValue(actualValue);\r\n                    if (normalizedValue !== actualValue) {\r\n                        this.markControlAsUserInteracted(control);\r\n                        control.setValue(normalizedValue, { emitEvent: true });\r\n                        return;\r\n                    }\r\n                }\r\n\r\n                if (control && !actualValue) {\r\n                    this.markControlAsUserInteracted(control);\r\n                    control.setValue(null, { emitEvent: true });\r\n                }\r\n            },\r\n            onUnselect: () => {\r\n                const control = this.config.formGroup.get(this.config.name);\r\n                if (control) {\r\n                    this.markControlAsUserInteracted(control);\r\n                    control.setValue(null, { emitEvent: true });\r\n                }\r\n            },\r\n            searchFields: this.config.searchFields,\r\n            searchGridFields: this.config.searchFields,\r\n            appendTo: 'body',\r\n            baseZIndex: 10000,\r\n        };\r\n    }\r\n}\r\n\r\n\r\n"]}