bways-report 0.1.0

package/esm2022/lib/core/services/report-session-context.service.mjs

@@ -0,0 +1,314 @@
+import { computed, inject, Injectable, signal, } from '@angular/core';
+import { toObservable } from '@angular/core/rxjs-interop';
+import { isObservable } from 'rxjs';
+import { REPORT_SESSION_CONTEXT, REPORT_SESSION_PROVIDER, } from '../tokens/session-context.token';
+import { humanizeIdentifier } from '../utils/identifier-humanizer';
+import * as i0 from "@angular/core";
+/**
+ * Service that manages host application session context parameters (e.g. branchId, companyId, userId)
+ * at runtime and automatically detects and binds them to Stored Procedure parameters.
+ *
+ * Designed to completely shield end users from entering technical session parameters while
+ * eliminating silent failures or thread crashes in host integrations.
+ */
+export class ReportSessionContextService {
+    rawSource = inject(REPORT_SESSION_CONTEXT, {
+        optional: true,
+    });
+    sessionProvider = inject(REPORT_SESSION_PROVIDER, {
+        optional: true,
+    });
+    /** Internal manual runtime session overrides (e.g. set via setSessionContext or setSessionParameter) */
+    manualRuntimeContext = signal({});
+    latestObservableValue = signal({});
+    providerObservableValue = signal({});
+    observableSub;
+    providerSub;
+    /**
+     * Reactive signal exposing the live session context parameters.
+     * Updates automatically when host app mutates runtime state, when observables emit,
+     * or when reactive signals update.
+     */
+    sessionContext = computed(() => {
+        let providerMap = {};
+        if (this.sessionProvider) {
+            try {
+                const res = this.sessionProvider.getSessionContext();
+                if (typeof res === 'function') {
+                    const val = res();
+                    if (val && typeof val === 'object') {
+                        providerMap = val;
+                    }
+                }
+                else if (isObservable(res)) {
+                    providerMap = this.providerObservableValue();
+                }
+                else if (res && typeof res === 'object' && !('then' in res)) {
+                    providerMap = res;
+                }
+            }
+            catch (err) {
+                console.warn('[ReportSessionContextService] Error reading SessionContextProvider:', err);
+            }
+        }
+        let tokenMap = {};
+        if (this.rawSource) {
+            try {
+                if (isObservable(this.rawSource)) {
+                    tokenMap = this.latestObservableValue();
+                }
+                else if (typeof this.rawSource === 'function') {
+                    const res = this.rawSource();
+                    if (typeof res === 'function') {
+                        const innerRes = res();
+                        tokenMap = innerRes && typeof innerRes === 'object' ? innerRes : {};
+                    }
+                    else if (isObservable(res)) {
+                        tokenMap = this.latestObservableValue();
+                    }
+                    else {
+                        tokenMap = res && typeof res === 'object' ? res : {};
+                    }
+                }
+                else if (typeof this.rawSource === 'object' && this.rawSource !== null) {
+                    tokenMap = this.rawSource;
+                }
+            }
+            catch (err) {
+                console.warn('[ReportSessionContextService] Error evaluating raw session source:', err);
+            }
+        }
+        const manualMap = this.manualRuntimeContext();
+        return {
+            ...providerMap,
+            ...tokenMap,
+            ...manualMap,
+        };
+    });
+    /**
+     * Observable stream of live session parameters for RxJS-based integrations.
+     */
+    sessionContext$ = toObservable(this.sessionContext);
+    constructor() {
+        this.initSubscriptions();
+    }
+    ngOnDestroy() {
+        this.observableSub?.unsubscribe();
+        this.providerSub?.unsubscribe();
+    }
+    initSubscriptions() {
+        if (this.rawSource && isObservable(this.rawSource)) {
+            this.observableSub = this.rawSource.subscribe({
+                next: (val) => {
+                    if (val && typeof val === 'object') {
+                        this.latestObservableValue.set({ ...val });
+                    }
+                },
+                error: (err) => {
+                    console.warn('[ReportSessionContextService] Error from session context observable:', err);
+                },
+            });
+        }
+        if (this.sessionProvider) {
+            try {
+                const res = this.sessionProvider.getSessionContext();
+                if (isObservable(res)) {
+                    this.providerSub = res.subscribe({
+                        next: (val) => {
+                            if (val && typeof val === 'object') {
+                                this.providerObservableValue.set({ ...val });
+                            }
+                        },
+                        error: (err) => {
+                            console.warn('[ReportSessionContextService] Error from session provider observable:', err);
+                        },
+                    });
+                }
+                else if (res &&
+                    typeof res === 'object' &&
+                    'then' in res &&
+                    typeof res.then === 'function') {
+                    res
+                        .then((val) => {
+                        if (val && typeof val === 'object') {
+                            this.providerObservableValue.set({ ...val });
+                        }
+                    })
+                        .catch((err) => {
+                        console.warn('[ReportSessionContextService] Error from session provider promise:', err);
+                    });
+                }
+            }
+            catch (err) {
+                console.warn('[ReportSessionContextService] Error initializing session provider:', err);
+            }
+        }
+    }
+    /**
+     * Sets or replaces the runtime session context.
+     * Can be called dynamically after user authentication, branch change, etc.
+     */
+    setSessionContext(context) {
+        if (context && typeof context === 'object') {
+            this.manualRuntimeContext.set({ ...context });
+        }
+        else {
+            this.manualRuntimeContext.set({});
+        }
+    }
+    /**
+     * Updates or sets a specific session parameter at runtime (e.g. branchId = 2).
+     */
+    setSessionParameter(key, value) {
+        if (!key)
+            return;
+        this.manualRuntimeContext.update((current) => ({
+            ...current,
+            [key]: value,
+        }));
+    }
+    /**
+     * Clears any runtime session parameters set via `setSessionContext` or `setSessionParameter`.
+     */
+    clearSessionContext() {
+        this.manualRuntimeContext.set({});
+    }
+    /**
+     * Safely returns the current session context map.
+     * Always pulls the latest runtime state. Never throws or crashes the thread.
+     */
+    getCurrentSessionContext() {
+        try {
+            return this.sessionContext();
+        }
+        catch (err) {
+            console.warn('[ReportSessionContextService] Failed to evaluate session context:', err);
+            return {};
+        }
+    }
+    /**
+     * Normalizes a parameter or session key into a lowercase alphanumeric string
+     * for reliable, case-insensitive, and symbol-insensitive matching.
+     * E.g. '@BranchId' -> 'branchid', 'branch_id' -> 'branchid', 'BranchID' -> 'branchid'
+     */
+    normalizeKey(key) {
+        if (!key || typeof key !== 'string')
+            return '';
+        return key
+            .replace(/^@+/, '')
+            .replace(/[_\-\s]+/g, '')
+            .toLowerCase();
+    }
+    /**
+     * Checks whether a stored procedure parameter matches any key in the active session context.
+     * Supports exact, normalized, and common ERP synonyms.
+     */
+    matchParameter(paramName) {
+        const session = this.getCurrentSessionContext();
+        const sessionKeys = Object.keys(session);
+        if (sessionKeys.length === 0)
+            return null;
+        const normalizedParam = this.normalizeKey(paramName);
+        // 1. Exact match on raw name
+        if (paramName in session) {
+            return {
+                isMatched: true,
+                sessionKey: paramName,
+                value: session[paramName],
+                friendlyLabel: humanizeIdentifier(paramName),
+            };
+        }
+        // 2. Direct normalized match
+        for (const key of sessionKeys) {
+            if (this.normalizeKey(key) === normalizedParam) {
+                return {
+                    isMatched: true,
+                    sessionKey: key,
+                    value: session[key],
+                    friendlyLabel: humanizeIdentifier(key),
+                };
+            }
+        }
+        // 3. Common ERP synonym groups (bidirectional matching)
+        const synonymGroups = [
+            ['branch', 'branchid', 'bid', 'branchcode', 'locationid', 'location'],
+            ['company', 'companyid', 'cid', 'companycode', 'tenant', 'tenantid'],
+            ['user', 'userid', 'uid', 'usercode', 'operatorid', 'loginuser'],
+            ['financialyear', 'financialyearid', 'yearid', 'fyear', 'fiscalyear'],
+            ['org', 'orgid', 'organization', 'organizationid'],
+        ];
+        for (const group of synonymGroups) {
+            if (group.includes(normalizedParam)) {
+                for (const key of sessionKeys) {
+                    if (group.includes(this.normalizeKey(key))) {
+                        return {
+                            isMatched: true,
+                            sessionKey: key,
+                            value: session[key],
+                            friendlyLabel: humanizeIdentifier(key),
+                        };
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Resolves and derives all stored procedure parameters:
+     * - Preserves explicit overrides (e.g. from canvas form controls or manual inputs)
+     * - Automatically injects matched session parameters
+     * - Validates whether required parameters are fulfilled
+     */
+    deriveParameters(spParams, explicitMappings = {}) {
+        const session = this.getCurrentSessionContext();
+        const finalParams = {};
+        const autoDerived = {};
+        const unresolvedRequired = [];
+        for (const param of spParams) {
+            const paramName = param.name;
+            const explicitVal = explicitMappings[paramName];
+            // Check if user or canvas explicitly provided a value (and not an empty placeholder)
+            const hasExplicit = explicitVal !== undefined && explicitVal !== '' && explicitVal !== null;
+            if (hasExplicit) {
+                finalParams[paramName] = explicitVal;
+                continue;
+            }
+            // Check for session context match
+            const sessionMatch = this.matchParameter(paramName);
+            if (sessionMatch && sessionMatch.value !== undefined && sessionMatch.value !== null) {
+                finalParams[paramName] = sessionMatch.value;
+                autoDerived[paramName] = sessionMatch;
+                continue;
+            }
+            // If default value is provided in SP metadata
+            if (param.defaultValue !== undefined && param.defaultValue !== null) {
+                finalParams[paramName] = param.defaultValue;
+                continue;
+            }
+            // If required but not satisfied
+            if (param.required) {
+                unresolvedRequired.push(param);
+            }
+        }
+        // Also include any extra explicit mappings that didn't match parameter list
+        for (const [key, val] of Object.entries(explicitMappings)) {
+            if (!(key in finalParams) && val !== undefined && val !== null && val !== '') {
+                finalParams[key] = val;
+            }
+        }
+        return {
+            parameters: finalParams,
+            autoDerivedParams: autoDerived,
+            unresolvedRequiredParams: unresolvedRequired,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportSessionContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportSessionContextService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportSessionContextService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-session-context.service.js","sourceRoot":"","sources":["../../../../../../projects/bways-report/src/lib/core/services/report-session-context.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,MAAM,EACN,UAAU,EAEV,MAAM,GAEP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAA4B,MAAM,MAAM,CAAC;AAC9D,OAAO,EACL,sBAAsB,EACtB,uBAAuB,GAKxB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;;AAkBnE;;;;;;GAMG;AAIH,MAAM,OAAO,2BAA2B;IACrB,SAAS,GAAG,MAAM,CAA8B,sBAAsB,EAAE;QACvF,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IACc,eAAe,GAAG,MAAM,CAAgC,uBAAuB,EAAE;QAChG,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IAEH,wGAAwG;IACvF,oBAAoB,GAAG,MAAM,CAAoB,EAAE,CAAC,CAAC;IACrD,qBAAqB,GAAG,MAAM,CAAoB,EAAE,CAAC,CAAC;IACtD,uBAAuB,GAAG,MAAM,CAAoB,EAAE,CAAC,CAAC;IAEjE,aAAa,CAAgB;IAC7B,WAAW,CAAgB;IAEnC;;;;OAIG;IACM,cAAc,GAA8B,QAAQ,CAAC,GAAG,EAAE;QACjE,IAAI,WAAW,GAAsB,EAAE,CAAC;QACxC,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,IAAI,CAAC;gBACH,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,CAAC;gBACrD,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;oBAC9B,MAAM,GAAG,GAAI,GAA+B,EAAE,CAAC;oBAC/C,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;wBACnC,WAAW,GAAG,GAAG,CAAC;oBACpB,CAAC;gBACH,CAAC;qBAAM,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC7B,WAAW,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;gBAC/C,CAAC;qBAAM,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,IAAI,GAAG,CAAC,EAAE,CAAC;oBAC9D,WAAW,GAAG,GAAwB,CAAC;gBACzC,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,IAAI,CAAC,qEAAqE,EAAE,GAAG,CAAC,CAAC;YAC3F,CAAC;QACH,CAAC;QAED,IAAI,QAAQ,GAAsB,EAAE,CAAC;QACrC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC;gBACH,IAAI,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;oBACjC,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBAC1C,CAAC;qBAAM,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;oBAChD,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;oBAC7B,IAAI,OAAO,GAAG,KAAK,UAAU,EAAE,CAAC;wBAC9B,MAAM,QAAQ,GAAI,GAAqB,EAAE,CAAC;wBAC1C,QAAQ,GAAG,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAE,QAA8B,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC7F,CAAC;yBAAM,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC;wBAC7B,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;oBAC1C,CAAC;yBAAM,CAAC;wBACN,QAAQ,GAAG,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAE,GAAyB,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC9E,CAAC;gBACH,CAAC;qBAAM,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,QAAQ,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;oBACzE,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;gBAC5B,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,IAAI,CAAC,oEAAoE,EAAE,GAAG,CAAC,CAAC;YAC1F,CAAC;QACH,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAE9C,OAAO;YACL,GAAG,WAAW;YACd,GAAG,QAAQ;YACX,GAAG,SAAS;SACb,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH;;OAEG;IACM,eAAe,GAAkC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAE5F;QACE,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,EAAE,WAAW,EAAE,CAAC;QAClC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,CAAC;IAClC,CAAC;IAEO,iBAAiB;QACvB,IAAI,IAAI,CAAC,SAAS,IAAI,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YACnD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;gBAC5C,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE;oBACZ,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;wBACnC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC;oBAC7C,CAAC;gBACH,CAAC;gBACD,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;oBACb,OAAO,CAAC,IAAI,CAAC,sEAAsE,EAAE,GAAG,CAAC,CAAC;gBAC5F,CAAC;aACF,CAAC,CAAC;QACL,CAAC;QAED,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,IAAI,CAAC;gBACH,MAAM,GAAG,GAAG,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,CAAC;gBACrD,IAAI,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC;oBACtB,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC,SAAS,CAAC;wBAC/B,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE;4BACZ,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;gCACnC,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC;4BAC/C,CAAC;wBACH,CAAC;wBACD,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;4BACb,OAAO,CAAC,IAAI,CAAC,uEAAuE,EAAE,GAAG,CAAC,CAAC;wBAC7F,CAAC;qBACF,CAAC,CAAC;gBACL,CAAC;qBAAM,IACL,GAAG;oBACH,OAAO,GAAG,KAAK,QAAQ;oBACvB,MAAM,IAAI,GAAG;oBACb,OAAQ,GAAwB,CAAC,IAAI,KAAK,UAAU,EACpD,CAAC;oBACA,GAAkC;yBAChC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;wBACZ,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;4BACnC,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC;wBAC/C,CAAC;oBACH,CAAC,CAAC;yBACD,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;wBACb,OAAO,CAAC,IAAI,CAAC,oEAAoE,EAAE,GAAG,CAAC,CAAC;oBAC1F,CAAC,CAAC,CAAC;gBACP,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,IAAI,CAAC,oEAAoE,EAAE,GAAG,CAAC,CAAC;YAC1F,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,iBAAiB,CAAC,OAA0B;QAC1C,IAAI,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YAC3C,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QAChD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,GAAW,EAAE,KAA4B;QAC3D,IAAI,CAAC,GAAG;YAAE,OAAO;QACjB,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YAC7C,GAAG,OAAO;YACV,CAAC,GAAG,CAAC,EAAE,KAAK;SACb,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,mBAAmB;QACjB,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACpC,CAAC;IAED;;;OAGG;IACH,wBAAwB;QACtB,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC;QAC/B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,mEAAmE,EAAE,GAAG,CAAC,CAAC;YACvF,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,YAAY,CAAC,GAAW;QACtB,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ;YAAE,OAAO,EAAE,CAAC;QAC/C,OAAO,GAAG;aACP,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;aAClB,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC;aACxB,WAAW,EAAE,CAAC;IACnB,CAAC;IAED;;;OAGG;IACH,cAAc,CAAC,SAAiB;QAC9B,MAAM,OAAO,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChD,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACzC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAE1C,MAAM,eAAe,GAAG,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAErD,6BAA6B;QAC7B,IAAI,SAAS,IAAI,OAAO,EAAE,CAAC;YACzB,OAAO;gBACL,SAAS,EAAE,IAAI;gBACf,UAAU,EAAE,SAAS;gBACrB,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC;gBACzB,aAAa,EAAE,kBAAkB,CAAC,SAAS,CAAC;aAC7C,CAAC;QACJ,CAAC;QAED,6BAA6B;QAC7B,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;YAC9B,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,eAAe,EAAE,CAAC;gBAC/C,OAAO;oBACL,SAAS,EAAE,IAAI;oBACf,UAAU,EAAE,GAAG;oBACf,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC;oBACnB,aAAa,EAAE,kBAAkB,CAAC,GAAG,CAAC;iBACvC,CAAC;YACJ,CAAC;QACH,CAAC;QAED,wDAAwD;QACxD,MAAM,aAAa,GAAe;YAChC,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,CAAC;YACrE,CAAC,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,CAAC;YACpE,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,CAAC;YAChE,CAAC,eAAe,EAAE,iBAAiB,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,CAAC;YACrE,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,gBAAgB,CAAC;SACnD,CAAC;QAEF,KAAK,MAAM,KAAK,IAAI,aAAa,EAAE,CAAC;YAClC,IAAI,KAAK,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;gBACpC,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;oBAC9B,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;wBAC3C,OAAO;4BACL,SAAS,EAAE,IAAI;4BACf,UAAU,EAAE,GAAG;4BACf,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC;4BACnB,aAAa,EAAE,kBAAkB,CAAC,GAAG,CAAC;yBACvC,CAAC;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CACd,QAAsC,EACtC,mBAA4C,EAAE;QAE9C,MAAM,OAAO,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChD,MAAM,WAAW,GAA4B,EAAE,CAAC;QAChD,MAAM,WAAW,GAAsC,EAAE,CAAC;QAC1D,MAAM,kBAAkB,GAAiC,EAAE,CAAC;QAE5D,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;YAC7B,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC;YAC7B,MAAM,WAAW,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;YAEhD,qFAAqF;YACrF,MAAM,WAAW,GAAG,WAAW,KAAK,SAAS,IAAI,WAAW,KAAK,EAAE,IAAI,WAAW,KAAK,IAAI,CAAC;YAE5F,IAAI,WAAW,EAAE,CAAC;gBAChB,WAAW,CAAC,SAAS,CAAC,GAAG,WAAW,CAAC;gBACrC,SAAS;YACX,CAAC;YAED,kCAAkC;YAClC,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;YACpD,IAAI,YAAY,IAAI,YAAY,CAAC,KAAK,KAAK,SAAS,IAAI,YAAY,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;gBACpF,WAAW,CAAC,SAAS,CAAC,GAAG,YAAY,CAAC,KAAK,CAAC;gBAC5C,WAAW,CAAC,SAAS,CAAC,GAAG,YAAY,CAAC;gBACtC,SAAS;YACX,CAAC;YAED,8CAA8C;YAC9C,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,IAAI,KAAK,CAAC,YAAY,KAAK,IAAI,EAAE,CAAC;gBACpE,WAAW,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,YAAY,CAAC;gBAC5C,SAAS;YACX,CAAC;YAED,gCAAgC;YAChC,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACnB,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QAED,4EAA4E;QAC5E,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAC1D,IAAI,CAAC,CAAC,GAAG,IAAI,WAAW,CAAC,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,EAAE,EAAE,CAAC;gBAC7E,WAAW,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;YACzB,CAAC;QACH,CAAC;QAED,OAAO;YACL,UAAU,EAAE,WAAW;YACvB,iBAAiB,EAAE,WAAW;YAC9B,wBAAwB,EAAE,kBAAkB;SAC7C,CAAC;IACJ,CAAC;wGAxTU,2BAA2B;4GAA3B,2BAA2B,cAF1B,MAAM;;4FAEP,2BAA2B;kBAHvC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import {\n  computed,\n  inject,\n  Injectable,\n  OnDestroy,\n  signal,\n  Signal,\n} from '@angular/core';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { isObservable, Observable, Subscription } from 'rxjs';\nimport {\n  REPORT_SESSION_CONTEXT,\n  REPORT_SESSION_PROVIDER,\n  SessionContextMap,\n  SessionContextProvider,\n  SessionContextSource,\n  SessionParamPrimitive,\n} from '../tokens/session-context.token';\nimport { ProcedureParameterMetadata } from '../../data-access/contracts/schema-discovery.contract';\nimport { humanizeIdentifier } from '../utils/identifier-humanizer';\n\nexport interface SessionParamMatch {\n  isMatched: boolean;\n  sessionKey: string;\n  value: SessionParamPrimitive;\n  friendlyLabel: string;\n}\n\nexport interface DerivedParametersResult {\n  /** The consolidated parameter payload for stored procedure execution */\n  parameters: Record<string, unknown>;\n  /** Map of which SP parameters were auto-derived from session context */\n  autoDerivedParams: Record<string, SessionParamMatch>;\n  /** Any required parameters that were neither in session context nor explicitly mapped */\n  unresolvedRequiredParams: ProcedureParameterMetadata[];\n}\n\n/**\n * Service that manages host application session context parameters (e.g. branchId, companyId, userId)\n * at runtime and automatically detects and binds them to Stored Procedure parameters.\n *\n * Designed to completely shield end users from entering technical session parameters while\n * eliminating silent failures or thread crashes in host integrations.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReportSessionContextService implements OnDestroy {\n  private readonly rawSource = inject<SessionContextSource | null>(REPORT_SESSION_CONTEXT, {\n    optional: true,\n  });\n  private readonly sessionProvider = inject<SessionContextProvider | null>(REPORT_SESSION_PROVIDER, {\n    optional: true,\n  });\n\n  /** Internal manual runtime session overrides (e.g. set via setSessionContext or setSessionParameter) */\n  private readonly manualRuntimeContext = signal<SessionContextMap>({});\n  private readonly latestObservableValue = signal<SessionContextMap>({});\n  private readonly providerObservableValue = signal<SessionContextMap>({});\n\n  private observableSub?: Subscription;\n  private providerSub?: Subscription;\n\n  /**\n   * Reactive signal exposing the live session context parameters.\n   * Updates automatically when host app mutates runtime state, when observables emit,\n   * or when reactive signals update.\n   */\n  readonly sessionContext: Signal<SessionContextMap> = computed(() => {\n    let providerMap: SessionContextMap = {};\n    if (this.sessionProvider) {\n      try {\n        const res = this.sessionProvider.getSessionContext();\n        if (typeof res === 'function') {\n          const val = (res as () => SessionContextMap)();\n          if (val && typeof val === 'object') {\n            providerMap = val;\n          }\n        } else if (isObservable(res)) {\n          providerMap = this.providerObservableValue();\n        } else if (res && typeof res === 'object' && !('then' in res)) {\n          providerMap = res as SessionContextMap;\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error reading SessionContextProvider:', err);\n      }\n    }\n\n    let tokenMap: SessionContextMap = {};\n    if (this.rawSource) {\n      try {\n        if (isObservable(this.rawSource)) {\n          tokenMap = this.latestObservableValue();\n        } else if (typeof this.rawSource === 'function') {\n          const res = this.rawSource();\n          if (typeof res === 'function') {\n            const innerRes = (res as () => unknown)();\n            tokenMap = innerRes && typeof innerRes === 'object' ? (innerRes as SessionContextMap) : {};\n          } else if (isObservable(res)) {\n            tokenMap = this.latestObservableValue();\n          } else {\n            tokenMap = res && typeof res === 'object' ? (res as SessionContextMap) : {};\n          }\n        } else if (typeof this.rawSource === 'object' && this.rawSource !== null) {\n          tokenMap = this.rawSource;\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error evaluating raw session source:', err);\n      }\n    }\n\n    const manualMap = this.manualRuntimeContext();\n\n    return {\n      ...providerMap,\n      ...tokenMap,\n      ...manualMap,\n    };\n  });\n\n  /**\n   * Observable stream of live session parameters for RxJS-based integrations.\n   */\n  readonly sessionContext$: Observable<SessionContextMap> = toObservable(this.sessionContext);\n\n  constructor() {\n    this.initSubscriptions();\n  }\n\n  ngOnDestroy(): void {\n    this.observableSub?.unsubscribe();\n    this.providerSub?.unsubscribe();\n  }\n\n  private initSubscriptions(): void {\n    if (this.rawSource && isObservable(this.rawSource)) {\n      this.observableSub = this.rawSource.subscribe({\n        next: (val) => {\n          if (val && typeof val === 'object') {\n            this.latestObservableValue.set({ ...val });\n          }\n        },\n        error: (err) => {\n          console.warn('[ReportSessionContextService] Error from session context observable:', err);\n        },\n      });\n    }\n\n    if (this.sessionProvider) {\n      try {\n        const res = this.sessionProvider.getSessionContext();\n        if (isObservable(res)) {\n          this.providerSub = res.subscribe({\n            next: (val) => {\n              if (val && typeof val === 'object') {\n                this.providerObservableValue.set({ ...val });\n              }\n            },\n            error: (err) => {\n              console.warn('[ReportSessionContextService] Error from session provider observable:', err);\n            },\n          });\n        } else if (\n          res &&\n          typeof res === 'object' &&\n          'then' in res &&\n          typeof (res as Promise<unknown>).then === 'function'\n        ) {\n          (res as Promise<SessionContextMap>)\n            .then((val) => {\n              if (val && typeof val === 'object') {\n                this.providerObservableValue.set({ ...val });\n              }\n            })\n            .catch((err) => {\n              console.warn('[ReportSessionContextService] Error from session provider promise:', err);\n            });\n        }\n      } catch (err) {\n        console.warn('[ReportSessionContextService] Error initializing session provider:', err);\n      }\n    }\n  }\n\n  /**\n   * Sets or replaces the runtime session context.\n   * Can be called dynamically after user authentication, branch change, etc.\n   */\n  setSessionContext(context: SessionContextMap): void {\n    if (context && typeof context === 'object') {\n      this.manualRuntimeContext.set({ ...context });\n    } else {\n      this.manualRuntimeContext.set({});\n    }\n  }\n\n  /**\n   * Updates or sets a specific session parameter at runtime (e.g. branchId = 2).\n   */\n  setSessionParameter(key: string, value: SessionParamPrimitive): void {\n    if (!key) return;\n    this.manualRuntimeContext.update((current) => ({\n      ...current,\n      [key]: value,\n    }));\n  }\n\n  /**\n   * Clears any runtime session parameters set via `setSessionContext` or `setSessionParameter`.\n   */\n  clearSessionContext(): void {\n    this.manualRuntimeContext.set({});\n  }\n\n  /**\n   * Safely returns the current session context map.\n   * Always pulls the latest runtime state. Never throws or crashes the thread.\n   */\n  getCurrentSessionContext(): SessionContextMap {\n    try {\n      return this.sessionContext();\n    } catch (err) {\n      console.warn('[ReportSessionContextService] Failed to evaluate session context:', err);\n      return {};\n    }\n  }\n\n  /**\n   * Normalizes a parameter or session key into a lowercase alphanumeric string\n   * for reliable, case-insensitive, and symbol-insensitive matching.\n   * E.g. '@BranchId' -> 'branchid', 'branch_id' -> 'branchid', 'BranchID' -> 'branchid'\n   */\n  normalizeKey(key: string): string {\n    if (!key || typeof key !== 'string') return '';\n    return key\n      .replace(/^@+/, '')\n      .replace(/[_\\-\\s]+/g, '')\n      .toLowerCase();\n  }\n\n  /**\n   * Checks whether a stored procedure parameter matches any key in the active session context.\n   * Supports exact, normalized, and common ERP synonyms.\n   */\n  matchParameter(paramName: string): SessionParamMatch | null {\n    const session = this.getCurrentSessionContext();\n    const sessionKeys = Object.keys(session);\n    if (sessionKeys.length === 0) return null;\n\n    const normalizedParam = this.normalizeKey(paramName);\n\n    // 1. Exact match on raw name\n    if (paramName in session) {\n      return {\n        isMatched: true,\n        sessionKey: paramName,\n        value: session[paramName],\n        friendlyLabel: humanizeIdentifier(paramName),\n      };\n    }\n\n    // 2. Direct normalized match\n    for (const key of sessionKeys) {\n      if (this.normalizeKey(key) === normalizedParam) {\n        return {\n          isMatched: true,\n          sessionKey: key,\n          value: session[key],\n          friendlyLabel: humanizeIdentifier(key),\n        };\n      }\n    }\n\n    // 3. Common ERP synonym groups (bidirectional matching)\n    const synonymGroups: string[][] = [\n      ['branch', 'branchid', 'bid', 'branchcode', 'locationid', 'location'],\n      ['company', 'companyid', 'cid', 'companycode', 'tenant', 'tenantid'],\n      ['user', 'userid', 'uid', 'usercode', 'operatorid', 'loginuser'],\n      ['financialyear', 'financialyearid', 'yearid', 'fyear', 'fiscalyear'],\n      ['org', 'orgid', 'organization', 'organizationid'],\n    ];\n\n    for (const group of synonymGroups) {\n      if (group.includes(normalizedParam)) {\n        for (const key of sessionKeys) {\n          if (group.includes(this.normalizeKey(key))) {\n            return {\n              isMatched: true,\n              sessionKey: key,\n              value: session[key],\n              friendlyLabel: humanizeIdentifier(key),\n            };\n          }\n        }\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Resolves and derives all stored procedure parameters:\n   * - Preserves explicit overrides (e.g. from canvas form controls or manual inputs)\n   * - Automatically injects matched session parameters\n   * - Validates whether required parameters are fulfilled\n   */\n  deriveParameters(\n    spParams: ProcedureParameterMetadata[],\n    explicitMappings: Record<string, unknown> = {}\n  ): DerivedParametersResult {\n    const session = this.getCurrentSessionContext();\n    const finalParams: Record<string, unknown> = {};\n    const autoDerived: Record<string, SessionParamMatch> = {};\n    const unresolvedRequired: ProcedureParameterMetadata[] = [];\n\n    for (const param of spParams) {\n      const paramName = param.name;\n      const explicitVal = explicitMappings[paramName];\n\n      // Check if user or canvas explicitly provided a value (and not an empty placeholder)\n      const hasExplicit = explicitVal !== undefined && explicitVal !== '' && explicitVal !== null;\n\n      if (hasExplicit) {\n        finalParams[paramName] = explicitVal;\n        continue;\n      }\n\n      // Check for session context match\n      const sessionMatch = this.matchParameter(paramName);\n      if (sessionMatch && sessionMatch.value !== undefined && sessionMatch.value !== null) {\n        finalParams[paramName] = sessionMatch.value;\n        autoDerived[paramName] = sessionMatch;\n        continue;\n      }\n\n      // If default value is provided in SP metadata\n      if (param.defaultValue !== undefined && param.defaultValue !== null) {\n        finalParams[paramName] = param.defaultValue;\n        continue;\n      }\n\n      // If required but not satisfied\n      if (param.required) {\n        unresolvedRequired.push(param);\n      }\n    }\n\n    // Also include any extra explicit mappings that didn't match parameter list\n    for (const [key, val] of Object.entries(explicitMappings)) {\n      if (!(key in finalParams) && val !== undefined && val !== null && val !== '') {\n        finalParams[key] = val;\n      }\n    }\n\n    return {\n      parameters: finalParams,\n      autoDerivedParams: autoDerived,\n      unresolvedRequiredParams: unresolvedRequired,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,3 @@
+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=

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

@@ -0,0 +1,26 @@
+/**
+ * Reporting library configuration tokens.
+ *
+ * Core configuration models and injection tokens.
+ * Decoupled from UI primitives and data-access adapters.
+ */
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for the grid component.
+ *
+ * The host provides their grid component (BWays-grid, AG Grid wrapper, etc.)
+ * and the `ReportGridBridgeComponent` resolves it at runtime.
+ */
+export const GRID_COMPONENT = new InjectionToken('GRID_COMPONENT');
+/**
+ * Injection token for the chart component.
+ *
+ * The host can provide their preferred chart component (Chart.js, Highcharts, ApexCharts wrapper, etc.)
+ * and the `ReportChartBridgeComponent` delegates rendering to it, or falls back to built-in SVG charts.
+ */
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVwb3J0aW5nLWNvbmZpZy50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2J3YXlzLXJlcG9ydC9zcmMvbGliL2NvcmUvdG9rZW5zL3JlcG9ydGluZy1jb25maWcudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFFSCxPQUFPLEVBQUUsY0FBYyxFQUFRLE1BQU0sZUFBZSxDQUFDO0FBeUJyRDs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxJQUFJLGNBQWMsQ0FBZ0IsZ0JBQWdCLENBQUMsQ0FBQztBQUVsRjs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxJQUFJLGNBQWMsQ0FBZ0IsaUJBQWlCLENBQUMsQ0FBQztBQUVwRjs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLElBQUksY0FBYyxDQUFrQixrQkFBa0IsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXBvcnRpbmcgbGlicmFyeSBjb25maWd1cmF0aW9uIHRva2Vucy5cbiAqXG4gKiBDb3JlIGNvbmZpZ3VyYXRpb24gbW9kZWxzIGFuZCBpbmplY3Rpb24gdG9rZW5zLlxuICogRGVjb3VwbGVkIGZyb20gVUkgcHJpbWl0aXZlcyBhbmQgZGF0YS1hY2Nlc3MgYWRhcHRlcnMuXG4gKi9cblxuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBMaWJyYXJ5IGNvbmZpZ3VyYXRpb24gb3B0aW9ucy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBSZXBvcnRpbmdDb25maWcge1xuICAvKiogRGVmYXVsdCBwYWdlIHNpemUgZm9yIGdyaWRzLiAqL1xuICBkZWZhdWx0UGFnZVNpemU6IG51bWJlcjtcblxuICAvKiogRGF0ZSBmb3JtYXQgc3RyaW5nIHVzZWQgYWNyb3NzIHRoZSBsaWJyYXJ5LiAqL1xuICBkYXRlRm9ybWF0OiBzdHJpbmc7XG5cbiAgLyoqIFdoZXRoZXIgdGhlIERlc2lnbmVyIGZlYXR1cmUgaXMgZW5hYmxlZC4gKi9cbiAgZW5hYmxlRGVzaWduZXI6IGJvb2xlYW47XG5cbiAgLyoqIEN1cnJlbnQgc2NoZW1hIHZlcnNpb24gZm9yIG5ldyByZXBvcnRzLiAqL1xuICBzY2hlbWFWZXJzaW9uOiBudW1iZXI7XG5cbiAgLyoqIEJhc2UgVVJMIGZvciBiYWNrZW5kIHJlcG9ydGluZyBlbmRwb2ludHMgKE5lc3RKUyAvIC5ORVQgLyBSRVNUIEFQSSkuICovXG4gIGFwaUJhc2VVcmw/OiBzdHJpbmc7XG5cbiAgLyoqIFdoZXRoZXIgYXV0b21hdGljIGJhY2tlbmQgc2NoZW1hIGRpc2NvdmVyeSAoU1BzICYgVGFibGVzKSBpcyBlbmFibGVkLiAqL1xuICBlbmFibGVTY2hlbWFEaXNjb3Zlcnk/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIEluamVjdGlvbiB0b2tlbiBmb3IgdGhlIGdyaWQgY29tcG9uZW50LlxuICpcbiAqIFRoZSBob3N0IHByb3ZpZGVzIHRoZWlyIGdyaWQgY29tcG9uZW50IChCV2F5cy1ncmlkLCBBRyBHcmlkIHdyYXBwZXIsIGV0Yy4pXG4gKiBhbmQgdGhlIGBSZXBvcnRHcmlkQnJpZGdlQ29tcG9uZW50YCByZXNvbHZlcyBpdCBhdCBydW50aW1lLlxuICovXG5leHBvcnQgY29uc3QgR1JJRF9DT01QT05FTlQgPSBuZXcgSW5qZWN0aW9uVG9rZW48VHlwZTx1bmtub3duPj4oJ0dSSURfQ09NUE9ORU5UJyk7XG5cbi8qKlxuICogSW5qZWN0aW9uIHRva2VuIGZvciB0aGUgY2hhcnQgY29tcG9uZW50LlxuICpcbiAqIFRoZSBob3N0IGNhbiBwcm92aWRlIHRoZWlyIHByZWZlcnJlZCBjaGFydCBjb21wb25lbnQgKENoYXJ0LmpzLCBIaWdoY2hhcnRzLCBBcGV4Q2hhcnRzIHdyYXBwZXIsIGV0Yy4pXG4gKiBhbmQgdGhlIGBSZXBvcnRDaGFydEJyaWRnZUNvbXBvbmVudGAgZGVsZWdhdGVzIHJlbmRlcmluZyB0byBpdCwgb3IgZmFsbHMgYmFjayB0byBidWlsdC1pbiBTVkcgY2hhcnRzLlxuICovXG5leHBvcnQgY29uc3QgQ0hBUlRfQ09NUE9ORU5UID0gbmV3IEluamVjdGlvblRva2VuPFR5cGU8dW5rbm93bj4+KCdDSEFSVF9DT01QT05FTlQnKTtcblxuLyoqXG4gKiBJbmplY3Rpb24gdG9rZW4gZm9yIHRoZSByZXBvcnRpbmcgbGlicmFyeSBjb25maWd1cmF0aW9uLlxuICovXG5leHBvcnQgY29uc3QgUkVQT1JUSU5HX0NPTkZJRyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxSZXBvcnRpbmdDb25maWc+KCdSRVBPUlRJTkdfQ09ORklHJyk7XG4iXX0=

package/esm2022/lib/core/tokens/session-context.token.mjs

@@ -0,0 +1,18 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Injection token for host application session parameters.
+ * When configuring `provideReporting({ sessionContext: ... })`, the host app
+ * supplies their current session context (e.g. branchId, companyId, userId, tenantId).
+ */
+export const REPORT_SESSION_CONTEXT = new InjectionToken('REPORT_SESSION_CONTEXT');
+/**
+ * Service contract for host applications providing runtime session parameters.
+ * A host service (e.g. AuthService, SessionService) can implement this interface/class.
+ */
+export class SessionContextProvider {
+}
+/**
+ * Injection token for host application session provider service class.
+ */
+export const REPORT_SESSION_PROVIDER = new InjectionToken('REPORT_SESSION_PROVIDER');
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/utilities/id-generator.mjs

@@ -0,0 +1,17 @@
+/**
+ * Generates a unique identifier with a given prefix.
+ *
+ * Safe for modern browser and Node environments.
+ *
+ * @param prefix - Prefix for the ID (default 'cmp').
+ * @returns Unique string ID (e.g. 'cmp-4a7b2c9d').
+ */
+export function generateId(prefix = 'cmp') {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return `${prefix}-${crypto.randomUUID().slice(0, 8)}`;
+    }
+    // Fallback random generation
+    const random = Math.random().toString(36).substring(2, 10);
+    return `${prefix}-${random}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWQtZ2VuZXJhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYndheXMtcmVwb3J0L3NyYy9saWIvY29yZS91dGlsaXRpZXMvaWQtZ2VuZXJhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFVBQVUsVUFBVSxDQUFDLE1BQU0sR0FBRyxLQUFLO0lBQ3ZDLElBQUksT0FBTyxNQUFNLEtBQUssV0FBVyxJQUFJLE9BQU8sTUFBTSxDQUFDLFVBQVUsS0FBSyxVQUFVLEVBQUUsQ0FBQztRQUM3RSxPQUFPLEdBQUcsTUFBTSxJQUFJLE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUM7SUFDeEQsQ0FBQztJQUVELDZCQUE2QjtJQUM3QixNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDM0QsT0FBTyxHQUFHLE1BQU0sSUFBSSxNQUFNLEVBQUUsQ0FBQztBQUMvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZXMgYSB1bmlxdWUgaWRlbnRpZmllciB3aXRoIGEgZ2l2ZW4gcHJlZml4LlxuICpcbiAqIFNhZmUgZm9yIG1vZGVybiBicm93c2VyIGFuZCBOb2RlIGVudmlyb25tZW50cy5cbiAqXG4gKiBAcGFyYW0gcHJlZml4IC0gUHJlZml4IGZvciB0aGUgSUQgKGRlZmF1bHQgJ2NtcCcpLlxuICogQHJldHVybnMgVW5pcXVlIHN0cmluZyBJRCAoZS5nLiAnY21wLTRhN2IyYzlkJykuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZW5lcmF0ZUlkKHByZWZpeCA9ICdjbXAnKTogc3RyaW5nIHtcbiAgaWYgKHR5cGVvZiBjcnlwdG8gIT09ICd1bmRlZmluZWQnICYmIHR5cGVvZiBjcnlwdG8ucmFuZG9tVVVJRCA9PT0gJ2Z1bmN0aW9uJykge1xuICAgIHJldHVybiBgJHtwcmVmaXh9LSR7Y3J5cHRvLnJhbmRvbVVVSUQoKS5zbGljZSgwLCA4KX1gO1xuICB9XG5cbiAgLy8gRmFsbGJhY2sgcmFuZG9tIGdlbmVyYXRpb25cbiAgY29uc3QgcmFuZG9tID0gTWF0aC5yYW5kb20oKS50b1N0cmluZygzNikuc3Vic3RyaW5nKDIsIDEwKTtcbiAgcmV0dXJuIGAke3ByZWZpeH0tJHtyYW5kb219YDtcbn1cbiJdfQ==

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

@@ -0,0 +1,3 @@
+export { generateId } from './id-generator';
+export { migrateDefinition } from './schema-migration';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3V0aWxpdGllcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDNUMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBnZW5lcmF0ZUlkIH0gZnJvbSAnLi9pZC1nZW5lcmF0b3InO1xuZXhwb3J0IHsgbWlncmF0ZURlZmluaXRpb24gfSBmcm9tICcuL3NjaGVtYS1taWdyYXRpb24nO1xuZXhwb3J0IHR5cGUgeyBNaWdyYXRpb25GbiB9IGZyb20gJy4vc2NoZW1hLW1pZ3JhdGlvbic7XG4iXX0=

package/esm2022/lib/core/utilities/schema-migration.mjs

@@ -0,0 +1,38 @@
+import { SchemaVersionError } from '../errors/reporting-errors';
+/**
+ * Migration registry mapping sourceVersion -> targetVersion migration function.
+ */
+const MIGRATIONS = {
+// Example migration for v1 to v2 in future:
+// 1: (def) => ({ ...def, schemaVersion: 2, ... }),
+};
+/**
+ * Migrates a ReportDefinition to a target schema version.
+ *
+ * @param definition - Source report definition.
+ * @param targetVersion - Desired schema version (default current version = 1).
+ * @returns Migrated ReportDefinition.
+ */
+export function migrateDefinition(definition, targetVersion = 1) {
+    if (!definition) {
+        throw new SchemaVersionError(0, targetVersion, 'Invalid report definition provided');
+    }
+    const currentVersion = definition.schemaVersion ?? 1;
+    if (currentVersion === targetVersion) {
+        return { ...definition, schemaVersion: targetVersion };
+    }
+    if (currentVersion > targetVersion) {
+        throw new SchemaVersionError(currentVersion, targetVersion, `Cannot downgrade report schema from version ${currentVersion} to ${targetVersion}`);
+    }
+    let migrated = { ...definition };
+    for (let v = currentVersion; v < targetVersion; v++) {
+        const migrationFn = MIGRATIONS[v];
+        if (!migrationFn) {
+            throw new SchemaVersionError(v, v + 1, `No migration path defined from schema version ${v} to ${v + 1}`);
+        }
+        migrated = migrationFn(migrated);
+    }
+    migrated.schemaVersion = targetVersion;
+    return migrated;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,88 @@
+/**
+ * Strips technical SQL prefixes (usp_, sp_, tbl_, vw_, @), removes schema if present,
+ * and converts snake_case, PascalCase, or camelCase into clean, human-readable Title Case.
+ *
+ * Examples:
+ * - 'dbo.usp_GetCustomerList' -> 'Customer List'
+ * - 'usp_GetBranches' -> 'Branches'
+ * - '@BranchId' -> 'Branch'
+ * - '@ActiveOnly' -> 'Active Only'
+ * - 'tbl_Products' -> 'Products'
+ * - 'customer_name_en' -> 'Customer Name En'
+ */
+export function humanizeIdentifier(raw) {
+    if (!raw || typeof raw !== 'string')
+        return '';
+    // 1. Remove schema (e.g. 'dbo.')
+    let text = raw.includes('.') ? raw.split('.').pop() : raw;
+    // 2. Remove leading @, and prefixes like sp_, usp_, tbl_, vw_, get_ repeatedly
+    text = text.replace(/^@+/, '');
+    while (/^(usp_|sp_|tbl_|vw_|get_)/i.test(text)) {
+        text = text.replace(/^(usp_|sp_|tbl_|vw_|get_)/i, '');
+    }
+    // 3. If it starts with 'Get' followed by uppercase (e.g. 'GetCustomerList'), strip 'Get'
+    if (/^get[A-Z]/i.test(text)) {
+        text = text.slice(3);
+    }
+    // 4. Split snake_case and kebab-case
+    text = text.replace(/[_-]+/g, ' ');
+    // 5. Split PascalCase and camelCase (e.g. 'CustomerList' -> 'Customer List', 'BranchId' -> 'Branch Id')
+    text = text.replace(/([a-z0-9])([A-Z])/g, '$1 $2');
+    text = text.replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+    // 6. Clean up trailing ' Id' if it's a parameter label (e.g. 'Branch Id' -> 'Branch')
+    // We keep it natural for parameters: 'Branch' is clearer than 'Branch Id' for non-technical users
+    if (text.endsWith(' Id') && text.length > 3) {
+        text = text.slice(0, -3);
+    }
+    // 7. Title-case each word
+    return text
+        .split(' ')
+        .filter(Boolean)
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join(' ');
+}
+/**
+ * Detects the most probable column to use as the value/key (e.g. ID, Code, Key, Guid).
+ */
+export function detectDefaultValueField(columns) {
+    if (!columns || columns.length === 0)
+        return undefined;
+    // 1. Check exact matches for 'id' or 'key' or 'code'
+    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'
+    const suffixMatch = columns.find((c) => {
+        const f = c.field.toLowerCase();
+        return f.endsWith('_id') || f.endsWith('id') || f.endsWith('_code') || f.endsWith('code');
+    });
+    if (suffixMatch)
+        return suffixMatch.field;
+    // 3. Fallback to first column
+    return columns[0]?.field;
+}
+/**
+ * Detects the most probable column to use as the display text (e.g. Name, Title, Label, Description).
+ */
+export function detectDefaultDisplayField(columns) {
+    if (!columns || columns.length === 0)
+        return undefined;
+    // 1. Look for text fields containing 'name', 'title', 'label', 'desc'
+    const nameMatch = columns.find((c) => {
+        const f = c.field.toLowerCase();
+        return (f.includes('name') ||
+            f.includes('title') ||
+            f.includes('label') ||
+            f.includes('description') ||
+            f.includes('desc'));
+    });
+    if (nameMatch)
+        return nameMatch.field;
+    // 2. Look for any string dataType column
+    const stringMatch = columns.find((c) => c.dataType === 'string');
+    if (stringMatch)
+        return stringMatch.field;
+    // 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"]}

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

@@ -0,0 +1,2 @@
+export { createValidators, getValidationMessage } from './validation-factory';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9id2F5cy1yZXBvcnQvc3JjL2xpYi9jb3JlL3ZhbGlkYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLG9CQUFvQixFQUFFLE1BQU0sc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBjcmVhdGVWYWxpZGF0b3JzLCBnZXRWYWxpZGF0aW9uTWVzc2FnZSB9IGZyb20gJy4vdmFsaWRhdGlvbi1mYWN0b3J5JztcbiJdfQ==