@zeniai/client-epic-state 4.19.99 → 4.20.0-beta0ND

package/lib/esm/view/profitAndLossClassesView/profitAndLossClassesByClassHorizontalSelector.js

@@ -49,16 +49,11 @@ export const getProfitAndLossClassesHorizontalView = (filter, accountState, clas
     const calculatedSections = {};
     let reportCurrency = defaultCustomerCurrency;
     if (fetchState.fetchState === 'Completed' && selectedPeriod != null) {
-        // Get section reports using existing selector infrastructure
-        const sectionReports = {};
-        HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
-            sectionReports[sectionId] = getSectionClassesViewReport(accountState, classState, sectionsState, { reportId, sectionId }, filter);
-        });
         reportCurrency =
             profitAndLossClassesViewState.currency ?? 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 = getSectionClassesViewReport(accountState, classState, sectionsState, { reportId, sectionId }, filter);
             if (sectionReport != null) {
                 sections[sectionId] = pivotSectionToHorizontal(sectionReport, classColumns, SECTION_TITLES[sectionId] ?? sectionId, reportCurrency);
             }
@@ -261,7 +256,7 @@ function sumBalancesInSlice(balances) {
     if (balances.length === 0) {
         return 0;
     }
-    const summed = getSummationFreeRangeTotalBalance([...balances]);
+    const summed = getSummationFreeRangeTotalBalance(balances);
     return summed?.balance.amount ?? 0;
 }
 /**

package/lib/esm/view/profitAndLossClassesView/profitAndLossHorizontalEnrichment.js

@@ -25,30 +25,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,
     };
+    const siblingsPerRow = buildSiblingIndicesPerRow(section.accounts, parentIndices);
+    const hasChildFlags = computeHorizontalHasChildFlags(parentIndices);
     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;
-        });
+        // Same column order as `report.classColumns` (see `pivotSectionToHorizontal`).
+        const classRowAmounts = row.classBalances.map((b) => b.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, i, parentIndices, siblingsPerRow, hasChildFlags),
         };
     }
 }
@@ -120,64 +121,157 @@ 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 d = accountRow.depth;
+        while (stack.length > 0) {
+            const topIdx = stack[stack.length - 1];
+            if (topIdx == null) {
+                break;
             }
-            return -1;
+            const topRow = rows[topIdx];
+            if (topRow == null) {
+                stack.pop();
+                continue;
+            }
+            if (topRow.depth < d) {
+                break;
+            }
+            stack.pop();
+        }
+        if (d <= 2) {
+            parentIndex[rowIndex] = -1;
+        }
+        else if (stack.length === 0) {
+            parentIndex[rowIndex] = -1;
         }
+        else {
+            const peek = stack[stack.length - 1];
+            if (peek == null) {
+                parentIndex[rowIndex] = -1;
+            }
+            else {
+                const parentRow = rows[peek];
+                parentIndex[rowIndex] =
+                    parentRow != null && parentRow.depth === d - 1 ? peek : -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 g = keyToIndices.get(key);
+        if (g == null) {
+            g = [];
+            keyToIndices.set(key, g);
         }
+        g.push(rowIndex);
     }
-    return siblings;
+    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 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 sibs = siblingIndices ?? [currentRowIndex];
+    return {
+        subAccountAncestorMetadata: buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags),
+        treeDepth,
+        hasChildren,
+        hasSiblings: sibs.length > 1,
+        isLeaf: !hasChildren,
+        isLastNode: currentRowIndex === sibs[sibs.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);
             }
@@ -186,16 +280,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],
-    };
-}