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

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

@@ -0,0 +1,322 @@
+import { toAmountWC } from '../../commonStateTypes/amount';
+import { getSummationFreeRangeTotalBalance } from '../../commonStateTypes/coaBalance/additionalBalances/getSummationBalance';
+import { defaultCustomerCurrency } from '../../commonStateTypes/currencyHelper';
+import { reduceFetchStateParallelTimeframes } from '../../commonStateTypes/reduceFetchState';
+import { getSectionClassesViewReport } from '../../entity/sectionClassesViewV2/sectionClassesViewSelector';
+import { enrichProfitAndLossByClassHorizontalReport } from './profitAndLossHorizontalEnrichment';
+export const profitAndLossHorizontalIdsInOrder = [
+    'income',
+    'cogs',
+    'grossProfit',
+    'expenses',
+    'earningsBeforeInterestAndTax',
+    'otherIncome',
+    'otherExpenses',
+    'netOtherIncome',
+    'netIncome',
+];
+const SECTION_TITLES = {
+    income: 'Income',
+    cogs: 'Cost of Goods Sold',
+    grossProfit: 'Gross Profit',
+    expenses: 'Expenses',
+    earningsBeforeInterestAndTax: 'Net Operating Income',
+    otherIncome: 'Other Income',
+    otherExpenses: 'Other Expenses',
+    netOtherIncome: 'Net Other Income',
+    netIncome: 'Net Income',
+};
+/** Sections fetched and pivoted for horizontal layout (excludes e.g. `netOperatingIncome`). */
+const HORIZONTAL_PANDL_SECTION_IDS = [
+    'income',
+    'cogs',
+    'expenses',
+    'otherIncome',
+    'otherExpenses',
+];
+export const getProfitAndLossClassesHorizontalView = (filter, accountState, classState, sectionsState, profitAndLossClassesViewState, selectedPeriod) => {
+    const fetchState = reduceFetchStateParallelTimeframes([
+        profitAndLossClassesViewState.fetchState.month,
+        profitAndLossClassesViewState.fetchState.quarter,
+        profitAndLossClassesViewState.fetchState.year,
+    ]);
+    const reportId = 'profit_and_loss_by_classes';
+    // Build class columns from the class hierarchy (top-level only).
+    // Use `filter.classesToFilterOut` so PDF/Excel downloads (fresh store, empty UI state)
+    // respect `classes_to_filter_out` from the request; in-app `classFilter` mirrors uiState.
+    const classColumns = buildClassColumns(profitAndLossClassesViewState.classHierarchy, filter.classesToFilterOut);
+    const sections = {};
+    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
+        HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
+            const sectionReport = sectionReports[sectionId];
+            if (sectionReport != null) {
+                sections[sectionId] = pivotSectionToHorizontal(sectionReport, classColumns, SECTION_TITLES[sectionId] ?? sectionId, reportCurrency);
+            }
+        });
+        // Calculate derived sections
+        const incomeSection = sections['income'];
+        const cogsSection = sections['cogs'];
+        const expensesSection = sections['expenses'];
+        const otherIncomeSection = sections['otherIncome'];
+        const otherExpensesSection = sections['otherExpenses'];
+        // Gross Profit = Income - COGS
+        if (incomeSection != null && cogsSection != null) {
+            calculatedSections['grossProfit'] = computeCalculatedSection(incomeSection.classTotals, cogsSection.classTotals, incomeSection.sectionTotal, cogsSection.sectionTotal, 'subtract', SECTION_TITLES['grossProfit']);
+        }
+        // EBIT = Gross Profit - Expenses
+        const grossProfit = calculatedSections['grossProfit'];
+        if (grossProfit != null && expensesSection != null) {
+            calculatedSections['earningsBeforeInterestAndTax'] =
+                computeCalculatedSection(grossProfit.classTotals, expensesSection.classTotals, grossProfit.sectionTotal, expensesSection.sectionTotal, 'subtract', SECTION_TITLES['earningsBeforeInterestAndTax']);
+        }
+        // Net Other Income = Other Income - Other Expenses
+        if (otherIncomeSection != null && otherExpensesSection != null) {
+            calculatedSections['netOtherIncome'] = computeCalculatedSection(otherIncomeSection.classTotals, otherExpensesSection.classTotals, otherIncomeSection.sectionTotal, otherExpensesSection.sectionTotal, 'subtract', SECTION_TITLES['netOtherIncome']);
+        }
+        // Net Income = EBIT + Net Other Income
+        const ebit = calculatedSections['earningsBeforeInterestAndTax'];
+        const netOtherIncome = calculatedSections['netOtherIncome'];
+        if (ebit != null && netOtherIncome != null) {
+            calculatedSections['netIncome'] = computeCalculatedSection(ebit.classTotals, netOtherIncome.classTotals, ebit.sectionTotal, netOtherIncome.sectionTotal, 'add', SECTION_TITLES['netIncome']);
+        }
+    }
+    // Build synthetic header COABalances for rendering class names as column headers
+    const headerBalances = buildHeaderBalances(classColumns, filter.timeframe, selectedPeriod, reportCurrency);
+    const report = {
+        reportId,
+        reportTitle: 'Profit and Loss by Class',
+        firstMonthOfFY: profitAndLossClassesViewState.firstMonthOfFY,
+        fetchState: fetchState.fetchState,
+        bookCloseDate: profitAndLossClassesViewState.bookCloseDate,
+        dataAvailable: profitAndLossClassesViewState.dataAvailable,
+        selectedPeriod,
+        classColumns,
+        sections,
+        calculatedSections,
+        idsInOrder: profitAndLossHorizontalIdsInOrder,
+        uiState: profitAndLossClassesViewState.uiState,
+        headerBalances,
+    };
+    enrichProfitAndLossByClassHorizontalReport(report);
+    return report;
+};
+/**
+ * Build column definitions from class hierarchy (top-level classes only).
+ */
+function buildClassColumns(classHierarchy, classesToFilterOut) {
+    const filteredIds = new Set(classesToFilterOut.map((id) => id[0]));
+    return classHierarchy
+        .filter((c) => !filteredIds.has(c.classId[0]))
+        .map((c) => ({
+        classId: c.classId[0],
+        className: c.className,
+        nestedClassId: c.classId,
+        qboId: c.qboId,
+    }))
+        .sort((a, b) => a.className.localeCompare(b.className, [], { sensitivity: 'base' }));
+}
+/**
+ * Pivot a section from class→account→balances to account→class→balance (single period).
+ */
+function pivotSectionToHorizontal(section, classColumns, title, currency) {
+    // Map: accountId -> { accountName, classId -> balance }
+    const accountMap = new Map();
+    // Also track class totals
+    const classTotalMap = new Map();
+    classColumns.forEach((col) => classTotalMap.set(col.classId, 0));
+    // Iterate over each class in the section
+    section.classes.forEach((classReport) => {
+        const classId = classReport.id[0];
+        // Only process classes that are in our columns
+        if (!classTotalMap.has(classId)) {
+            return;
+        }
+        // Sum all sliced period balances (same slice as vertical columns; multi-period = range total)
+        const classBalance = sumBalancesInSlice(classReport.childrenBalancesTotal.balances);
+        classTotalMap.set(classId, classBalance);
+        // Iterate through accounts in this class
+        collectAccountsFromClass(classReport, classId, accountMap);
+    });
+    // Build account rows in COA tree order (same parent/child ordering as vertical P&L by class).
+    // Sorting by depth + name flattened the hierarchy and broke sub-account grouping.
+    const orderedIds = collectAccountIdsInTreeOrder(section, classColumns);
+    const usedIds = new Set();
+    const accounts = [];
+    const pushAccountRow = (accountId) => {
+        const accountData = accountMap.get(accountId);
+        if (accountData == null) {
+            return;
+        }
+        usedIds.add(accountId);
+        const classBalances = classColumns.map((col) => ({
+            classId: col.classId,
+            balance: toAmountWC(accountData.classBalances.get(col.classId) ?? 0, currency),
+        }));
+        const rowTotal = classBalances.reduce((sum, cb) => sum + cb.balance.amount, 0);
+        accounts.push({
+            accountId,
+            accountName: accountData.accountName,
+            accountType: accountData.accountType,
+            depth: accountData.depth,
+            classBalances,
+            rowTotal: toAmountWC(rowTotal, currency),
+        });
+    };
+    for (const id of orderedIds) {
+        pushAccountRow(id);
+    }
+    for (const accountId of accountMap.keys()) {
+        if (!usedIds.has(accountId)) {
+            pushAccountRow(accountId);
+        }
+    }
+    // Build class totals
+    const classTotals = classColumns.map((col) => ({
+        classId: col.classId,
+        balance: toAmountWC(classTotalMap.get(col.classId) ?? 0, currency),
+    }));
+    const sectionTotal = classTotals.reduce((sum, ct) => sum + ct.balance.amount, 0);
+    return {
+        title,
+        accounts,
+        classTotals,
+        sectionTotal: toAmountWC(sectionTotal, currency),
+    };
+}
+/**
+ * DFS account ids in the same order as vertical P&L by class, using the first class
+ * column that appears in this section as the canonical tree (structure is identical per class).
+ */
+function collectAccountIdsInTreeOrder(section, classColumns) {
+    const ids = [];
+    const visitNested = (nested) => {
+        ids.push(nested.account.accountId);
+        nested.children.forEach(visitNested);
+    };
+    for (const col of classColumns) {
+        const classReport = section.classes.find((c) => c.id[0] === col.classId);
+        if (classReport == null) {
+            continue;
+        }
+        classReport.class.accounts.forEach(visitNested);
+        return ids;
+    }
+    return ids;
+}
+/**
+ * Recursively collect account balances from a NestedClassReportV2 into accountMap.
+ */
+function collectAccountsFromClass(classReport, classId, accountMap) {
+    // Process accounts directly on this class (depth 2 matches vertical `AccountsSection` first level)
+    classReport.class.accounts.forEach((nestedAccount) => {
+        collectAccountsFromNestedAccount(nestedAccount, classId, accountMap, 2);
+    });
+}
+/**
+ * Recursively collect accounts from NestedAccountReport (handles sub-accounts).
+ */
+function collectAccountsFromNestedAccount(nestedAccount, classId, accountMap, depth) {
+    const accountId = nestedAccount.account.accountId;
+    const accountName = nestedAccount.account.accountName;
+    const balance = sumBalancesInSlice(nestedAccount.account.balancesInTimeframe.balances);
+    if (!accountMap.has(accountId)) {
+        accountMap.set(accountId, {
+            accountName,
+            accountType: nestedAccount.account.accountType,
+            depth,
+            classBalances: new Map(),
+        });
+    }
+    const accountData = accountMap.get(accountId);
+    if (accountData == null) {
+        return;
+    }
+    accountData.depth = Math.max(accountData.depth, depth);
+    if (accountData.accountType == null &&
+        nestedAccount.account.accountType != null) {
+        accountData.accountType = nestedAccount.account.accountType;
+    }
+    const existing = accountData.classBalances.get(classId) ?? 0;
+    accountData.classBalances.set(classId, existing + balance);
+    // Process sub-accounts
+    nestedAccount.children.forEach((child) => {
+        collectAccountsFromNestedAccount(child, classId, accountMap, depth + 1);
+    });
+}
+/**
+ * Total `balance.amount` for the current COA slice (same aggregation as
+ * `getSummationFreeRangeTotalBalance`, used for class totals and account rows).
+ */
+function sumBalancesInSlice(balances) {
+    if (balances.length === 0) {
+        return 0;
+    }
+    const summed = getSummationFreeRangeTotalBalance([...balances]);
+    return summed?.balance.amount ?? 0;
+}
+/**
+ * Compute a calculated section by adding or subtracting two sets of class totals.
+ */
+function computeCalculatedSection(aTotals, bTotals, aTotal, bTotal, operation, title) {
+    const currency = {
+        currencyCode: aTotal.currencyCode,
+        currencySymbol: aTotal.currencySymbol,
+    };
+    const bTotalsMap = new Map(bTotals.map((b) => [b.classId, b.balance.amount]));
+    const classTotals = aTotals.map((a) => {
+        const bAmount = bTotalsMap.get(a.classId) ?? 0;
+        const resultAmount = operation === 'add'
+            ? a.balance.amount + bAmount
+            : a.balance.amount - bAmount;
+        return {
+            classId: a.classId,
+            balance: toAmountWC(resultAmount, currency),
+        };
+    });
+    const sectionTotalAmount = operation === 'add'
+        ? aTotal.amount + bTotal.amount
+        : aTotal.amount - bTotal.amount;
+    return {
+        title,
+        classTotals,
+        sectionTotal: toAmountWC(sectionTotalAmount, currency),
+    };
+}
+/**
+ * Build synthetic COABalance array for header rendering.
+ * One entry per class column + one for "Total".
+ */
+function buildHeaderBalances(classColumns, timeframe, selectedPeriod, currency) {
+    if (selectedPeriod == null) {
+        return [];
+    }
+    const { endDate, startDate } = selectedPeriod;
+    const balances = classColumns.map((col) => ({
+        balance: toAmountWC(0, currency),
+        balanceTimeFrame: timeframe,
+        endDate,
+        startDate,
+        type: 'default',
+        label: col.className,
+    }));
+    // Add a "Total" column
+    balances.push({
+        balance: toAmountWC(0, currency),
+        balanceTimeFrame: timeframe,
+        endDate,
+        startDate,
+        type: 'default',
+        label: 'Total',
+    });
+    return balances;
+}

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

@@ -0,0 +1,9 @@
+/** Synthetic COABalance `id` for the horizontal class report Total column (transaction routing). */
+export const HORIZONTAL_CLASS_TOTAL_BALANCE_ID = '__horizontal_total__';
+export function isHorizontalAccountReportData(data) {
+    return (typeof data === 'object' &&
+        data !== null &&
+        'depth' in data &&
+        typeof data.depth === 'number' &&
+        !('filter' in data));
+}

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

@@ -23,6 +23,7 @@ export const initialState = {
         nodeCollapseState: {},
         scrollPosition: undefined,
         accountViewMode: 'account_group',
+        classViewLayout: 'vertical',
         classesToFilterOut: [],
     },
     firstMonthOfFY: 1,
@@ -94,6 +95,9 @@ const profitAndLossClassesView = createSlice({
         updateAccountViewMode(draft, action) {
             draft.uiState.accountViewMode = action.payload.viewMode;
         },
+        updateClassViewLayout(draft, action) {
+            draft.uiState.classViewLayout = action.payload.classViewLayout;
+        },
         resetProfitAndLossClassesNodeCollapseState(draft) {
             draft.uiState.nodeCollapseState = {};
         },
@@ -102,10 +106,11 @@ const profitAndLossClassesView = createSlice({
         },
     },
 });
-export const { fetchProfitAndLossClassesView, fetchProfitAndLossForTimeframeClassesView, updateProfitAndLossForTimeframeClassesView, updateProfitAndLossForTimeframeClassesViewFailure, updateClassesToFilterOut, updateProfitAndLossClassesViewUIState, updateAccountViewMode, resetProfitAndLossClassesNodeCollapseState, clearProfitAndLossClassesView, } = profitAndLossClassesView.actions;
+export const { fetchProfitAndLossClassesView, fetchProfitAndLossForTimeframeClassesView, updateProfitAndLossForTimeframeClassesView, updateProfitAndLossForTimeframeClassesViewFailure, updateClassesToFilterOut, updateProfitAndLossClassesViewUIState, updateAccountViewMode, updateClassViewLayout, resetProfitAndLossClassesNodeCollapseState, clearProfitAndLossClassesView, } = profitAndLossClassesView.actions;
 export default profitAndLossClassesView.reducer;
 const doUpdatedProfitAndLossClassesView = (draft, timeframe, pandLReport) => {
     const report = mapReportPayloadV2ToReportV2(pandLReport.report);
+    draft.currency = report.currency;
     draft.dataAvailable = report.dataAvailable;
     draft.firstMonthOfFY = report.firstMonthOfFY;
     draft.bookCloseDate = report.bookCloseDate;

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

@@ -1,6 +1,7 @@
 import { getDifferenceOfBalancesGroupedByPeriod } from '../../commonStateTypes/coaBalance/classBalances/getDifferenceOfBalancesGroupedByPeriod';
 import { getSumOfBalancesByGroupedByPeriod } from '../../commonStateTypes/coaBalance/classBalances/getSumOfBalancesGroupedByPeriod';
 import { getCOABalances } from '../../commonStateTypes/coaBalance/coaBalance';
+import { reduceFetchStateParallelTimeframes } from '../../commonStateTypes/reduceFetchState';
 import { getSectionClassesViewReport } from '../../entity/sectionClassesViewV2/sectionClassesViewSelector';
 import { ALL_PANDL_REPORT_VIEW_SECTION_IDS, } from './profitAndLossClassesViewSelectorTypes';
 export const profitAndLossIdsInOrder = [
@@ -15,7 +16,7 @@ export const profitAndLossIdsInOrder = [
     'netIncome',
 ];
 export const getProfitAndLossClassesView = (filter, accountState, classState, sectionsState, profitAndLossClassesViewState) => {
-    const fetchState = reduceFetchState([
+    const fetchState = reduceFetchStateParallelTimeframes([
         profitAndLossClassesViewState.fetchState.month,
         profitAndLossClassesViewState.fetchState.quarter,
         profitAndLossClassesViewState.fetchState.year,
@@ -64,31 +65,3 @@ export const getProfitAndLossClassesView = (filter, accountState, classState, se
         idsInOrder: profitAndLossIdsInOrder,
     };
 };
-function reduceFetchState(fetchStateList) {
-    const isAnyProgress = fetchStateList.reduce((prevValue, currentValue) => {
-        return prevValue === true || currentValue.fetchState === 'In-Progress';
-    }, false);
-    const isAllCompleted = fetchStateList.reduce((prevValue, currentValue) => {
-        return prevValue === true && currentValue.fetchState === 'Completed';
-    }, true);
-    const isAnyError = fetchStateList.reduce((prevValue, currentValue) => {
-        return prevValue === true || currentValue.fetchState === 'Error';
-    }, false);
-    const error = fetchStateList.reduce((prevValue, currentValue) => {
-        return prevValue ?? currentValue.error;
-    }, undefined);
-    let fetchState = 'Not-Started';
-    if (isAnyProgress) {
-        fetchState = 'In-Progress';
-    }
-    else if (isAllCompleted) {
-        fetchState = 'Completed';
-    }
-    else if (isAnyError) {
-        fetchState = 'Error';
-    }
-    return {
-        fetchState,
-        error,
-    };
-}

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

@@ -24,11 +24,13 @@ export const fetchProfitAndLossForTimeframeClassesViewEpic = (actions$, _, zeniA
         .pipe(mergeMap((response) => {
         if (response.data != null && isSuccessResponse(response)) {
             const actions = [];
-            actions.push(updateSectionClassesView(action.payload.timeframe, 'cogs', 'profit_and_loss_by_classes', response.data.report.cogs, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
-            actions.push(updateSectionClassesView(action.payload.timeframe, 'expenses', 'profit_and_loss_by_classes', response.data.report.expenses, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
-            actions.push(updateSectionClassesView(action.payload.timeframe, 'income', 'profit_and_loss_by_classes', response.data.report.income, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
-            actions.push(updateSectionClassesView(action.payload.timeframe, 'otherExpenses', 'profit_and_loss_by_classes', response.data.report.other_expenses, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
-            actions.push(updateSectionClassesView(action.payload.timeframe, 'otherIncome', 'profit_and_loss_by_classes', response.data.report.other_income, response.data.report.classes, response.data.report.accounts, response.data.report.currency));
+            const report = response.data.report;
+            const currency = report.currency;
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'cogs', 'profit_and_loss_by_classes', report.cogs, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'expenses', 'profit_and_loss_by_classes', report.expenses, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'income', 'profit_and_loss_by_classes', report.income, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'otherExpenses', 'profit_and_loss_by_classes', report.other_expenses, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, 'otherIncome', 'profit_and_loss_by_classes', report.other_income, report.classes, report.accounts, currency));
             actions.push(updateProfitAndLossForTimeframeClassesView({
                 timeframe: action.payload.timeframe,
                 report: response.data,

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

@@ -0,0 +1,201 @@
+import { defaultCustomerCurrency } from '../../commonStateTypes/currencyHelper';
+import { HORIZONTAL_CLASS_TOTAL_BALANCE_ID, } from './profitAndLossClassesByClassHorizontalSelectorTypes';
+/**
+ * Populates `sectionHeaderBalancesSlice`, and per-account `accountReportData`, so the
+ * web layer only maps selector output to tree nodes.
+ */
+export function enrichProfitAndLossByClassHorizontalReport(report) {
+    if (report.fetchState !== 'Completed' || report.selectedPeriod == null) {
+        return;
+    }
+    for (const section of Object.values(report.sections)) {
+        if (section != null) {
+            enrichHorizontalSection(report, section);
+        }
+    }
+    for (const calc of Object.values(report.calculatedSections)) {
+        if (calc != null) {
+            enrichHorizontalCalculatedSection(report, calc);
+        }
+    }
+}
+function enrichHorizontalSection(report, section) {
+    const classAmounts = report.classColumns.map((col) => {
+        const total = section.classTotals.find((ct) => ct.classId === col.classId);
+        return total?.balance.amount ?? 0;
+    });
+    section.sectionHeaderBalancesSlice = buildHorizontalClassColumnBalancesSlice(report, classAmounts, section.sectionTotal.amount);
+    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(section.accounts);
+    const childrenRecord = {};
+    childrenRowIndicesByParent.forEach((childIndices, parentIndex) => {
+        childrenRecord[parentIndex] = childIndices;
+    });
+    section.treeLayout = {
+        rootAccountRowIndices: section.accounts
+            .map((_, i) => findHorizontalAccountParentIndex(section.accounts, 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;
+        });
+        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),
+        };
+    }
+}
+function enrichHorizontalCalculatedSection(report, calcSection) {
+    const classAmounts = report.classColumns.map((col) => {
+        const total = calcSection.classTotals.find((ct) => ct.classId === col.classId);
+        return total?.balance.amount ?? 0;
+    });
+    calcSection.sectionHeaderBalancesSlice =
+        buildHorizontalClassColumnBalancesSlice(report, classAmounts, calcSection.sectionTotal.amount);
+}
+function buildHorizontalClassColumnBalancesSlice(report, classAmounts, totalAmount) {
+    const fallback = defaultCustomerCurrency;
+    const firstHeader = report.headerBalances[0];
+    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: [],
+        },
+    };
+    if (report.selectedPeriod == null) {
+        return emptySlice;
+    }
+    const { startDate, endDate } = report.selectedPeriod;
+    const balances = report.classColumns.map((col, i) => ({
+        balance: {
+            amount: classAmounts[i] ?? 0,
+            currencyCode,
+            currencySymbol,
+        },
+        balanceTimeFrame: timeframe,
+        startDate,
+        endDate,
+        type: 'default',
+        id: col.classId,
+        label: col.className,
+    }));
+    balances.push({
+        balance: {
+            amount: totalAmount,
+            currencyCode,
+            currencySymbol,
+        },
+        balanceTimeFrame: timeframe,
+        startDate,
+        endDate,
+        type: 'default',
+        id: HORIZONTAL_CLASS_TOTAL_BALANCE_ID,
+        label: 'Total',
+    });
+    return {
+        balances,
+        additionalBalances: [],
+        filter: {
+            firstMonthOfFY: report.firstMonthOfFY,
+            timeframe,
+            balancesRange: {
+                numberOfPeriods: balances.length,
+                orderBy: 'ascending_date',
+            },
+            additionalBalances: [],
+        },
+    };
+}
+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;
+            }
+            return -1;
+        }
+    }
+    return -1;
+}
+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);
+        }
+    }
+    return siblings;
+}
+function horizontalAccountHasChildRows(dfsOrderedAccountRows, parentRowIndex) {
+    return dfsOrderedAccountRows.some((_, rowIndex) => findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex) ===
+        parentRowIndex);
+}
+function buildHorizontalSubAccountAncestorMetadata(dfsOrderedAccountRows, currentRowIndex) {
+    const ancestorRowIndicesRootToLeaf = [];
+    let walkRowIndex = currentRowIndex;
+    while (walkRowIndex >= 0) {
+        ancestorRowIndicesRootToLeaf.unshift(walkRowIndex);
+        walkRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, walkRowIndex);
+    }
+    return ancestorRowIndicesRootToLeaf.map((rowIndex) => {
+        const siblingIndices = getHorizontalAccountSiblingIndices(dfsOrderedAccountRows, rowIndex);
+        return {
+            depth: dfsOrderedAccountRows[rowIndex].depth - 2,
+            hasSibling: siblingIndices.length > 1,
+            hasChildren: horizontalAccountHasChildRows(dfsOrderedAccountRows, rowIndex),
+            isLastNode: rowIndex === siblingIndices[siblingIndices.length - 1],
+            name: dfsOrderedAccountRows[rowIndex].accountName,
+        };
+    });
+}
+function buildHorizontalAccountChildIndicesByParent(dfsOrderedAccountRows) {
+    const childIndicesByParentRowIndex = new Map();
+    for (let rowIndex = 0; rowIndex < dfsOrderedAccountRows.length; rowIndex++) {
+        const parentRowIndex = findHorizontalAccountParentIndex(dfsOrderedAccountRows, rowIndex);
+        if (parentRowIndex >= 0) {
+            let childRowIndices = childIndicesByParentRowIndex.get(parentRowIndex);
+            if (childRowIndices === undefined) {
+                childRowIndices = [];
+                childIndicesByParentRowIndex.set(parentRowIndex, childRowIndices);
+            }
+            childRowIndices.push(rowIndex);
+        }
+    }
+    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/lib/esm/view/reportUIOptions/updateReportUIOptionCOABalancesRangeEpic.js

@@ -2,15 +2,19 @@ import { of } from 'rxjs';
 import { filter, switchMap } from 'rxjs/operators';
 import { updateCashInCashOutCOABalancesRange } from '../cashInCashOut/cashInCashOutReducer';
 import { updateCashPositionCOABalancesRange } from '../cashPosition/cashPositionReducer';
-import { initialFinanceStatementState, updateCOABalancesRange, } from '../financeStatement/financeStatementReducer';
+import { updateCOABalancesRange } from '../financeStatement/financeStatementReducer';
 import { updateNetBurnOrIncomeCOABalancesRange } from '../netBurnOrIncome/netBurnOrIncomeReducer';
 import { updateOpExCOABalancesRange } from '../opEx/opExReducer';
 import { updateRevenueCOABalancesRange } from '../revenue/revenueReducer';
 import { updateReportUIOptionCOABalancesRange } from './reportUIOptionsReducer';
 export const updateReportUIOptionCOABalancesRangeEpic = (actions$, state$) => actions$.pipe(filter(updateReportUIOptionCOABalancesRange.match), switchMap((action) => {
-    const thisPeriod = action.payload.selectedCOABalancesRange.thisPeriod;
-    const orderBy = action.payload.selectedCOABalancesRange.orderBy;
-    const highlightedNoOfPeriods = state$.value.reportUIOptionsState.isCompareModeOn === true ? 4 : 1;
+    const selectedRange = action.payload.selectedCOABalancesRange;
+    const thisPeriod = selectedRange.thisPeriod;
+    const orderBy = selectedRange.orderBy;
+    const numberOfPeriodsFromSelection = selectedRange.numberOfPeriods;
+    const highlightedNoOfPeriods = state$.value.reportUIOptionsState.isCompareModeOn === true
+        ? numberOfPeriodsFromSelection
+        : 1;
     const highlightedCOABalancesRange = action.payload.highlightedCOABalancesRange == null && thisPeriod != null
         ? {
             numberOfPeriods: highlightedNoOfPeriods,
@@ -62,9 +66,7 @@ export const updateReportUIOptionCOABalancesRangeEpic = (actions$, state$) => ac
         thisPeriod: action.payload.highlightedCOABalancesRange != null
             ? action.payload.highlightedCOABalancesRange.thisPeriod
             : thisPeriod,
-        numberOfPeriods: state$.value.reportUIOptionsState.isCompareModeOn === true
-            ? 4
-            : initialFinanceStatementState.maxNumOfPeriodsToHighlight,
+        numberOfPeriods: numberOfPeriodsFromSelection,
         orderBy,
     }));
 }));