bways-report 0.1.4 → 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,3 +1,5 @@
 export { DynamicFormBuilder } from './dynamic-form-builder.service';
 export { ReportSessionContextService } from './report-session-context.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BFLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGtDQUFrQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRHluYW1pY0Zvcm1CdWlsZGVyIH0gZnJvbSAnLi9keW5hbWljLWZvcm0tYnVpbGRlci5zZXJ2aWNlJztcbmV4cG9ydCB7IFJlcG9ydFNlc3Npb25Db250ZXh0U2VydmljZSB9IGZyb20gJy4vcmVwb3J0LXNlc3Npb24tY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCB0eXBlIHtcbiAgU2Vzc2lvblBhcmFtTWF0Y2gsXG4gIERlcml2ZWRQYXJhbWV0ZXJzUmVzdWx0LFxufSBmcm9tICcuL3JlcG9ydC1zZXNzaW9uLWNvbnRleHQuc2VydmljZSc7XG5cbiJdfQ==
+export { ReportStorageService } from './report-storage.service';
+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/services/report-storage.service.mjs

@@ -0,0 +1,63 @@
+import { Injectable, inject } from '@angular/core';
+import { REPORT_STORAGE } from '../tokens/storage.token';
+import * as i0 from "@angular/core";
+/**
+ * Angular injectable service wrapping report storage operations.
+ * Provides type-safe JSON serialization/deserialization and environment-agnostic access.
+ */
+export class ReportStorageService {
+    storage = inject(REPORT_STORAGE);
+    getItem(key) {
+        return this.storage.getItem(key);
+    }
+    setItem(key, value) {
+        this.storage.setItem(key, value);
+    }
+    removeItem(key) {
+        this.storage.removeItem(key);
+    }
+    clear() {
+        this.storage.clear();
+    }
+    key(index) {
+        return this.storage.key ? this.storage.key(index) : null;
+    }
+    get length() {
+        return this.storage.length ?? 0;
+    }
+    /**
+     * Safely retrieves and parses a JSON value from storage.
+     * Returns fallback if key is missing or parsing fails.
+     */
+    getJSON(key, fallback) {
+        const raw = this.getItem(key);
+        if (!raw)
+            return fallback;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return fallback;
+        }
+    }
+    /**
+     * Safely serializes and stores a JSON value in storage.
+     */
+    setJSON(key, value) {
+        try {
+            this.setItem(key, JSON.stringify(value));
+        }
+        catch {
+            // Storage error or circular structure handled gracefully
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportStorageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,3 +1,4 @@
 export { REPORTING_CONFIG, GRID_COMPONENT, CHART_COMPONENT, } from './reporting-config.token';
 export { REPORT_SESSION_CONTEXT, REPORT_SESSION_PROVIDER, SessionContextProvider, } from './session-context.token';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3Rva2Vucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLGNBQWMsRUFDZCxlQUFlLEdBQ2hCLE1BQU0sMEJBQTBCLENBQUM7QUFNbEMsT0FBTyxFQUNMLHNCQUFzQixFQUN0Qix1QkFBdUIsRUFDdkIsc0JBQXNCLEdBQ3ZCLE1BQU0seUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBSRVBPUlRJTkdfQ09ORklHLFxuICBHUklEX0NPTVBPTkVOVCxcbiAgQ0hBUlRfQ09NUE9ORU5ULFxufSBmcm9tICcuL3JlcG9ydGluZy1jb25maWcudG9rZW4nO1xuXG5leHBvcnQgdHlwZSB7XG4gIFJlcG9ydGluZ0NvbmZpZyxcbn0gZnJvbSAnLi9yZXBvcnRpbmctY29uZmlnLnRva2VuJztcblxuZXhwb3J0IHtcbiAgUkVQT1JUX1NFU1NJT05fQ09OVEVYVCxcbiAgUkVQT1JUX1NFU1NJT05fUFJPVklERVIsXG4gIFNlc3Npb25Db250ZXh0UHJvdmlkZXIsXG59IGZyb20gJy4vc2Vzc2lvbi1jb250ZXh0LnRva2VuJztcblxuZXhwb3J0IHR5cGUge1xuICBTZXNzaW9uUGFyYW1QcmltaXRpdmUsXG4gIFNlc3Npb25Db250ZXh0TWFwLFxuICBTZXNzaW9uQ29udGV4dFByb3ZpZGVyRm4sXG4gIFNlc3Npb25Db250ZXh0U291cmNlLFxufSBmcm9tICcuL3Nlc3Npb24tY29udGV4dC50b2tlbic7XG4iXX0=
+export { REPORT_STORAGE, BrowserReportStorage, MemoryReportStorage, } from './storage.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3Rva2Vucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZ0JBQWdCLEVBQ2hCLGNBQWMsRUFDZCxlQUFlLEdBQ2hCLE1BQU0sMEJBQTBCLENBQUM7QUFNbEMsT0FBTyxFQUNMLHNCQUFzQixFQUN0Qix1QkFBdUIsRUFDdkIsc0JBQXNCLEdBQ3ZCLE1BQU0seUJBQXlCLENBQUM7QUFTakMsT0FBTyxFQUNMLGNBQWMsRUFDZCxvQkFBb0IsRUFDcEIsbUJBQW1CLEdBQ3BCLE1BQU0saUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBSRVBPUlRJTkdfQ09ORklHLFxuICBHUklEX0NPTVBPTkVOVCxcbiAgQ0hBUlRfQ09NUE9ORU5ULFxufSBmcm9tICcuL3JlcG9ydGluZy1jb25maWcudG9rZW4nO1xuXG5leHBvcnQgdHlwZSB7XG4gIFJlcG9ydGluZ0NvbmZpZyxcbn0gZnJvbSAnLi9yZXBvcnRpbmctY29uZmlnLnRva2VuJztcblxuZXhwb3J0IHtcbiAgUkVQT1JUX1NFU1NJT05fQ09OVEVYVCxcbiAgUkVQT1JUX1NFU1NJT05fUFJPVklERVIsXG4gIFNlc3Npb25Db250ZXh0UHJvdmlkZXIsXG59IGZyb20gJy4vc2Vzc2lvbi1jb250ZXh0LnRva2VuJztcblxuZXhwb3J0IHR5cGUge1xuICBTZXNzaW9uUGFyYW1QcmltaXRpdmUsXG4gIFNlc3Npb25Db250ZXh0TWFwLFxuICBTZXNzaW9uQ29udGV4dFByb3ZpZGVyRm4sXG4gIFNlc3Npb25Db250ZXh0U291cmNlLFxufSBmcm9tICcuL3Nlc3Npb24tY29udGV4dC50b2tlbic7XG5cbmV4cG9ydCB7XG4gIFJFUE9SVF9TVE9SQUdFLFxuICBCcm93c2VyUmVwb3J0U3RvcmFnZSxcbiAgTWVtb3J5UmVwb3J0U3RvcmFnZSxcbn0gZnJvbSAnLi9zdG9yYWdlLnRva2VuJztcblxuZXhwb3J0IHR5cGUge1xuICBSZXBvcnRTdG9yYWdlLFxufSBmcm9tICcuL3N0b3JhZ2UudG9rZW4nO1xuIl19

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/tokens/storage.token.mjs

@@ -0,0 +1,128 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * In-memory fallback implementation of ReportStorage.
+ * Safe for SSR, unit tests, and sandboxed iframes where localStorage access is denied.
+ */
+export class MemoryReportStorage {
+    store = new Map();
+    getItem(key) {
+        return this.store.get(key) ?? null;
+    }
+    setItem(key, value) {
+        this.store.set(key, value);
+    }
+    removeItem(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+    key(index) {
+        const keys = Array.from(this.store.keys());
+        return keys[index] ?? null;
+    }
+    get length() {
+        return this.store.size;
+    }
+}
+/**
+ * Browser localStorage-backed implementation of ReportStorage
+ * with transparent in-memory fallback on DOMException or SSR.
+ */
+export class BrowserReportStorage {
+    memory = new MemoryReportStorage();
+    isSupported;
+    constructor() {
+        this.isSupported = this.checkStorageSupport();
+    }
+    checkStorageSupport() {
+        if (typeof window === 'undefined')
+            return false;
+        try {
+            const probe = '__bways_storage_probe__';
+            window.localStorage.setItem(probe, probe);
+            window.localStorage.removeItem(probe);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getItem(key) {
+        if (this.isSupported) {
+            try {
+                return window.localStorage.getItem(key);
+            }
+            catch {
+                return this.memory.getItem(key);
+            }
+        }
+        return this.memory.getItem(key);
+    }
+    setItem(key, value) {
+        if (this.isSupported) {
+            try {
+                window.localStorage.setItem(key, value);
+                return;
+            }
+            catch {
+                // Fall back to in-memory on quota or security exceptions
+            }
+        }
+        this.memory.setItem(key, value);
+    }
+    removeItem(key) {
+        if (this.isSupported) {
+            try {
+                window.localStorage.removeItem(key);
+            }
+            catch {
+                // Ignore
+            }
+        }
+        this.memory.removeItem(key);
+    }
+    clear() {
+        if (this.isSupported) {
+            try {
+                window.localStorage.clear();
+            }
+            catch {
+                // Ignore
+            }
+        }
+        this.memory.clear();
+    }
+    key(index) {
+        if (this.isSupported) {
+            try {
+                return window.localStorage.key(index);
+            }
+            catch {
+                return this.memory.key(index);
+            }
+        }
+        return this.memory.key(index);
+    }
+    get length() {
+        if (this.isSupported) {
+            try {
+                return window.localStorage.length;
+            }
+            catch {
+                return this.memory.length;
+            }
+        }
+        return this.memory.length;
+    }
+}
+/**
+ * Injection token for the report storage engine.
+ * Defaults to `BrowserReportStorage`, which transparently falls back to
+ * `MemoryReportStorage` when browser localStorage is unavailable or restricted.
+ */
+export const REPORT_STORAGE = new InjectionToken('REPORT_STORAGE', {
+    providedIn: 'root',
+    factory: () => new BrowserReportStorage(),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.token.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/tokens/storage.token.ts"],"names":[],"mappings":"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","sourcesContent":["import { InjectionToken } from '@angular/core';\n\n/**\n * Storage contract for reading and writing report configurations,\n * presets, and layout states across environments (Browser, SSR, sandboxed iframes).\n */\nexport interface ReportStorage {\n  getItem(key: string): string | null;\n  setItem(key: string, value: string): void;\n  removeItem(key: string): void;\n  clear(): void;\n  key?(index: number): string | null;\n  readonly length?: number;\n}\n\n/**\n * In-memory fallback implementation of ReportStorage.\n * Safe for SSR, unit tests, and sandboxed iframes where localStorage access is denied.\n */\nexport class MemoryReportStorage implements ReportStorage {\n  private readonly store = new Map<string, string>();\n\n  getItem(key: string): string | null {\n    return this.store.get(key) ?? null;\n  }\n\n  setItem(key: string, value: string): void {\n    this.store.set(key, value);\n  }\n\n  removeItem(key: string): void {\n    this.store.delete(key);\n  }\n\n  clear(): void {\n    this.store.clear();\n  }\n\n  key(index: number): string | null {\n    const keys = Array.from(this.store.keys());\n    return keys[index] ?? null;\n  }\n\n  get length(): number {\n    return this.store.size;\n  }\n}\n\n/**\n * Browser localStorage-backed implementation of ReportStorage\n * with transparent in-memory fallback on DOMException or SSR.\n */\nexport class BrowserReportStorage implements ReportStorage {\n  private readonly memory = new MemoryReportStorage();\n  private readonly isSupported: boolean;\n\n  constructor() {\n    this.isSupported = this.checkStorageSupport();\n  }\n\n  private checkStorageSupport(): boolean {\n    if (typeof window === 'undefined') return false;\n    try {\n      const probe = '__bways_storage_probe__';\n      window.localStorage.setItem(probe, probe);\n      window.localStorage.removeItem(probe);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  getItem(key: string): string | null {\n    if (this.isSupported) {\n      try {\n        return window.localStorage.getItem(key);\n      } catch {\n        return this.memory.getItem(key);\n      }\n    }\n    return this.memory.getItem(key);\n  }\n\n  setItem(key: string, value: string): void {\n    if (this.isSupported) {\n      try {\n        window.localStorage.setItem(key, value);\n        return;\n      } catch {\n        // Fall back to in-memory on quota or security exceptions\n      }\n    }\n    this.memory.setItem(key, value);\n  }\n\n  removeItem(key: string): void {\n    if (this.isSupported) {\n      try {\n        window.localStorage.removeItem(key);\n      } catch {\n        // Ignore\n      }\n    }\n    this.memory.removeItem(key);\n  }\n\n  clear(): void {\n    if (this.isSupported) {\n      try {\n        window.localStorage.clear();\n      } catch {\n        // Ignore\n      }\n    }\n    this.memory.clear();\n  }\n\n  key(index: number): string | null {\n    if (this.isSupported) {\n      try {\n        return window.localStorage.key(index);\n      } catch {\n        return this.memory.key(index);\n      }\n    }\n    return this.memory.key(index);\n  }\n\n  get length(): number {\n    if (this.isSupported) {\n      try {\n        return window.localStorage.length;\n      } catch {\n        return this.memory.length;\n      }\n    }\n    return this.memory.length;\n  }\n}\n\n/**\n * Injection token for the report storage engine.\n * Defaults to `BrowserReportStorage`, which transparently falls back to\n * `MemoryReportStorage` when browser localStorage is unavailable or restricted.\n */\nexport const REPORT_STORAGE = new InjectionToken<ReportStorage>('REPORT_STORAGE', {\n  providedIn: 'root',\n  factory: () => new BrowserReportStorage(),\n});\n"]}

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