bways-report 0.1.5 → 0.1.6

package/README.md

@@ -7,6 +7,7 @@ It allows non-developers to visually design reporting pages with filters, KPI me
 ---
 [![npm version](https://img.shields.io/npm/v/bways-report.svg)](https://www.npmjs.com/package/bways-report)
 [![license](https://img.shields.io/npm/l/bways-report.svg)](https://github.com/ccplProject/BWays-CustomeReport)
+[![Changelog](https://img.shields.io/badge/Changelog-v0.1.6-blue.svg)](CHANGELOG.md)
 ---
 
 ## Table of Contents
@@ -25,6 +26,11 @@ It allows non-developers to visually design reporting pages with filters, KPI me
 5. [Routing & ERP Navigation Integration](#5-routing--erp-navigation-integration)
 6. [Drill-Down Drill-Through & Slide-Over Drawers](#6-drill-down--slide-over-drawers)
 7. [Starter Blueprints Gallery & Branded Exports](#7-starter-blueprints--branded-exports)
+8. [Grid Bridge & Circular Echo Suppression](#8-grid-bridge--circular-echo-suppression)
+9. [Stored Procedure Discovery & Smart Parameter Mapping](#9-stored-procedure-discovery--smart-parameter-mapping)
+10. [Theming & CSS Custom Properties](#10-theming--css-custom-properties)
+11. [Exporting Data (CSV & JSON)](#11-exporting-data-csv--json)
+12. [Changelog & Version History](#12-changelog--version-history)
 
 ---
 
@@ -456,7 +462,67 @@ If not provided, the built-in SVG visual chart renderer outputs crisp, responsiv
 
 ---
 
-## 7. Theming & CSS Custom Properties
+## 8. Grid Bridge & Circular Echo Suppression
+
+`bways-report` features an intelligent runtime bridge (`ReportGridBridgeComponent` and `RptGridOutletDirective`) that connects any underlying grid library (e.g., `UltraGridComponent` from `bways-grid`) to the dynamic report state:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Design Canvas / Runtime                   │
+│                                                             │
+│   [gridDefinition] (ReportGridDefinition)                   │
+│         │                                                   │
+│         ▼                                                   │
+│   ┌─────────────────────────────────────────────────────┐   │
+│   │             ReportGridBridgeComponent               │   │
+│   │                                                     │   │
+│   │   - gridInputs: transforms definition into inputs   │   │
+│   │   - gridReportState: preserves active & condition   │   │
+│   │     filters from serialized report state            │   │
+│   │                                                     │   │
+│   │   ┌─────────────────────────────────────────────┐   │   │
+│   │   │           RptGridOutletDirective            │   │   │
+│   │   │                                             │   │   │
+│   │   │   - Circular Echo Suppression:              │   │   │
+│   │   │     Tracks last emitted state & col-defs    │   │   │
+│   │   │     Skips setInput when update came from    │   │   │
+│   │   │     the grid itself.                        │   │   │
+│   │   └─────────────────────┬───────────────────────┘   │   │
+│   └─────────────────────────┼───────────────────────────┘   │
+│                             │                               │
+│                             ▼                               │
+│                 ┌───────────────────────┐                   │
+│                 │  UltraGridComponent   │                   │
+│                 │   (Live ERP Grid)     │                   │
+│                 └───────────────────────┘                   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Key Capabilities:
+- **Interactive Filtering without Popover Dismissal**: In traditional bindings, when a user types in a filter or checks a box, parent state updates re-trigger `setInput`, causing the grid to re-initialize headers and snap popovers shut. `RptGridOutletDirective` compares incoming states (`isReportStateMatching`) against the grid's own latest emission, preventing unnecessary re-renders.
+- **Layout Auto-Persist vs. Runtime Filtering**:
+  - **Structural Layout** changes (`groupModel`, `sortModel`, column widths, visibility) trigger immediate persistence and display the `"Layout auto-persisted"` status banner.
+  - **Column Data Filtering** (`activeFilters`, `conditionFilters`) is treated as runtime data exploration: debounced (1200ms) with `{ skipHistory: true }`, ensuring undo/redo stacks aren't flooded with intermediate keystrokes.
+- **Full Filter State Preservation**: Filter sets and expressions are preserved intact in `options.reportState` when saved or exported.
+
+---
+
+## 9. Stored Procedure Discovery & Smart Parameter Mapping
+
+`bways-report` integrates with SQL Server stored procedures via `HttpReportSchemaDiscoveryAdapter`:
+
+1. **Introspection (`sys.parameters`)**: Queries stored procedure signatures, determining data types, nullability, and default expressions.
+2. **Smart Control Inference**:
+   - Date parameters (`@FromDate`, `@ToDate`, `@AsOnDate`) automatically suggest date-picker or date-range controls.
+   - Master entity parameters (`@SubGLCode`, `@BranchId`, `@CustomerId`) infer dropdown lookups from associated tables or views.
+3. **Lookup Deduplication & Account Resolution**:
+   - `identifier-humanizer.ts` prioritizes unique account numbers (`_acno`, `glacno`, `account_no`) over category codes (`_code`), preventing duplicate collapsing of customer accounts in dropdown lookups.
+4. **Session Token Binding**:
+   - Parameters matching ERP session context (`@BranchId`, `@CompanyId`, `@FinYearId`) are automatically resolved via `SessionContextProvider` without manual user intervention.
+
+---
+
+## 10. Theming & CSS Custom Properties
 
 `bways-report` uses CSS custom properties (`--rpt-*`) throughout all components, ensuring seamless alignment with your ERP application's design system:
 
@@ -490,40 +556,7 @@ If not provided, the built-in SVG visual chart renderer outputs crisp, responsiv
 
 ---
 
-## 8. Registering Custom Host Controls
-
-You can register custom Angular components (e.g., custom slider, multi-select, rich customer picker) into the `ComponentRegistry` so they appear in the Visual Designer palette and render dynamically at runtime:
-
-```typescript
-import { ComponentRegistry, ComponentMetadata } from 'bways-report';
-import { MyCustomPickerComponent } from './my-custom-picker.component';
-
-export function configureCustomControls(registry: ComponentRegistry): void {
-  registry.register({
-    type: 'customer-picker',
-    displayName: 'Customer Picker',
-    category: 'input',
-    icon: 'person_search',
-    component: MyCustomPickerComponent,
-    createDefaultConfig: () => ({
-      id: 'cust-picker',
-      type: 'customer-picker',
-      label: 'Select Customer',
-      properties: { placeholder: 'Search customer...' },
-      layout: { columnSpan: 4 },
-    }),
-    propertySchema: [
-      { key: 'label', label: 'Label', type: 'string', required: true, group: 'General' },
-      { key: 'key', label: 'Field Name (Key)', type: 'string', required: true, group: 'General' },
-      { key: 'required', label: 'Required', type: 'boolean', group: 'Validation' },
-    ],
-  });
-}
-```
-
----
-
-## 9. Exporting Data (CSV & JSON)
+## 11. Exporting Data (CSV & JSON)
 
 Use `ReportExportService` for one-click file generation:
 
@@ -574,6 +607,13 @@ export class ExportActionsComponent {
 
 ---
 
+## 12. Changelog & Version History
+
+For a complete record of releases, breaking changes, and bug fixes, refer to the **[Changelog](CHANGELOG.md)**.
+
+---
+
 ## License
 
 MIT © BWays Technologies
+

package/esm2022/lib/core/services/index.mjs

@@ -1,4 +1,5 @@
 export { DynamicFormBuilder } from './dynamic-form-builder.service';
 export { ReportSessionContextService } from './report-session-context.service';
 export { ReportStorageService } from './report-storage.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBSy9FLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRHluYW1pY0Zvcm1CdWlsZGVyIH0gZnJvbSAnLi9keW5hbWljLWZvcm0tYnVpbGRlci5zZXJ2aWNlJztcbmV4cG9ydCB7IFJlcG9ydFNlc3Npb25Db250ZXh0U2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXNlc3Npb24tY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHtcbiAgU2Vzc2lvblBhcmFtTWF0Y2gsXG4gIERlcml2ZWRQYXJhbWV0ZXJzUmVzdWx0LFxufSBmcm9tICcuL3JlcG9ydC1zZXNzaW9uLWNvbnRleHQuc2VydmljZSc7XG5leHBvcnQgeyBSZXBvcnRTdG9yYWdlU2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXN0b3JhZ2Uuc2VydmljZSc7XG4iXX0=
+export { ReportDataDiscoveryService } from './report-data-discovery.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBSy9FLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRHluYW1pY0Zvcm1CdWlsZGVyIH0gZnJvbSAnLi9keW5hbWljLWZvcm0tYnVpbGRlci5zZXJ2aWNlJztcbmV4cG9ydCB7IFJlcG9ydFNlc3Npb25Db250ZXh0U2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXNlc3Npb24tY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHtcbiAgU2Vzc2lvblBhcmFtTWF0Y2gsXG4gIERlcml2ZWRQYXJhbWV0ZXJzUmVzdWx0LFxufSBmcm9tICcuL3JlcG9ydC1zZXNzaW9uLWNvbnRleHQuc2VydmljZSc7XG5leHBvcnQgeyBSZXBvcnRTdG9yYWdlU2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXN0b3JhZ2Uuc2VydmljZSc7XG5leHBvcnQgeyBSZXBvcnREYXRhRGlzY292ZXJ5U2VydmljZSB9IGZyb20gJy4vcmVwb3J0LWRhdGEtZGlzY292ZXJ5LnNlcnZpY2UnO1xuIl19

package/esm2022/lib/core/services/report-data-discovery.service.mjs

@@ -0,0 +1,135 @@
+import { inject, Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { ReportSchemaDiscoveryAdapter, } from '../../data-access/contracts/schema-discovery.contract';
+import { ReportLookupAdapter } from '../../data-access/contracts/lookup.contract';
+import { ReportSessionContextService } from './report-session-context.service';
+import { resolveParameterMappings } from '../utils/report-parameter.util';
+import { humanizeIdentifier } from '../utils/identifier-humanizer';
+import * as i0 from "@angular/core";
+/**
+ * Centralized service for discovering database schema entities, parameters,
+ * and column definitions.
+ *
+ * Provides a unified static + dynamic detection pipeline:
+ * If static schema metadata discovery fails (e.g. SQL Server stored procedures
+ * using #temp tables that cannot be analyzed statically), it automatically
+ * falls back to executing a safe dynamic sample query with the active parameter
+ * values and extracting column definitions from the result dataset.
+ */
+export class ReportDataDiscoveryService {
+    discoveryAdapter = inject(ReportSchemaDiscoveryAdapter, { optional: true });
+    lookupAdapter = inject(ReportLookupAdapter, { optional: true });
+    sessionService = inject(ReportSessionContextService, { optional: true });
+    /**
+     * Retrieves all database tables, views, and stored procedures.
+     */
+    getEntities(types) {
+        if (!this.discoveryAdapter) {
+            return of([]);
+        }
+        return this.discoveryAdapter.getEntities(types).pipe(catchError((err) => {
+            console.warn('[ReportDataDiscoveryService] Failed to get entities:', err);
+            return of([]);
+        }));
+    }
+    /**
+     * Retrieves stored procedure parameter metadata.
+     */
+    getParameters(procedureName, schema = 'dbo') {
+        if (!procedureName || !this.discoveryAdapter) {
+            return of([]);
+        }
+        return this.discoveryAdapter.getParameters(procedureName, schema).pipe(catchError((err) => {
+            console.warn(`[ReportDataDiscoveryService] Failed to get parameters for ${procedureName}:`, err);
+            return of([]);
+        }));
+    }
+    /**
+     * Unified column detection:
+     * 1. Attempts static schema discovery via ReportSchemaDiscoveryAdapter.
+     * 2. If static discovery returns 0 columns or throws an error (e.g. SQL Error 11526 with #temp tables),
+     *    automatically runs dynamic sample query via ReportLookupAdapter using resolved parameters.
+     */
+    autoDetectColumns(entityName, entityType = 'stored_procedure', mappings = {}, schema = 'dbo') {
+        if (!entityName) {
+            return of([]);
+        }
+        // Try static discovery first
+        if (this.discoveryAdapter) {
+            return this.discoveryAdapter.getColumns(entityName, schema, entityType).pipe(map((cols) => {
+                if (cols && cols.length > 0) {
+                    return this.mapStaticColumnsToGrid(cols);
+                }
+                throw new Error('STATIC_EMPTY');
+            }), catchError(() => {
+                // Fallback to dynamic execution
+                return this.fallbackDynamicDetection(entityName, entityType, mappings, schema);
+            }));
+        }
+        return this.fallbackDynamicDetection(entityName, entityType, mappings, schema);
+    }
+    mapStaticColumnsToGrid(cols) {
+        return cols.map((c) => ({
+            field: c.field,
+            label: humanizeIdentifier(c.label || c.field),
+            dataType: c.dataType || 'string',
+            visible: true,
+            sortable: true,
+            align: c.dataType === 'number' ? 'right' : 'left',
+        }));
+    }
+    fallbackDynamicDetection(entityName, sourceType, mappings, schema = 'dbo') {
+        if (!this.lookupAdapter) {
+            return of([]);
+        }
+        const session = this.sessionService?.getCurrentSessionContext() ?? {};
+        const resolvedParams = resolveParameterMappings(mappings, session, {});
+        return this.lookupAdapter
+            .fetchOptions({
+            sourceType: (sourceType === 'stored_procedure' ? 'procedure' : sourceType),
+            entityName,
+            schema,
+            valueField: '',
+            displayField: '',
+            parameters: resolvedParams,
+        })
+            .pipe(map((items) => {
+            if (items && items.length > 0 && items[0].raw) {
+                const sampleRow = items[0].raw;
+                const keys = Object.keys(sampleRow);
+                if (keys.length > 0) {
+                    return keys.map((key) => {
+                        const val = sampleRow[key];
+                        let type = 'string';
+                        if (typeof val === 'number')
+                            type = 'number';
+                        else if (typeof val === 'boolean')
+                            type = 'boolean';
+                        else if (typeof val === 'string' && /^\d{4}-\d{2}-\d{2}/.test(val))
+                            type = 'date';
+                        return {
+                            field: key,
+                            label: humanizeIdentifier(key),
+                            dataType: type,
+                            visible: true,
+                            sortable: true,
+                            align: (type === 'number' ? 'right' : 'left'),
+                        };
+                    });
+                }
+            }
+            return [];
+        }), catchError((err) => {
+            console.warn(`[ReportDataDiscoveryService] Dynamic sample detection failed for ${entityName}:`, err);
+            return of([]);
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportDataDiscoveryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportDataDiscoveryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportDataDiscoveryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-data-discovery.service.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/services/report-data-discovery.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport {\n  DatabaseEntityMetadata,\n  DatabaseEntityType,\n  EntityColumnMetadata,\n  ProcedureParameterMetadata,\n  ReportSchemaDiscoveryAdapter,\n} from '../../data-access/contracts/schema-discovery.contract';\nimport { ReportLookupAdapter } from '../../data-access/contracts/lookup.contract';\nimport { ReportSessionContextService } from './report-session-context.service';\nimport { GridColumnDefinition } from '../models/report-grid.model';\nimport { DropdownSourceType } from '../models/report-component.model';\nimport { resolveParameterMappings } from '../utils/report-parameter.util';\nimport { humanizeIdentifier } from '../utils/identifier-humanizer';\n\n/**\n * Centralized service for discovering database schema entities, parameters,\n * and column definitions.\n *\n * Provides a unified static + dynamic detection pipeline:\n * If static schema metadata discovery fails (e.g. SQL Server stored procedures\n * using #temp tables that cannot be analyzed statically), it automatically\n * falls back to executing a safe dynamic sample query with the active parameter\n * values and extracting column definitions from the result dataset.\n */\n@Injectable({ providedIn: 'root' })\nexport class ReportDataDiscoveryService {\n  private readonly discoveryAdapter = inject(ReportSchemaDiscoveryAdapter, { optional: true });\n  private readonly lookupAdapter = inject(ReportLookupAdapter, { optional: true });\n  private readonly sessionService = inject(ReportSessionContextService, { optional: true });\n\n  /**\n   * Retrieves all database tables, views, and stored procedures.\n   */\n  getEntities(types?: DatabaseEntityType[]): Observable<DatabaseEntityMetadata[]> {\n    if (!this.discoveryAdapter) {\n      return of([]);\n    }\n    return this.discoveryAdapter.getEntities(types).pipe(\n      catchError((err) => {\n        console.warn('[ReportDataDiscoveryService] Failed to get entities:', err);\n        return of([]);\n      })\n    );\n  }\n\n  /**\n   * Retrieves stored procedure parameter metadata.\n   */\n  getParameters(procedureName: string, schema = 'dbo'): Observable<ProcedureParameterMetadata[]> {\n    if (!procedureName || !this.discoveryAdapter) {\n      return of([]);\n    }\n    return this.discoveryAdapter.getParameters(procedureName, schema).pipe(\n      catchError((err) => {\n        console.warn(`[ReportDataDiscoveryService] Failed to get parameters for ${procedureName}:`, err);\n        return of([]);\n      })\n    );\n  }\n\n  /**\n   * Unified column detection:\n   * 1. Attempts static schema discovery via ReportSchemaDiscoveryAdapter.\n   * 2. If static discovery returns 0 columns or throws an error (e.g. SQL Error 11526 with #temp tables),\n   *    automatically runs dynamic sample query via ReportLookupAdapter using resolved parameters.\n   */\n  autoDetectColumns(\n    entityName: string,\n    entityType: 'table' | 'stored_procedure' = 'stored_procedure',\n    mappings: Record<string, unknown> = {},\n    schema = 'dbo'\n  ): Observable<GridColumnDefinition[]> {\n    if (!entityName) {\n      return of([]);\n    }\n\n    // Try static discovery first\n    if (this.discoveryAdapter) {\n      return this.discoveryAdapter.getColumns(entityName, schema, entityType).pipe(\n        map((cols) => {\n          if (cols && cols.length > 0) {\n            return this.mapStaticColumnsToGrid(cols);\n          }\n          throw new Error('STATIC_EMPTY');\n        }),\n        catchError(() => {\n          // Fallback to dynamic execution\n          return this.fallbackDynamicDetection(entityName, entityType, mappings, schema);\n        })\n      );\n    }\n\n    return this.fallbackDynamicDetection(entityName, entityType, mappings, schema);\n  }\n\n  private mapStaticColumnsToGrid(cols: EntityColumnMetadata[]): GridColumnDefinition[] {\n    return cols.map((c) => ({\n      field: c.field,\n      label: humanizeIdentifier(c.label || c.field),\n      dataType: (c.dataType as any) || 'string',\n      visible: true,\n      sortable: true,\n      align: c.dataType === 'number' ? 'right' : 'left',\n    }));\n  }\n\n  private fallbackDynamicDetection(\n    entityName: string,\n    sourceType: 'table' | 'stored_procedure',\n    mappings: Record<string, unknown>,\n    schema = 'dbo'\n  ): Observable<GridColumnDefinition[]> {\n    if (!this.lookupAdapter) {\n      return of([]);\n    }\n\n    const session = this.sessionService?.getCurrentSessionContext() ?? {};\n    const resolvedParams = resolveParameterMappings(mappings as any, session, {});\n\n    return this.lookupAdapter\n      .fetchOptions({\n        sourceType: (sourceType === 'stored_procedure' ? 'procedure' : sourceType) as DropdownSourceType,\n        entityName,\n        schema,\n        valueField: '',\n        displayField: '',\n        parameters: resolvedParams,\n      })\n      .pipe(\n        map((items) => {\n          if (items && items.length > 0 && items[0].raw) {\n            const sampleRow = items[0].raw as Record<string, unknown>;\n            const keys = Object.keys(sampleRow);\n            if (keys.length > 0) {\n              return keys.map((key) => {\n                const val = sampleRow[key];\n                let type: 'string' | 'number' | 'date' | 'boolean' = 'string';\n                if (typeof val === 'number') type = 'number';\n                else if (typeof val === 'boolean') type = 'boolean';\n                else if (typeof val === 'string' && /^\\d{4}-\\d{2}-\\d{2}/.test(val)) type = 'date';\n\n                return {\n                  field: key,\n                  label: humanizeIdentifier(key),\n                  dataType: type,\n                  visible: true,\n                  sortable: true,\n                  align: (type === 'number' ? 'right' : 'left') as 'right' | 'left',\n                };\n              });\n            }\n          }\n          return [];\n        }),\n        catchError((err) => {\n          console.warn(`[ReportDataDiscoveryService] Dynamic sample detection failed for ${entityName}:`, err);\n          return of([]);\n        })\n      );\n  }\n}\n"]}

package/esm2022/lib/core/tokens/reporting-config.token.mjs

@@ -23,4 +23,4 @@ export const CHART_COMPONENT = new InjectionToken('CHART_COMPONENT');
  * Injection token for the reporting library configuration.
  */
 export const REPORTING_CONFIG = new InjectionToken('REPORTING_CONFIG');
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/utils/identifier-humanizer.mjs

@@ -51,14 +51,25 @@ export function detectDefaultValueField(columns) {
     const exactMatch = columns.find((c) => ['id', 'key', 'code', 'guid', 'uuid'].includes(c.field.toLowerCase()));
     if (exactMatch)
         return exactMatch.field;
-    // 2. Check columns ending with 'id' or 'code' or 'key'
+    // 2. Check columns ending with 'acno', 'glacno', 'account_no', 'accountno', '_id', 'id'
+    const primaryIdMatch = columns.find((c) => {
+        const f = c.field.toLowerCase();
+        return (f.endsWith('_acno') ||
+            f.endsWith('acno') ||
+            f.includes('glacno') ||
+            f.endsWith('_id') ||
+            f.endsWith('id'));
+    });
+    if (primaryIdMatch)
+        return primaryIdMatch.field;
+    // 3. Check columns ending with 'code' or 'key'
     const suffixMatch = columns.find((c) => {
         const f = c.field.toLowerCase();
-        return f.endsWith('_id') || f.endsWith('id') || f.endsWith('_code') || f.endsWith('code');
+        return f.endsWith('_code') || f.endsWith('code') || f.endsWith('_key') || f.endsWith('key');
     });
     if (suffixMatch)
         return suffixMatch.field;
-    // 3. Fallback to first column
+    // 4. Fallback to first column
     return columns[0]?.field;
 }
 /**
@@ -85,4 +96,4 @@ export function detectDefaultDisplayField(columns) {
     // 3. Fallback to second column or first column
     return columns.length > 1 ? columns[1].field : columns[0]?.field;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identifier-humanizer.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/utils/identifier-humanizer.ts"],"names":[],"mappings":"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","sourcesContent":["import { EntityColumnMetadata } from '../../data-access/contracts/schema-discovery.contract';\n\n/**\n * Strips technical SQL prefixes (usp_, sp_, tbl_, vw_, @), removes schema if present,\n * and converts snake_case, PascalCase, or camelCase into clean, human-readable Title Case.\n *\n * Examples:\n * - 'dbo.usp_GetCustomerList' -> 'Customer List'\n * - 'usp_GetBranches' -> 'Branches'\n * - '@BranchId' -> 'Branch'\n * - '@ActiveOnly' -> 'Active Only'\n * - 'tbl_Products' -> 'Products'\n * - 'customer_name_en' -> 'Customer Name En'\n */\nexport function humanizeIdentifier(raw: string): string {\n  if (!raw || typeof raw !== 'string') return '';\n\n  // 1. Remove schema (e.g. 'dbo.')\n  let text = raw.includes('.') ? raw.split('.').pop()! : raw;\n\n  // 2. Remove leading @, and prefixes like sp_, usp_, tbl_, vw_, get_ repeatedly\n  text = text.replace(/^@+/, '');\n  while (/^(usp_|sp_|tbl_|vw_|get_)/i.test(text)) {\n    text = text.replace(/^(usp_|sp_|tbl_|vw_|get_)/i, '');\n  }\n\n  // 3. If it starts with 'Get' followed by uppercase (e.g. 'GetCustomerList'), strip 'Get'\n  if (/^get[A-Z]/i.test(text)) {\n    text = text.slice(3);\n  }\n\n  // 4. Split snake_case and kebab-case\n  text = text.replace(/[_-]+/g, ' ');\n\n  // 5. Split PascalCase and camelCase (e.g. 'CustomerList' -> 'Customer List', 'BranchId' -> 'Branch Id')\n  text = text.replace(/([a-z0-9])([A-Z])/g, '$1 $2');\n  text = text.replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');\n\n  // 6. Clean up trailing ' Id' if it's a parameter label (e.g. 'Branch Id' -> 'Branch')\n  // We keep it natural for parameters: 'Branch' is clearer than 'Branch Id' for non-technical users\n  if (text.endsWith(' Id') && text.length > 3) {\n    text = text.slice(0, -3);\n  }\n\n  // 7. Title-case each word\n  return text\n    .split(' ')\n    .filter(Boolean)\n    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())\n    .join(' ');\n}\n\n/**\n * Detects the most probable column to use as the value/key (e.g. ID, Code, Key, Guid).\n */\nexport function detectDefaultValueField(columns: EntityColumnMetadata[]): string | undefined {\n  if (!columns || columns.length === 0) return undefined;\n\n  // 1. Check exact matches for 'id' or 'key' or 'code'\n  const exactMatch = columns.find((c) =>\n    ['id', 'key', 'code', 'guid', 'uuid'].includes(c.field.toLowerCase())\n  );\n  if (exactMatch) return exactMatch.field;\n\n  // 2. Check columns ending with 'id' or 'code' or 'key'\n  const suffixMatch = columns.find((c) => {\n    const f = c.field.toLowerCase();\n    return f.endsWith('_id') || f.endsWith('id') || f.endsWith('_code') || f.endsWith('code');\n  });\n  if (suffixMatch) return suffixMatch.field;\n\n  // 3. Fallback to first column\n  return columns[0]?.field;\n}\n\n/**\n * Detects the most probable column to use as the display text (e.g. Name, Title, Label, Description).\n */\nexport function detectDefaultDisplayField(columns: EntityColumnMetadata[]): string | undefined {\n  if (!columns || columns.length === 0) return undefined;\n\n  // 1. Look for text fields containing 'name', 'title', 'label', 'desc'\n  const nameMatch = columns.find((c) => {\n    const f = c.field.toLowerCase();\n    return (\n      f.includes('name') ||\n      f.includes('title') ||\n      f.includes('label') ||\n      f.includes('description') ||\n      f.includes('desc')\n    );\n  });\n  if (nameMatch) return nameMatch.field;\n\n  // 2. Look for any string dataType column\n  const stringMatch = columns.find((c) => c.dataType === 'string');\n  if (stringMatch) return stringMatch.field;\n\n  // 3. Fallback to second column or first column\n  return columns.length > 1 ? columns[1].field : columns[0]?.field;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identifier-humanizer.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/utils/identifier-humanizer.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAW;IAC5C,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IAE/C,iCAAiC;IACjC,IAAI,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAG,CAAC,CAAC,CAAC,GAAG,CAAC;IAE3D,+EAA+E;IAC/E,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAC/B,OAAO,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/C,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,4BAA4B,EAAE,EAAE,CAAC,CAAC;IACxD,CAAC;IAED,yFAAyF;IACzF,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IAED,qCAAqC;IACrC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAEnC,wGAAwG;IACxG,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC;IACnD,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,uBAAuB,EAAE,OAAO,CAAC,CAAC;IAEtD,sFAAsF;IACtF,kGAAkG;IAClG,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5C,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3B,CAAC;IAED,0BAA0B;IAC1B,OAAO,IAAI;SACR,KAAK,CAAC,GAAG,CAAC;SACV,MAAM,CAAC,OAAO,CAAC;SACf,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;SAChE,IAAI,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAA+B;IACrE,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAEvD,qDAAqD;IACrD,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CACpC,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CACtE,CAAC;IACF,IAAI,UAAU;QAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAExC,wFAAwF;IACxF,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;QACxC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAChC,OAAO,CACL,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;YACnB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;YAClB,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC;YACpB,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YACjB,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CACjB,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,IAAI,cAAc;QAAE,OAAO,cAAc,CAAC,KAAK,CAAC;IAEhD,+CAA+C;IAC/C,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;QACrC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAChC,OAAO,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC9F,CAAC,CAAC,CAAC;IACH,IAAI,WAAW;QAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAE1C,8BAA8B;IAC9B,OAAO,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;AAC3B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,yBAAyB,CAAC,OAA+B;IACvE,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAEvD,sEAAsE;IACtE,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;QACnC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAChC,OAAO,CACL,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;YAClB,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;YACnB,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC;YACnB,CAAC,CAAC,QAAQ,CAAC,aAAa,CAAC;YACzB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CACnB,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,IAAI,SAAS;QAAE,OAAO,SAAS,CAAC,KAAK,CAAC;IAEtC,yCAAyC;IACzC,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;IACjE,IAAI,WAAW;QAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAE1C,+CAA+C;IAC/C,OAAO,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC;AACnE,CAAC","sourcesContent":["import { EntityColumnMetadata } from '../../data-access/contracts/schema-discovery.contract';\n\n/**\n * Strips technical SQL prefixes (usp_, sp_, tbl_, vw_, @), removes schema if present,\n * and converts snake_case, PascalCase, or camelCase into clean, human-readable Title Case.\n *\n * Examples:\n * - 'dbo.usp_GetCustomerList' -> 'Customer List'\n * - 'usp_GetBranches' -> 'Branches'\n * - '@BranchId' -> 'Branch'\n * - '@ActiveOnly' -> 'Active Only'\n * - 'tbl_Products' -> 'Products'\n * - 'customer_name_en' -> 'Customer Name En'\n */\nexport function humanizeIdentifier(raw: string): string {\n  if (!raw || typeof raw !== 'string') return '';\n\n  // 1. Remove schema (e.g. 'dbo.')\n  let text = raw.includes('.') ? raw.split('.').pop()! : raw;\n\n  // 2. Remove leading @, and prefixes like sp_, usp_, tbl_, vw_, get_ repeatedly\n  text = text.replace(/^@+/, '');\n  while (/^(usp_|sp_|tbl_|vw_|get_)/i.test(text)) {\n    text = text.replace(/^(usp_|sp_|tbl_|vw_|get_)/i, '');\n  }\n\n  // 3. If it starts with 'Get' followed by uppercase (e.g. 'GetCustomerList'), strip 'Get'\n  if (/^get[A-Z]/i.test(text)) {\n    text = text.slice(3);\n  }\n\n  // 4. Split snake_case and kebab-case\n  text = text.replace(/[_-]+/g, ' ');\n\n  // 5. Split PascalCase and camelCase (e.g. 'CustomerList' -> 'Customer List', 'BranchId' -> 'Branch Id')\n  text = text.replace(/([a-z0-9])([A-Z])/g, '$1 $2');\n  text = text.replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');\n\n  // 6. Clean up trailing ' Id' if it's a parameter label (e.g. 'Branch Id' -> 'Branch')\n  // We keep it natural for parameters: 'Branch' is clearer than 'Branch Id' for non-technical users\n  if (text.endsWith(' Id') && text.length > 3) {\n    text = text.slice(0, -3);\n  }\n\n  // 7. Title-case each word\n  return text\n    .split(' ')\n    .filter(Boolean)\n    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())\n    .join(' ');\n}\n\n/**\n * Detects the most probable column to use as the value/key (e.g. ID, Code, Key, Guid).\n */\nexport function detectDefaultValueField(columns: EntityColumnMetadata[]): string | undefined {\n  if (!columns || columns.length === 0) return undefined;\n\n  // 1. Check exact matches for 'id' or 'key' or 'code'\n  const exactMatch = columns.find((c) =>\n    ['id', 'key', 'code', 'guid', 'uuid'].includes(c.field.toLowerCase())\n  );\n  if (exactMatch) return exactMatch.field;\n\n  // 2. Check columns ending with 'acno', 'glacno', 'account_no', 'accountno', '_id', 'id'\n  const primaryIdMatch = columns.find((c) => {\n    const f = c.field.toLowerCase();\n    return (\n      f.endsWith('_acno') ||\n      f.endsWith('acno') ||\n      f.includes('glacno') ||\n      f.endsWith('_id') ||\n      f.endsWith('id')\n    );\n  });\n  if (primaryIdMatch) return primaryIdMatch.field;\n\n  // 3. Check columns ending with 'code' or 'key'\n  const suffixMatch = columns.find((c) => {\n    const f = c.field.toLowerCase();\n    return f.endsWith('_code') || f.endsWith('code') || f.endsWith('_key') || f.endsWith('key');\n  });\n  if (suffixMatch) return suffixMatch.field;\n\n  // 4. Fallback to first column\n  return columns[0]?.field;\n}\n\n/**\n * Detects the most probable column to use as the display text (e.g. Name, Title, Label, Description).\n */\nexport function detectDefaultDisplayField(columns: EntityColumnMetadata[]): string | undefined {\n  if (!columns || columns.length === 0) return undefined;\n\n  // 1. Look for text fields containing 'name', 'title', 'label', 'desc'\n  const nameMatch = columns.find((c) => {\n    const f = c.field.toLowerCase();\n    return (\n      f.includes('name') ||\n      f.includes('title') ||\n      f.includes('label') ||\n      f.includes('description') ||\n      f.includes('desc')\n    );\n  });\n  if (nameMatch) return nameMatch.field;\n\n  // 2. Look for any string dataType column\n  const stringMatch = columns.find((c) => c.dataType === 'string');\n  if (stringMatch) return stringMatch.field;\n\n  // 3. Fallback to second column or first column\n  return columns.length > 1 ? columns[1].field : columns[0]?.field;\n}\n"]}

package/esm2022/lib/data-access/adapters/http-lookup.adapter.mjs

@@ -1,7 +1,7 @@
 import { inject, Injectable } from '@angular/core';
 import { HttpClient, HttpHeaders } from '@angular/common/http';
 import { of, throwError } from 'rxjs';
-import { catchError, map, tap } from 'rxjs/operators';
+import { catchError, finalize, map, shareReplay, tap } from 'rxjs/operators';
 import { ReportLookupAdapter, } from '../contracts/lookup.contract';
 import { REPORTING_CONFIG } from '../../core/tokens/reporting-config.token';
 import { ReportSessionContextService } from '../../core/services/report-session-context.service';
@@ -9,13 +9,14 @@ import { extractRowArray } from '../../core/utils/data-normalization.util';
 import * as i0 from "@angular/core";
 /**
  * Built-in HTTP adapter for fetching dropdown options from backend database tables and SPs.
- * Includes in-memory caching with TTL and rich fallback mock data for testing.
+ * Includes in-memory caching with TTL, in-flight request deduplication, and fallback mock data.
  */
 export class HttpReportLookupAdapter extends ReportLookupAdapter {
     http = inject(HttpClient, { optional: true });
     config = inject(REPORTING_CONFIG, { optional: true });
     sessionService = inject(ReportSessionContextService, { optional: true });
     cache = new Map();
+    inFlight = new Map();
     mockDataStore = {
         Customers: [
             { customerId: 101, customerName: 'Acme Corporation', branchId: 1, isActive: true },
@@ -62,6 +63,10 @@ export class HttpReportLookupAdapter extends ReportLookupAdapter {
         if (cached && cached.expiresAt > now) {
             return of(cached.data);
         }
+        const running = this.inFlight.get(cacheKey);
+        if (running) {
+            return running;
+        }
         const baseUrl = this.config?.apiBaseUrl;
         if (baseUrl && this.http) {
             const session = this.sessionService?.sessionContext() ?? {};
@@ -72,7 +77,7 @@ export class HttpReportLookupAdapter extends ReportLookupAdapter {
             if (session['branchId'] !== undefined && session['branchId'] !== null) {
                 headers = headers.set('X-Branch-Id', String(session['branchId']));
             }
-            return this.http.post(`${baseUrl}/lookup`, request, { headers }).pipe(map((response) => {
+            const obs$ = this.http.post(`${baseUrl}/lookup`, request, { headers }).pipe(map((response) => {
                 const rawItems = extractRowArray(response);
                 return rawItems.map((r) => {
                     if (r && typeof r === 'object' && 'value' in r) {
@@ -85,17 +90,21 @@ export class HttpReportLookupAdapter extends ReportLookupAdapter {
             }), tap((items) => {
                 // Never cache empty results: parameters may simply not have been filled yet.
                 if (items.length > 0)
-                    this.setCache(cacheKey, items);
+                    this.setCache(cacheKey, items, 600);
             }), catchError((err) => {
                 const msg = err?.error?.message || err?.message || 'Lookup request failed';
                 return throwError(() => new Error(Array.isArray(msg) ? msg.join(', ') : msg));
-            }));
+            }), finalize(() => {
+                this.inFlight.delete(cacheKey);
+            }), shareReplay({ bufferSize: 1, refCount: true }));
+            this.inFlight.set(cacheKey, obs$);
+            return obs$;
         }
         const fallback = this.resolveMockOptions(request);
-        this.setCache(cacheKey, fallback);
+        this.setCache(cacheKey, fallback, 600);
         return of(fallback);
     }
-    setCache(key, data, ttlSeconds = 300) {
+    setCache(key, data, ttlSeconds = 600) {
         this.cache.set(key, {
             expiresAt: Date.now() + ttlSeconds * 1000,
             data,
@@ -129,4 +138,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         }] });
 /** Convenience alias */
 export const HttpLookupAdapter = HttpReportLookupAdapter;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-lookup.adapter.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/data-access/adapters/http-lookup.adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, map, tap } from 'rxjs/operators';\nimport {\n  LookupOptionItem,\n  LookupQueryRequest,\n  ReportLookupAdapter,\n} from '../contracts/lookup.contract';\nimport { REPORTING_CONFIG } from '../../core/tokens/reporting-config.token';\nimport { ReportSessionContextService } from '../../core/services/report-session-context.service';\nimport { extractRowArray } from '../../core/utils/data-normalization.util';\n\ninterface CacheEntry {\n  expiresAt: number;\n  data: LookupOptionItem[];\n}\n\n/**\n * Built-in HTTP adapter for fetching dropdown options from backend database tables and SPs.\n * Includes in-memory caching with TTL and rich fallback mock data for testing.\n */\n@Injectable()\nexport class HttpReportLookupAdapter extends ReportLookupAdapter {\n  private readonly http = inject(HttpClient, { optional: true });\n  private readonly config = inject(REPORTING_CONFIG, { optional: true });\n  private readonly sessionService = inject(ReportSessionContextService, { optional: true });\n\n  private readonly cache = new Map<string, CacheEntry>();\n\n  private readonly mockDataStore: Record<string, Array<{ [key: string]: unknown }>> = {\n    Customers: [\n      { customerId: 101, customerName: 'Acme Corporation', branchId: 1, isActive: true },\n      { customerId: 102, customerName: 'Globex Industries', branchId: 2, isActive: true },\n      { customerId: 103, customerName: 'Initech Software', branchId: 1, isActive: true },\n      { customerId: 104, customerName: 'Umbrella Corporation', branchId: 3, isActive: true },\n      { customerId: 105, customerName: 'Wayne Enterprises', branchId: 2, isActive: true },\n      { customerId: 106, customerName: 'Stark Industries', branchId: 1, isActive: true },\n    ],\n    Branches: [\n      { branchId: 1, branchName: 'North America HQ (New York)', region: 'North America' },\n      { branchId: 2, branchName: 'EMEA Division (London)', region: 'Europe' },\n      { branchId: 3, branchName: 'APAC Hub (Singapore)', region: 'Asia Pacific' },\n      { branchId: 4, branchName: 'LATAM Office (São Paulo)', region: 'Latin America' },\n    ],\n    Products: [\n      { productId: 1, productName: 'Enterprise ERP Suite', category: 'Software', unitPrice: 2400 },\n      { productId: 2, productName: 'Cloud Analytics Pro', category: 'SaaS', unitPrice: 1200 },\n      { productId: 3, productName: 'Security Shield Endpoint', category: 'Security', unitPrice: 850 },\n      { productId: 4, productName: 'Dedicated API Gateway', category: 'Infrastructure', unitPrice: 3100 },\n    ],\n    PaymentMethods: [\n      { code: 'BANK_TRANSFER', title: 'Direct Bank Wire' },\n      { code: 'CREDIT_CARD', title: 'Corporate Credit Card' },\n      { code: 'PAYPAL', title: 'PayPal Corporate' },\n      { code: 'NET_30', title: 'Net 30 Invoicing' },\n    ],\n    usp_GetCustomerList: [\n      { id: 101, name: 'Acme Corporation (SP)', branchId: 1, branch: 'NA' },\n      { id: 102, name: 'Globex Industries (SP)', branchId: 2, branch: 'EMEA' },\n      { id: 105, name: 'Wayne Enterprises (SP)', branchId: 1, branch: 'NA' },\n      { id: 106, name: 'Stark Industries (SP)', branchId: 3, branch: 'APAC' },\n    ],\n    usp_GetBranchLookup: [\n      { id: 1, name: 'North America HQ' },\n      { id: 2, name: 'EMEA Division' },\n      { id: 3, name: 'APAC Hub' },\n    ],\n  };\n\n  fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]> {\n    const cacheKey = this.generateCacheKey(request);\n    const cached = this.cache.get(cacheKey);\n    const now = Date.now();\n\n    if (cached && cached.expiresAt > now) {\n      return of(cached.data);\n    }\n\n    const baseUrl = this.config?.apiBaseUrl;\n    if (baseUrl && this.http) {\n      const session = this.sessionService?.sessionContext() ?? {};\n      let headers = new HttpHeaders();\n      if (session['companyId'] !== undefined && session['companyId'] !== null) {\n        headers = headers.set('X-Company-Id', String(session['companyId']));\n      }\n      if (session['branchId'] !== undefined && session['branchId'] !== null) {\n        headers = headers.set('X-Branch-Id', String(session['branchId']));\n      }\n\n      return this.http.post<unknown>(`${baseUrl}/lookup`, request, { headers }).pipe(\n        map((response) => {\n          const rawItems = extractRowArray(response);\n          return rawItems.map((r: any) => {\n            if (r && typeof r === 'object' && 'value' in r) {\n              return r as LookupOptionItem;\n            }\n            const val = r?.[request.valueField] ?? r?.id ?? r?.code ?? String(r ?? '');\n            const lbl = r?.[request.displayField] ?? r?.name ?? r?.title ?? String(val);\n            return { value: val, label: lbl, raw: r };\n          });\n        }),\n        tap((items) => {\n          // Never cache empty results: parameters may simply not have been filled yet.\n          if (items.length > 0) this.setCache(cacheKey, items);\n        }),\n        catchError((err) => {\n          const msg = err?.error?.message || err?.message || 'Lookup request failed';\n          return throwError(() => new Error(Array.isArray(msg) ? msg.join(', ') : msg));\n        })\n      );\n    }\n\n    const fallback = this.resolveMockOptions(request);\n    this.setCache(cacheKey, fallback);\n    return of(fallback);\n  }\n\n  private setCache(key: string, data: LookupOptionItem[], ttlSeconds = 300): void {\n    this.cache.set(key, {\n      expiresAt: Date.now() + ttlSeconds * 1000,\n      data,\n    });\n  }\n\n  private generateCacheKey(req: LookupQueryRequest): string {\n    return `${req.sourceType}:${req.entityName}:${req.valueField}:${req.displayField}:${JSON.stringify(req.filter ?? {})}:${JSON.stringify(req.parameters ?? {})}`;\n  }\n\n  private resolveMockOptions(req: LookupQueryRequest): LookupOptionItem[] {\n    const entity = req.entityName || '';\n    const records = this.mockDataStore[entity] ?? [];\n    const valKey = req.valueField;\n    const labelKey = req.displayField;\n\n    let filteredRecords = records;\n    const branchParam = req.parameters?.['@BranchId'] ?? req.parameters?.['branchId'];\n    if (branchParam !== undefined && branchParam !== null && branchParam !== '') {\n      const matchNum = Number(branchParam);\n      filteredRecords = records.filter(\n        (r) => r['branchId'] === undefined || r['branchId'] === matchNum || r['branch'] === String(branchParam)\n      );\n    }\n\n    return filteredRecords.map((r) => ({\n      value: (r[valKey] as string | number) ?? String(r['id'] ?? r['code'] ?? ''),\n      label: (r[labelKey] as string) ?? String(r['name'] ?? r['title'] ?? ''),\n      raw: r,\n    }));\n  }\n}\n\n/** Convenience alias */\nexport const HttpLookupAdapter = HttpReportLookupAdapter;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-lookup.adapter.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/data-access/adapters/http-lookup.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAc,EAAE,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAGL,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,oDAAoD,CAAC;AACjG,OAAO,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;;AAO3E;;;GAGG;AAEH,MAAM,OAAO,uBAAwB,SAAQ,mBAAmB;IAC7C,IAAI,GAAG,MAAM,CAAC,UAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9C,MAAM,GAAG,MAAM,CAAC,gBAAgB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IACtD,cAAc,GAAG,MAAM,CAAC,2BAA2B,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IAEzE,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAC;IACtC,QAAQ,GAAG,IAAI,GAAG,EAA0C,CAAC;IAE7D,aAAa,GAAsD;QAClF,SAAS,EAAE;YACT,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,kBAAkB,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;YAClF,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,mBAAmB,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;YACnF,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,kBAAkB,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;YAClF,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,sBAAsB,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;YACtF,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,mBAAmB,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;YACnF,EAAE,UAAU,EAAE,GAAG,EAAE,YAAY,EAAE,kBAAkB,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;SACnF;QACD,QAAQ,EAAE;YACR,EAAE,QAAQ,EAAE,CAAC,EAAE,UAAU,EAAE,6BAA6B,EAAE,MAAM,EAAE,eAAe,EAAE;YACnF,EAAE,QAAQ,EAAE,CAAC,EAAE,UAAU,EAAE,wBAAwB,EAAE,MAAM,EAAE,QAAQ,EAAE;YACvE,EAAE,QAAQ,EAAE,CAAC,EAAE,UAAU,EAAE,sBAAsB,EAAE,MAAM,EAAE,cAAc,EAAE;YAC3E,EAAE,QAAQ,EAAE,CAAC,EAAE,UAAU,EAAE,0BAA0B,EAAE,MAAM,EAAE,eAAe,EAAE;SACjF;QACD,QAAQ,EAAE;YACR,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,sBAAsB,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE;YAC5F,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE;YACvF,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,0BAA0B,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,EAAE;YAC/F,EAAE,SAAS,EAAE,CAAC,EAAE,WAAW,EAAE,uBAAuB,EAAE,QAAQ,EAAE,gBAAgB,EAAE,SAAS,EAAE,IAAI,EAAE;SACpG;QACD,cAAc,EAAE;YACd,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,kBAAkB,EAAE;YACpD,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,uBAAuB,EAAE;YACvD,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,kBAAkB,EAAE;YAC7C,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,kBAAkB,EAAE;SAC9C;QACD,mBAAmB,EAAE;YACnB,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,uBAAuB,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE;YACrE,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,wBAAwB,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE;YACxE,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,wBAAwB,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE;YACtE,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,uBAAuB,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE;SACxE;QACD,mBAAmB,EAAE;YACnB,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE;YACnC,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE;YAChC,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE;SAC5B;KACF,CAAC;IAEF,YAAY,CAAC,OAA2B;QACtC,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,IAAI,MAAM,IAAI,MAAM,CAAC,SAAS,GAAG,GAAG,EAAE,CAAC;YACrC,OAAO,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC;QACxC,IAAI,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACzB,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC;YAC5D,IAAI,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;YAChC,IAAI,OAAO,CAAC,WAAW,CAAC,KAAK,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE,CAAC;gBACxE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,OAAO,CAAC,UAAU,CAAC,KAAK,SAAS,IAAI,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAAE,CAAC;gBACtE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YACpE,CAAC;YAED,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAU,GAAG,OAAO,SAAS,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,CAClF,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACf,MAAM,QAAQ,GAAG,eAAe,CAAC,QAAQ,CAAC,CAAC;gBAC3C,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE;oBAC7B,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;wBAC/C,OAAO,CAAqB,CAAC;oBAC/B,CAAC;oBACD,MAAM,GAAG,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,IAAI,IAAI,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;oBAC3E,MAAM,GAAG,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;oBAC5E,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;gBAC5C,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,EACF,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;gBACZ,6EAA6E;gBAC7E,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;oBAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;YAC5D,CAAC,CAAC,EACF,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE;gBACjB,MAAM,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,OAAO,IAAI,GAAG,EAAE,OAAO,IAAI,uBAAuB,CAAC;gBAC3E,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAChF,CAAC,CAAC,EACF,QAAQ,CAAC,GAAG,EAAE;gBACZ,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACjC,CAAC,CAAC,EACF,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAC/C,CAAC;YAEF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YAClC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;QACvC,OAAO,EAAE,CAAC,QAAQ,CAAC,CAAC;IACtB,CAAC;IAEO,QAAQ,CAAC,GAAW,EAAE,IAAwB,EAAE,UAAU,GAAG,GAAG;QACtE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE;YAClB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,UAAU,GAAG,IAAI;YACzC,IAAI;SACL,CAAC,CAAC;IACL,CAAC;IAEO,gBAAgB,CAAC,GAAuB;QAC9C,OAAO,GAAG,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,YAAY,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC,EAAE,CAAC;IACjK,CAAC;IAEO,kBAAkB,CAAC,GAAuB;QAChD,MAAM,MAAM,GAAG,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACjD,MAAM,MAAM,GAAG,GAAG,CAAC,UAAU,CAAC;QAC9B,MAAM,QAAQ,GAAG,GAAG,CAAC,YAAY,CAAC;QAElC,IAAI,eAAe,GAAG,OAAO,CAAC;QAC9B,MAAM,WAAW,GAAG,GAAG,CAAC,UAAU,EAAE,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC,UAAU,CAAC,CAAC;QAClF,IAAI,WAAW,KAAK,SAAS,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;YAC5E,MAAM,QAAQ,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;YACrC,eAAe,GAAG,OAAO,CAAC,MAAM,CAC9B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,SAAS,IAAI,CAAC,CAAC,UAAU,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,WAAW,CAAC,CACxG,CAAC;QACJ,CAAC;QAED,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACjC,KAAK,EAAG,CAAC,CAAC,MAAM,CAAqB,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YAC3E,KAAK,EAAG,CAAC,CAAC,QAAQ,CAAY,IAAI,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACvE,GAAG,EAAE,CAAC;SACP,CAAC,CAAC,CAAC;IACN,CAAC;wGA3IU,uBAAuB;4GAAvB,uBAAuB;;4FAAvB,uBAAuB;kBADnC,UAAU;;AA+IX,wBAAwB;AACxB,MAAM,CAAC,MAAM,iBAAiB,GAAG,uBAAuB,CAAC","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { Observable, of, throwError } from 'rxjs';\nimport { catchError, finalize, map, shareReplay, tap } from 'rxjs/operators';\nimport {\n  LookupOptionItem,\n  LookupQueryRequest,\n  ReportLookupAdapter,\n} from '../contracts/lookup.contract';\nimport { REPORTING_CONFIG } from '../../core/tokens/reporting-config.token';\nimport { ReportSessionContextService } from '../../core/services/report-session-context.service';\nimport { extractRowArray } from '../../core/utils/data-normalization.util';\n\ninterface CacheEntry {\n  expiresAt: number;\n  data: LookupOptionItem[];\n}\n\n/**\n * Built-in HTTP adapter for fetching dropdown options from backend database tables and SPs.\n * Includes in-memory caching with TTL, in-flight request deduplication, and fallback mock data.\n */\n@Injectable()\nexport class HttpReportLookupAdapter extends ReportLookupAdapter {\n  private readonly http = inject(HttpClient, { optional: true });\n  private readonly config = inject(REPORTING_CONFIG, { optional: true });\n  private readonly sessionService = inject(ReportSessionContextService, { optional: true });\n\n  private readonly cache = new Map<string, CacheEntry>();\n  private readonly inFlight = new Map<string, Observable<LookupOptionItem[]>>();\n\n  private readonly mockDataStore: Record<string, Array<{ [key: string]: unknown }>> = {\n    Customers: [\n      { customerId: 101, customerName: 'Acme Corporation', branchId: 1, isActive: true },\n      { customerId: 102, customerName: 'Globex Industries', branchId: 2, isActive: true },\n      { customerId: 103, customerName: 'Initech Software', branchId: 1, isActive: true },\n      { customerId: 104, customerName: 'Umbrella Corporation', branchId: 3, isActive: true },\n      { customerId: 105, customerName: 'Wayne Enterprises', branchId: 2, isActive: true },\n      { customerId: 106, customerName: 'Stark Industries', branchId: 1, isActive: true },\n    ],\n    Branches: [\n      { branchId: 1, branchName: 'North America HQ (New York)', region: 'North America' },\n      { branchId: 2, branchName: 'EMEA Division (London)', region: 'Europe' },\n      { branchId: 3, branchName: 'APAC Hub (Singapore)', region: 'Asia Pacific' },\n      { branchId: 4, branchName: 'LATAM Office (São Paulo)', region: 'Latin America' },\n    ],\n    Products: [\n      { productId: 1, productName: 'Enterprise ERP Suite', category: 'Software', unitPrice: 2400 },\n      { productId: 2, productName: 'Cloud Analytics Pro', category: 'SaaS', unitPrice: 1200 },\n      { productId: 3, productName: 'Security Shield Endpoint', category: 'Security', unitPrice: 850 },\n      { productId: 4, productName: 'Dedicated API Gateway', category: 'Infrastructure', unitPrice: 3100 },\n    ],\n    PaymentMethods: [\n      { code: 'BANK_TRANSFER', title: 'Direct Bank Wire' },\n      { code: 'CREDIT_CARD', title: 'Corporate Credit Card' },\n      { code: 'PAYPAL', title: 'PayPal Corporate' },\n      { code: 'NET_30', title: 'Net 30 Invoicing' },\n    ],\n    usp_GetCustomerList: [\n      { id: 101, name: 'Acme Corporation (SP)', branchId: 1, branch: 'NA' },\n      { id: 102, name: 'Globex Industries (SP)', branchId: 2, branch: 'EMEA' },\n      { id: 105, name: 'Wayne Enterprises (SP)', branchId: 1, branch: 'NA' },\n      { id: 106, name: 'Stark Industries (SP)', branchId: 3, branch: 'APAC' },\n    ],\n    usp_GetBranchLookup: [\n      { id: 1, name: 'North America HQ' },\n      { id: 2, name: 'EMEA Division' },\n      { id: 3, name: 'APAC Hub' },\n    ],\n  };\n\n  fetchOptions(request: LookupQueryRequest): Observable<LookupOptionItem[]> {\n    const cacheKey = this.generateCacheKey(request);\n    const cached = this.cache.get(cacheKey);\n    const now = Date.now();\n\n    if (cached && cached.expiresAt > now) {\n      return of(cached.data);\n    }\n\n    const running = this.inFlight.get(cacheKey);\n    if (running) {\n      return running;\n    }\n\n    const baseUrl = this.config?.apiBaseUrl;\n    if (baseUrl && this.http) {\n      const session = this.sessionService?.sessionContext() ?? {};\n      let headers = new HttpHeaders();\n      if (session['companyId'] !== undefined && session['companyId'] !== null) {\n        headers = headers.set('X-Company-Id', String(session['companyId']));\n      }\n      if (session['branchId'] !== undefined && session['branchId'] !== null) {\n        headers = headers.set('X-Branch-Id', String(session['branchId']));\n      }\n\n      const obs$ = this.http.post<unknown>(`${baseUrl}/lookup`, request, { headers }).pipe(\n        map((response) => {\n          const rawItems = extractRowArray(response);\n          return rawItems.map((r: any) => {\n            if (r && typeof r === 'object' && 'value' in r) {\n              return r as LookupOptionItem;\n            }\n            const val = r?.[request.valueField] ?? r?.id ?? r?.code ?? String(r ?? '');\n            const lbl = r?.[request.displayField] ?? r?.name ?? r?.title ?? String(val);\n            return { value: val, label: lbl, raw: r };\n          });\n        }),\n        tap((items) => {\n          // Never cache empty results: parameters may simply not have been filled yet.\n          if (items.length > 0) this.setCache(cacheKey, items, 600);\n        }),\n        catchError((err) => {\n          const msg = err?.error?.message || err?.message || 'Lookup request failed';\n          return throwError(() => new Error(Array.isArray(msg) ? msg.join(', ') : msg));\n        }),\n        finalize(() => {\n          this.inFlight.delete(cacheKey);\n        }),\n        shareReplay({ bufferSize: 1, refCount: true })\n      );\n\n      this.inFlight.set(cacheKey, obs$);\n      return obs$;\n    }\n\n    const fallback = this.resolveMockOptions(request);\n    this.setCache(cacheKey, fallback, 600);\n    return of(fallback);\n  }\n\n  private setCache(key: string, data: LookupOptionItem[], ttlSeconds = 600): void {\n    this.cache.set(key, {\n      expiresAt: Date.now() + ttlSeconds * 1000,\n      data,\n    });\n  }\n\n  private generateCacheKey(req: LookupQueryRequest): string {\n    return `${req.sourceType}:${req.entityName}:${req.valueField}:${req.displayField}:${JSON.stringify(req.filter ?? {})}:${JSON.stringify(req.parameters ?? {})}`;\n  }\n\n  private resolveMockOptions(req: LookupQueryRequest): LookupOptionItem[] {\n    const entity = req.entityName || '';\n    const records = this.mockDataStore[entity] ?? [];\n    const valKey = req.valueField;\n    const labelKey = req.displayField;\n\n    let filteredRecords = records;\n    const branchParam = req.parameters?.['@BranchId'] ?? req.parameters?.['branchId'];\n    if (branchParam !== undefined && branchParam !== null && branchParam !== '') {\n      const matchNum = Number(branchParam);\n      filteredRecords = records.filter(\n        (r) => r['branchId'] === undefined || r['branchId'] === matchNum || r['branch'] === String(branchParam)\n      );\n    }\n\n    return filteredRecords.map((r) => ({\n      value: (r[valKey] as string | number) ?? String(r['id'] ?? r['code'] ?? ''),\n      label: (r[labelKey] as string) ?? String(r['name'] ?? r['title'] ?? ''),\n      raw: r,\n    }));\n  }\n}\n\n/** Convenience alias */\nexport const HttpLookupAdapter = HttpReportLookupAdapter;\n"]}