@senior-agronegocio/angular-components 1.0.8 → 1.0.10

package/LLM_LIBRARY_GUIDES.md

@@ -6,4 +6,12 @@
 - 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,8 @@
-import { NgModule, InjectionToken } from "@angular/core";
+import { ENVIRONMENT_INITIALIZER, Injector, NgModule, inject } from "@angular/core";
+import { LIB_CONFIG } from "./lib-config.token";
+import { registerLookupRuntimeInjector } from "./fields/lookups/config/lookup-runtime-context";
 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 {
@@ -15,10 +17,24 @@ export class AgroAngularComponentsModule {
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AgroAngularComponentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
     static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: AgroAngularComponentsModule });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AgroAngularComponentsModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AgroAngularComponentsModule, providers: [
+            {
+                provide: ENVIRONMENT_INITIALIZER,
+                multi: true,
+                useValue: () => registerLookupRuntimeInjector(inject(Injector)),
+            }
+        ] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AgroAngularComponentsModule, decorators: [{
             type: NgModule,
-            args: [{}]
+            args: [{
+                    providers: [
+                        {
+                            provide: ENVIRONMENT_INITIALIZER,
+                            multi: true,
+                            useValue: () => registerLookupRuntimeInjector(inject(Injector)),
+                        }
+                    ]
+                }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdyby1hbmd1bGFyLWNvbXBvbmVudHMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2Fncm8tYW5ndWxhci1jb21wb25lbnRzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXVCLFFBQVEsRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTzlFLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxJQUFJLGNBQWMsQ0FBcUIsNkJBQTZCLENBQUMsQ0FBQztBQUloRyxNQUFNLE9BQU8sMkJBQTJCO0lBQ3BDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBMEI7UUFDckMsT0FBTztZQUNILFFBQVEsRUFBRSwyQkFBMkI7WUFDckMsU0FBUyxFQUFFO2dCQUNQO29CQUNJLE9BQU8sRUFBRSxVQUFVO29CQUNuQixRQUFRLEVBQUUsTUFBTTtpQkFDbkI7YUFDSjtTQUNKLENBQUM7SUFDTixDQUFDO3dHQVhRLDJCQUEyQjt5R0FBM0IsMkJBQTJCO3lHQUEzQiwyQkFBMkI7OzRGQUEzQiwyQkFBMkI7a0JBRnZDLFFBQVE7bUJBQUMsRUFDVCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vZHVsZVdpdGhQcm92aWRlcnMsIE5nTW9kdWxlLCBJbmplY3Rpb25Ub2tlbiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEhvc3RQcm9qZWN0Q29uZmlncyB7XHJcbiAgICBkb21haW46IHN0cmluZztcclxuICAgIHNlcnZpY2U6IHN0cmluZztcclxufVxyXG5cclxuZXhwb3J0IGNvbnN0IExJQl9DT05GSUcgPSBuZXcgSW5qZWN0aW9uVG9rZW48SG9zdFByb2plY3RDb25maWdzPihcIkFncm9Bbmd1bGFyQ29tcG9uZW50c0NvbmZpZ1wiKTtcclxuXHJcbkBOZ01vZHVsZSh7XHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBBZ3JvQW5ndWxhckNvbXBvbmVudHNNb2R1bGUge1xyXG4gICAgc3RhdGljIGZvclJvb3QoY29uZmlnOiBIb3N0UHJvamVjdENvbmZpZ3MpOiBNb2R1bGVXaXRoUHJvdmlkZXJzPEFncm9Bbmd1bGFyQ29tcG9uZW50c01vZHVsZT4ge1xyXG4gICAgICAgIHJldHVybiB7XHJcbiAgICAgICAgICAgIG5nTW9kdWxlOiBBZ3JvQW5ndWxhckNvbXBvbmVudHNNb2R1bGUsXHJcbiAgICAgICAgICAgIHByb3ZpZGVyczogW1xyXG4gICAgICAgICAgICAgICAge1xyXG4gICAgICAgICAgICAgICAgICAgIHByb3ZpZGU6IExJQl9DT05GSUcsXHJcbiAgICAgICAgICAgICAgICAgICAgdXNlVmFsdWU6IGNvbmZpZ1xyXG4gICAgICAgICAgICAgICAgfVxyXG4gICAgICAgICAgICBdXHJcbiAgICAgICAgfTtcclxuICAgIH1cclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,10 @@
+export function resolveLookupHostProjectConfig(config, serviceName) {
+    const domain = config?.domain;
+    const service = config?.service;
+    if (domain && service) {
+        return { domain, service };
+    }
+    throw new Error(`[${serviceName}] Missing host project configuration. ` +
+        `Provide 'domain' and 'service' in the lookup config or configure LIB_CONFIG in the module.`);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9va3VwLWhvc3QtcHJvamVjdC1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLWNvbXBvbmVudHMvZmllbGRzL2xvb2t1cHMvY29uZmlnL2xvb2t1cC1ob3N0LXByb2plY3QtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSw4QkFBOEIsQ0FDMUMsTUFBc0QsRUFDdEQsV0FBbUI7SUFFbkIsTUFBTSxNQUFNLEdBQUcsTUFBTSxFQUFFLE1BQU0sQ0FBQztJQUM5QixNQUFNLE9BQU8sR0FBRyxNQUFNLEVBQUUsT0FBTyxDQUFDO0lBRWhDLElBQUksTUFBTSxJQUFJLE9BQU8sRUFBRSxDQUFDO1FBQ3BCLE9BQU8sRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVELE1BQU0sSUFBSSxLQUFLLENBQ1gsSUFBSSxXQUFXLHdDQUF3QztRQUN2RCw0RkFBNEYsQ0FDL0YsQ0FBQztBQUNOLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIb3N0UHJvamVjdENvbmZpZ3MgfSBmcm9tICcuLi8uLi8uLi9saWItY29uZmlnLnRva2VuJztcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiByZXNvbHZlTG9va3VwSG9zdFByb2plY3RDb25maWcoXHJcbiAgICBjb25maWc6IFBhcnRpYWw8SG9zdFByb2plY3RDb25maWdzPiB8IG51bGwgfCB1bmRlZmluZWQsXHJcbiAgICBzZXJ2aWNlTmFtZTogc3RyaW5nXHJcbik6IEhvc3RQcm9qZWN0Q29uZmlncyB7XHJcbiAgICBjb25zdCBkb21haW4gPSBjb25maWc/LmRvbWFpbjtcclxuICAgIGNvbnN0IHNlcnZpY2UgPSBjb25maWc/LnNlcnZpY2U7XHJcblxyXG4gICAgaWYgKGRvbWFpbiAmJiBzZXJ2aWNlKSB7XHJcbiAgICAgICAgcmV0dXJuIHsgZG9tYWluLCBzZXJ2aWNlIH07XHJcbiAgICB9XHJcblxyXG4gICAgdGhyb3cgbmV3IEVycm9yKFxyXG4gICAgICAgIGBbJHtzZXJ2aWNlTmFtZX1dIE1pc3NpbmcgaG9zdCBwcm9qZWN0IGNvbmZpZ3VyYXRpb24uIGAgK1xyXG4gICAgICAgIGBQcm92aWRlICdkb21haW4nIGFuZCAnc2VydmljZScgaW4gdGhlIGxvb2t1cCBjb25maWcgb3IgY29uZmlndXJlIExJQl9DT05GSUcgaW4gdGhlIG1vZHVsZS5gXHJcbiAgICApO1xyXG59XHJcbiJdfQ==

package/esm2022/fields/lookups/config/lookup-runtime-context.mjs

@@ -0,0 +1,12 @@
+let runtimeInjector = null;
+export function registerLookupRuntimeInjector(injector) {
+    runtimeInjector = injector;
+}
+export function resolveLookupRuntimeInjector(callerName) {
+    if (!runtimeInjector) {
+        throw new Error(`[${callerName}] No runtime injector registered. ` +
+            `Import AgroAngularComponentsModule in your AppModule or call registerLookupRuntimeInjector().`);
+    }
+    return runtimeInjector;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9va3VwLXJ1bnRpbWUtY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9maWVsZHMvbG9va3Vwcy9jb25maWcvbG9va3VwLXJ1bnRpbWUtY29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxJQUFJLGVBQWUsR0FBb0IsSUFBSSxDQUFDO0FBRTVDLE1BQU0sVUFBVSw2QkFBNkIsQ0FBQyxRQUFrQjtJQUM1RCxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQy9CLENBQUM7QUFFRCxNQUFNLFVBQVUsNEJBQTRCLENBQUMsVUFBa0I7SUFDM0QsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBQ25CLE1BQU0sSUFBSSxLQUFLLENBQ1gsSUFBSSxVQUFVLG9DQUFvQztZQUNsRCwrRkFBK0YsQ0FDbEcsQ0FBQztJQUNOLENBQUM7SUFDRCxPQUFPLGVBQWUsQ0FBQztBQUMzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmxldCBydW50aW1lSW5qZWN0b3I6IEluamVjdG9yIHwgbnVsbCA9IG51bGw7XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gcmVnaXN0ZXJMb29rdXBSdW50aW1lSW5qZWN0b3IoaW5qZWN0b3I6IEluamVjdG9yKTogdm9pZCB7XHJcbiAgICBydW50aW1lSW5qZWN0b3IgPSBpbmplY3RvcjtcclxufVxyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVMb29rdXBSdW50aW1lSW5qZWN0b3IoY2FsbGVyTmFtZTogc3RyaW5nKTogSW5qZWN0b3Ige1xyXG4gICAgaWYgKCFydW50aW1lSW5qZWN0b3IpIHtcclxuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoXHJcbiAgICAgICAgICAgIGBbJHtjYWxsZXJOYW1lfV0gTm8gcnVudGltZSBpbmplY3RvciByZWdpc3RlcmVkLiBgICtcclxuICAgICAgICAgICAgYEltcG9ydCBBZ3JvQW5ndWxhckNvbXBvbmVudHNNb2R1bGUgaW4geW91ciBBcHBNb2R1bGUgb3IgY2FsbCByZWdpc3Rlckxvb2t1cFJ1bnRpbWVJbmplY3RvcigpLmBcclxuICAgICAgICApO1xyXG4gICAgfVxyXG4gICAgcmV0dXJuIHJ1bnRpbWVJbmplY3RvcjtcclxufVxyXG4iXX0=

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"]}

package/esm2022/fields/lookups/core/agro-branch-lookup.mjs

@@ -0,0 +1,27 @@
+import { AgroLookupEntityService } from '../services/agro-lookup-entity.service';
+import { resolveLookupHostProjectConfig } from '../config/lookup-host-project-config';
+import { AgroLookupBase } from './agro-lookup-base';
+export class AgroBranchLookup extends AgroLookupBase {
+    e070FilService;
+    constructor(config) {
+        super(config, { defaultFieldName: 'branch', defaultFilterFieldName: 'branch.id' });
+        this.e070FilService = new AgroLookupEntityService(resolveLookupHostProjectConfig(config, AgroBranchLookup.name), 'entities/e070fil');
+    }
+    getLookupConfig() {
+        return {
+            labelKey: 'agro.angular_components.lookup_contract_branch',
+            searchTitleKey: 'agro.angular_components.lookup_contract_branch_search_title',
+            lookupDisplayFields: ['codFil', 'nomFil'],
+            advancedDisplayFields: ['codFil', 'nomFil'],
+            searchFields: [
+                { name: 'codFil', label: this.translate.instant('agro.angular_components.lookup_label_code'), type: 'integer', allowNegative: false, precision: 11, scale: 0 },
+                { name: 'nomFil', label: this.translate.instant('agro.angular_components.lookup_label_branch'), type: 'string' },
+                { name: 'numCgc', label: this.translate.instant('agro.angular_components.lookup_e_070_fil_num_cgc'), type: 'string' },
+                { name: 'cidFil', label: this.translate.instant('agro.angular_components.lookup_label_city'), type: 'string' },
+            ],
+            dependencies: [{ formControlName: 'company', apiField: 'e070emp.id' }],
+            service: this.e070FilService,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdyby1icmFuY2gtbG9va3VwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL2ZpZWxkcy9sb29rdXBzL2NvcmUvYWdyby1icmFuY2gtbG9va3VwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ2pGLE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ3RGLE9BQU8sRUFBRSxjQUFjLEVBQXdCLE1BQU0sb0JBQW9CLENBQUM7QUFHMUUsTUFBTSxPQUFPLGdCQUFpQixTQUFRLGNBQWM7SUFDL0IsY0FBYyxDQUFtQztJQUVsRSxZQUFZLE1BQTBDO1FBQ2xELEtBQUssQ0FBQyxNQUFNLEVBQUUsRUFBRSxnQkFBZ0IsRUFBRSxRQUFRLEVBQUUsc0JBQXNCLEVBQUUsV0FBVyxFQUFFLENBQUMsQ0FBQztRQUNuRixJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksdUJBQXVCLENBQzdDLDhCQUE4QixDQUFDLE1BQU0sRUFBRSxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsRUFDN0Qsa0JBQWtCLENBQ3JCLENBQUM7SUFDTixDQUFDO0lBRUQsZUFBZTtRQUNYLE9BQU87WUFDSCxRQUFRLEVBQUUsZ0RBQWdEO1lBQzFELGNBQWMsRUFBRSw2REFBNkQ7WUFDN0UsbUJBQW1CLEVBQUUsQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDO1lBQ3pDLHFCQUFxQixFQUFFLENBQUMsUUFBUSxFQUFFLFFBQVEsQ0FBQztZQUMzQyxZQUFZLEVBQUU7Z0JBQ1YsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQywyQ0FBMkMsQ0FBQyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsYUFBYSxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUU7Z0JBQzlKLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsNkNBQTZDLENBQUMsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFO2dCQUNoSCxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLGtEQUFrRCxDQUFDLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTtnQkFDckgsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQywyQ0FBMkMsQ0FBQyxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUU7YUFDakg7WUFDRCxZQUFZLEVBQUUsQ0FBQyxFQUFFLGVBQWUsRUFBRSxTQUFTLEVBQUUsUUFBUSxFQUFFLFlBQVksRUFBRSxDQUFDO1lBQ3RFLE9BQU8sRUFBRSxJQUFJLENBQUMsY0FBYztTQUMvQixDQUFDO0lBQ04sQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWdyb0xvb2t1cEVudGl0eVNlcnZpY2UgfSBmcm9tICcuLi9zZXJ2aWNlcy9hZ3JvLWxvb2t1cC1lbnRpdHkuc2VydmljZSc7XHJcbmltcG9ydCB7IHJlc29sdmVMb29rdXBIb3N0UHJvamVjdENvbmZpZyB9IGZyb20gJy4uL2NvbmZpZy9sb29rdXAtaG9zdC1wcm9qZWN0LWNvbmZpZyc7XHJcbmltcG9ydCB7IEFncm9Mb29rdXBCYXNlLCBMb29rdXBTcGVjaWZpY0NvbmZpZyB9IGZyb20gJy4vYWdyby1sb29rdXAtYmFzZSc7XHJcbmltcG9ydCB7IFNoYXJlZExvb2t1cEZpZWxkQ29uc3RydWN0b3JDb25maWcgfSBmcm9tICcuL2xvb2t1cC1maWVsZC50eXBlcyc7XHJcblxyXG5leHBvcnQgY2xhc3MgQWdyb0JyYW5jaExvb2t1cCBleHRlbmRzIEFncm9Mb29rdXBCYXNlIHtcclxuICAgIHByaXZhdGUgcmVhZG9ubHkgZTA3MEZpbFNlcnZpY2U6IEFncm9Mb29rdXBFbnRpdHlTZXJ2aWNlPHVua25vd24+O1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKGNvbmZpZzogU2hhcmVkTG9va3VwRmllbGRDb25zdHJ1Y3RvckNvbmZpZykge1xyXG4gICAgICAgIHN1cGVyKGNvbmZpZywgeyBkZWZhdWx0RmllbGROYW1lOiAnYnJhbmNoJywgZGVmYXVsdEZpbHRlckZpZWxkTmFtZTogJ2JyYW5jaC5pZCcgfSk7XHJcbiAgICAgICAgdGhpcy5lMDcwRmlsU2VydmljZSA9IG5ldyBBZ3JvTG9va3VwRW50aXR5U2VydmljZShcclxuICAgICAgICAgICAgcmVzb2x2ZUxvb2t1cEhvc3RQcm9qZWN0Q29uZmlnKGNvbmZpZywgQWdyb0JyYW5jaExvb2t1cC5uYW1lKSxcclxuICAgICAgICAgICAgJ2VudGl0aWVzL2UwNzBmaWwnXHJcbiAgICAgICAgKTtcclxuICAgIH1cclxuXHJcbiAgICBnZXRMb29rdXBDb25maWcoKTogTG9va3VwU3BlY2lmaWNDb25maWcge1xyXG4gICAgICAgIHJldHVybiB7XHJcbiAgICAgICAgICAgIGxhYmVsS2V5OiAnYWdyby5hbmd1bGFyX2NvbXBvbmVudHMubG9va3VwX2NvbnRyYWN0X2JyYW5jaCcsXHJcbiAgICAgICAgICAgIHNlYXJjaFRpdGxlS2V5OiAnYWdyby5hbmd1bGFyX2NvbXBvbmVudHMubG9va3VwX2NvbnRyYWN0X2JyYW5jaF9zZWFyY2hfdGl0bGUnLFxyXG4gICAgICAgICAgICBsb29rdXBEaXNwbGF5RmllbGRzOiBbJ2NvZEZpbCcsICdub21GaWwnXSxcclxuICAgICAgICAgICAgYWR2YW5jZWREaXNwbGF5RmllbGRzOiBbJ2NvZEZpbCcsICdub21GaWwnXSxcclxuICAgICAgICAgICAgc2VhcmNoRmllbGRzOiBbXHJcbiAgICAgICAgICAgICAgICB7IG5hbWU6ICdjb2RGaWwnLCBsYWJlbDogdGhpcy50cmFuc2xhdGUuaW5zdGFudCgnYWdyby5hbmd1bGFyX2NvbXBvbmVudHMubG9va3VwX2xhYmVsX2NvZGUnKSwgdHlwZTogJ2ludGVnZXInLCBhbGxvd05lZ2F0aXZlOiBmYWxzZSwgcHJlY2lzaW9uOiAxMSwgc2NhbGU6IDAgfSxcclxuICAgICAgICAgICAgICAgIHsgbmFtZTogJ25vbUZpbCcsIGxhYmVsOiB0aGlzLnRyYW5zbGF0ZS5pbnN0YW50KCdhZ3JvLmFuZ3VsYXJfY29tcG9uZW50cy5sb29rdXBfbGFiZWxfYnJhbmNoJyksIHR5cGU6ICdzdHJpbmcnIH0sXHJcbiAgICAgICAgICAgICAgICB7IG5hbWU6ICdudW1DZ2MnLCBsYWJlbDogdGhpcy50cmFuc2xhdGUuaW5zdGFudCgnYWdyby5hbmd1bGFyX2NvbXBvbmVudHMubG9va3VwX2VfMDcwX2ZpbF9udW1fY2djJyksIHR5cGU6ICdzdHJpbmcnIH0sXHJcbiAgICAgICAgICAgICAgICB7IG5hbWU6ICdjaWRGaWwnLCBsYWJlbDogdGhpcy50cmFuc2xhdGUuaW5zdGFudCgnYWdyby5hbmd1bGFyX2NvbXBvbmVudHMubG9va3VwX2xhYmVsX2NpdHknKSwgdHlwZTogJ3N0cmluZycgfSxcclxuICAgICAgICAgICAgXSxcclxuICAgICAgICAgICAgZGVwZW5kZW5jaWVzOiBbeyBmb3JtQ29udHJvbE5hbWU6ICdjb21wYW55JywgYXBpRmllbGQ6ICdlMDcwZW1wLmlkJyB9XSxcclxuICAgICAgICAgICAgc2VydmljZTogdGhpcy5lMDcwRmlsU2VydmljZSxcclxuICAgICAgICB9O1xyXG4gICAgfVxyXG59XHJcblxyXG4iXX0=