@zeniai/client-epic-state 4.20.0 → 4.20.1-beta11ND

package/lib/view/profitAndLossClassesView/horizontalSectionEmptyBalancesSlice.d.ts

@@ -0,0 +1,9 @@
+import { COABalanceTimeFrame } from '../../commonStateTypes/coaBalance/coaBalance';
+import { COABalancesSlice } from '../../commonStateTypes/coaBalance/coaBalancesFilter';
+import { Month } from '../../commonStateTypes/timePeriod';
+/**
+ * Empty `COABalancesSlice` for horizontal P&L-by-class section / calculated headers when
+ * enrichment has not produced balances yet, or for UI mapping fallbacks.
+ * Structure matches {@link enrichProfitAndLossByClassHorizontalReport} output.
+ */
+export declare function getEmptyHorizontalSectionBalancesSlice(firstMonthOfFY: Month, timeframe?: COABalanceTimeFrame): COABalancesSlice;

package/lib/view/profitAndLossClassesView/horizontalSectionEmptyBalancesSlice.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmptyHorizontalSectionBalancesSlice = getEmptyHorizontalSectionBalancesSlice;
+/**
+ * Empty `COABalancesSlice` for horizontal P&L-by-class section / calculated headers when
+ * enrichment has not produced balances yet, or for UI mapping fallbacks.
+ * Structure matches {@link enrichProfitAndLossByClassHorizontalReport} output.
+ */
+function getEmptyHorizontalSectionBalancesSlice(firstMonthOfFY, timeframe = 'month') {
+    return {
+        balances: [],
+        additionalBalances: [],
+        filter: {
+            firstMonthOfFY,
+            timeframe,
+            balancesRange: { numberOfPeriods: 0, orderBy: 'ascending_date' },
+            additionalBalances: [],
+        },
+    };
+}

package/lib/view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector.js

@@ -52,16 +52,11 @@ const getProfitAndLossClassesHorizontalView = (filter, accountState, classState,
     const calculatedSections = {};
     let reportCurrency = currencyHelper_1.defaultCustomerCurrency;
     if (fetchState.fetchState === 'Completed' && selectedPeriod != null) {
-        // Get section reports using existing selector infrastructure
-        const sectionReports = {};
-        HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
-            sectionReports[sectionId] = (0, sectionClassesViewSelector_1.getSectionClassesViewReport)(accountState, classState, sectionsState, { reportId, sectionId }, filter);
-        });
         reportCurrency =
             profitAndLossClassesViewState.currency ?? currencyHelper_1.defaultCustomerCurrency;
-        // Pivot each section from class→account to account→class
+        // Fetch each section and pivot class→account to account→class in one pass
         HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
-            const sectionReport = sectionReports[sectionId];
+            const sectionReport = (0, sectionClassesViewSelector_1.getSectionClassesViewReport)(accountState, classState, sectionsState, { reportId, sectionId }, filter);
             if (sectionReport != null) {
                 sections[sectionId] = pivotSectionToHorizontal(sectionReport, classColumns, SECTION_TITLES[sectionId] ?? sectionId, reportCurrency);
             }
@@ -265,7 +260,7 @@ function sumBalancesInSlice(balances) {
     if (balances.length === 0) {
         return 0;
     }
-    const summed = (0, getSummationBalance_1.getSummationFreeRangeTotalBalance)([...balances]);
+    const summed = (0, getSummationBalance_1.getSummationFreeRangeTotalBalance)(balances);
     return summed?.balance.amount ?? 0;
 }
 /**

package/lib/view/profitAndLossClassesView/profitAndLossHorizontalEnrichment.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enrichProfitAndLossByClassHorizontalReport = enrichProfitAndLossByClassHorizontalReport;
 const currencyHelper_1 = require("../../commonStateTypes/currencyHelper");
+const horizontalSectionEmptyBalancesSlice_1 = require("./horizontalSectionEmptyBalancesSlice");
 const profitAndLossClassesByClassHorizontalSelectorTypes_1 = require("./profitAndLossClassesByClassHorizontalSelectorTypes");
 /**
  * Populates `sectionHeaderBalancesSlice`, and per-account `accountReportData`, so the
@@ -28,30 +29,31 @@ function enrichHorizontalSection(report, section) {
         return total?.balance.amount ?? 0;
     });
     section.sectionHeaderBalancesSlice = buildHorizontalClassColumnBalancesSlice(report, classAmounts, section.sectionTotal.amount);
-    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(section.accounts);
+    const parentIndices = computeHorizontalAccountParentIndices(section.accounts);
+    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(parentIndices);
     const childrenRecord = {};
     childrenRowIndicesByParent.forEach((childIndices, parentIndex) => {
         childrenRecord[parentIndex] = childIndices;
     });
     section.treeLayout = {
         rootAccountRowIndices: section.accounts
-            .map((_, i) => findHorizontalAccountParentIndex(section.accounts, i) === -1 ? i : -1)
+            .map((_, i) => (parentIndices[i] === -1 ? i : -1))
             .filter((i) => i >= 0),
         childrenRowIndicesByParent: childrenRecord,
     };
-    for (let i = 0; i < section.accounts.length; i++) {
-        const row = section.accounts[i];
-        const classRowAmounts = report.classColumns.map((col) => {
-            const cb = row.classBalances.find((b) => b.classId === col.classId);
-            return cb?.balance.amount ?? 0;
-        });
+    const siblingsPerRow = buildSiblingIndicesPerRow(section.accounts, parentIndices);
+    const hasChildFlags = computeHorizontalHasChildFlags(parentIndices);
+    for (let accountIndex = 0; accountIndex < section.accounts.length; accountIndex++) {
+        const row = section.accounts[accountIndex];
+        // Same column order as `report.classColumns` (see `pivotSectionToHorizontal`).
+        const classRowAmounts = row.classBalances.map((classBalance) => classBalance.balance.amount);
         row.accountReportData = {
             accountId: row.accountId,
             accountName: row.accountName,
             accountType: row.accountType,
             depth: row.depth,
             balancesInTimeframe: buildHorizontalClassColumnBalancesSlice(report, classRowAmounts, row.rowTotal.amount),
-            horizontalTreeView: buildHorizontalTreeView(section.accounts, i),
+            horizontalTreeView: buildHorizontalTreeViewFromPrecomputed(section.accounts, accountIndex, parentIndices, siblingsPerRow, hasChildFlags),
         };
     }
 }
@@ -69,23 +71,14 @@ function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmou
     const currencyCode = firstHeader?.balance.currencyCode ?? fallback.currencyCode;
     const currencySymbol = firstHeader?.balance.currencySymbol ?? fallback.currencySymbol;
     const timeframe = firstHeader?.balanceTimeFrame ?? 'month';
-    const emptySlice = {
-        balances: [],
-        additionalBalances: [],
-        filter: {
-            firstMonthOfFY: report.firstMonthOfFY,
-            timeframe,
-            balancesRange: { numberOfPeriods: 0, orderBy: 'ascending_date' },
-            additionalBalances: [],
-        },
-    };
+    const emptySlice = (0, horizontalSectionEmptyBalancesSlice_1.getEmptyHorizontalSectionBalancesSlice)(report.firstMonthOfFY, timeframe);
     if (report.selectedPeriod == null) {
         return emptySlice;
     }
     const { startDate, endDate } = report.selectedPeriod;
-    const balances = report.classColumns.map((col, i) => ({
+    const balances = report.classColumns.map((col, columnIndex) => ({
         balance: {
-            amount: classAmounts[i] ?? 0,
+            amount: classAmounts[columnIndex] ?? 0,
             currencyCode,
             currencySymbol,
         },
@@ -123,64 +116,143 @@ function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmou
         },
     };
 }
-function findHorizontalAccountParentIndex(dfsOrderedAccountRows, childRowIndex) {
-    const childDepth = dfsOrderedAccountRows[childRowIndex].depth;
-    if (childDepth <= 2) {
-        return -1;
-    }
-    for (let earlierRowIndex = childRowIndex - 1; earlierRowIndex >= 0; earlierRowIndex--) {
-        const earlierDepth = dfsOrderedAccountRows[earlierRowIndex].depth;
-        if (earlierDepth < childDepth) {
-            if (earlierDepth === childDepth - 1) {
-                return earlierRowIndex;
+/**
+ * Parent index per DFS row — O(n). Matches the scan in the former
+ * `findHorizontalAccountParentIndex` (depth &lt;= 2 rows have no parent).
+ */
+function computeHorizontalAccountParentIndices(rows) {
+    const accountRowCount = rows.length;
+    const parentIndex = new Array(accountRowCount).fill(-1);
+    const stack = [];
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const accountRow = rows[rowIndex];
+        if (accountRow == null) {
+            continue;
+        }
+        const depth = accountRow.depth;
+        while (stack.length > 0) {
+            const topRow = rows[stack[stack.length - 1]];
+            if (topRow == null) {
+                stack.pop();
+                continue;
+            }
+            if (topRow.depth < depth) {
+                break;
+            }
+            stack.pop();
+        }
+        if (depth > 2 && stack.length > 0) {
+            const peek = stack[stack.length - 1];
+            const parentRow = rows[peek];
+            if (parentRow != null && parentRow.depth === depth - 1) {
+                parentIndex[rowIndex] = peek;
             }
-            return -1;
         }
+        stack.push(rowIndex);
     }
-    return -1;
+    return parentIndex;
 }
-function getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, rowIndex) {
-    const parentRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex);
-    const rowDepth = dfsOrderedAccountRows[rowIndex].depth;
-    const siblings = [];
-    for (let i = 0; i < dfsOrderedAccountRows.length; i++) {
-        if (dfsOrderedAccountRows[i].depth === rowDepth &&
-            findHorizontalAccountParentIndex(dfsOrderedAccountRows, i) ===
-                parentRowIndex) {
-            siblings.push(i);
+/** Sibling row indices (same parent + depth), in traversal order — O(n). */
+function buildSiblingIndicesPerRow(rows, parentIndices) {
+    const accountRowCount = rows.length;
+    const keyToIndices = new Map();
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        const accountRow = rows[rowIndex];
+        if (parentRowIndex == null || accountRow == null) {
+            continue;
+        }
+        const key = `${parentRowIndex}:${accountRow.depth}`;
+        let siblingGroup = keyToIndices.get(key);
+        if (siblingGroup == null) {
+            siblingGroup = [];
+            keyToIndices.set(key, siblingGroup);
+        }
+        siblingGroup.push(rowIndex);
+    }
+    const siblingsPerRow = new Array(accountRowCount);
+    for (let rowIndex = 0; rowIndex < accountRowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        const accountRow = rows[rowIndex];
+        if (parentRowIndex == null || accountRow == null) {
+            siblingsPerRow[rowIndex] = [rowIndex];
+            continue;
         }
+        const key = `${parentRowIndex}:${accountRow.depth}`;
+        const group = keyToIndices.get(key);
+        siblingsPerRow[rowIndex] = group != null ? group : [rowIndex];
     }
-    return siblings;
+    return siblingsPerRow;
 }
-function horizontalAccountHasChildRows(dfsOrderedAccountRows, parentRowIndex) {
-    return dfsOrderedAccountRows.some((_, rowIndex) => findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex) ===
-        parentRowIndex);
+function computeHorizontalHasChildFlags(parentIndices) {
+    const rowCount = parentIndices.length;
+    const flags = new Array(rowCount).fill(false);
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        if (parentRowIndex != null &&
+            parentRowIndex >= 0 &&
+            parentRowIndex < rowCount) {
+            flags[parentRowIndex] = true;
+        }
+    }
+    return flags;
 }
-function buildHorizontalSubAccountAncestorMetadata(dfsOrderedAccountRows, currentRowIndex) {
-    const ancestorRowIndicesRootToLeaf = [];
+function buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
+    const chain = [];
     let walkRowIndex = currentRowIndex;
     while (walkRowIndex >= 0) {
-        ancestorRowIndicesRootToLeaf.unshift(walkRowIndex);
-        walkRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, walkRowIndex);
+        chain.unshift(walkRowIndex);
+        const parentRowIndex = parentIndices[walkRowIndex];
+        if (parentRowIndex == null) {
+            break;
+        }
+        walkRowIndex = parentRowIndex;
     }
-    return ancestorRowIndicesRootToLeaf.map((rowIndex) => {
-        const siblingIndices = getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, rowIndex);
+    return chain.map((rowIndex) => {
+        const accountRow = dfsOrderedAccountRows[rowIndex];
+        const siblingIndices = siblingsPerRow[rowIndex];
+        const hasChild = hasChildFlags[rowIndex];
+        if (accountRow == null || siblingIndices == null) {
+            return {
+                depth: 0,
+                hasSibling: false,
+                hasChildren: hasChild === true,
+                isLastNode: true,
+                name: '',
+            };
+        }
         return {
-            depth: dfsOrderedAccountRows[rowIndex].depth - 2,
+            depth: accountRow.depth - 2,
             hasSibling: siblingIndices.length > 1,
-            hasChildren: horizontalAccountHasChildRows(dfsOrderedAccountRows, rowIndex),
+            hasChildren: hasChild === true,
             isLastNode: rowIndex === siblingIndices[siblingIndices.length - 1],
-            name: dfsOrderedAccountRows[rowIndex].accountName,
+            name: accountRow.accountName,
         };
     });
 }
-function buildHorizontalAccountChildIndicesByParent(dfsOrderedAccountRows) {
+function buildHorizontalTreeViewFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
+    const siblingIndices = siblingsPerRow[currentRowIndex];
+    const accountRow = dfsOrderedAccountRows[currentRowIndex];
+    const hasChildrenFlag = hasChildFlags[currentRowIndex];
+    const treeDepth = accountRow != null ? Math.max(0, accountRow.depth - 2) : 0;
+    const hasChildren = hasChildrenFlag === true;
+    const siblings = siblingIndices ?? [currentRowIndex];
+    return {
+        subAccountAncestorMetadata: buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags),
+        treeDepth,
+        hasChildren,
+        hasSiblings: siblings.length > 1,
+        isLeaf: !hasChildren,
+        isLastNode: currentRowIndex === siblings[siblings.length - 1],
+    };
+}
+function buildHorizontalAccountChildIndicesByParent(parentIndices) {
     const childIndicesByParentRowIndex = new Map();
-    for (let rowIndex = 0; rowIndex < dfsOrderedAccountRows.length; rowIndex++) {
-        const parentRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex);
-        if (parentRowIndex >= 0) {
+    for (let rowIndex = 0; rowIndex < parentIndices.length; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        if (parentRowIndex != null && parentRowIndex >= 0) {
             let childRowIndices = childIndicesByParentRowIndex.get(parentRowIndex);
-            if (childRowIndices === undefined) {
+            if (childRowIndices == null) {
                 childRowIndices = [];
                 childIndicesByParentRowIndex.set(parentRowIndex, childRowIndices);
             }
@@ -189,16 +261,3 @@ function buildHorizontalAccountChildIndicesByParent(dfsOrderedAccountRows) {
     }
     return childIndicesByParentRowIndex;
 }
-function buildHorizontalTreeView(dfsOrderedAccountRows, currentRowIndex) {
-    const treeDepth = Math.max(0, dfsOrderedAccountRows[currentRowIndex].depth - 2);
-    const siblingIndices = getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, currentRowIndex);
-    const hasChildren = horizontalAccountHasChildRows(dfsOrderedAccountRows, currentRowIndex);
-    return {
-        subAccountAncestorMetadata: buildHorizontalSubAccountAncestorMetadata(dfsOrderedAccountRows, currentRowIndex),
-        treeDepth,
-        hasChildren,
-        hasSiblings: siblingIndices.length > 1,
-        isLeaf: !hasChildren,
-        isLastNode: currentRowIndex === siblingIndices[siblingIndices.length - 1],
-    };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeniai/client-epic-state",
-  "version": "4.20.0",
+  "version": "4.20.1-beta11ND",
   "description": "Shared module between Web & Mobile containing required abstractions for state management, async network communication. ",
   "main": "lib/index.js",
   "module": "lib/esm/index.js",