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

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

@@ -2,7 +2,7 @@ import { NestedClassID } from '../../commonStateTypes/classesView/nestedClassID'
 import { AccountViewMode, ID } from '../../commonStateTypes/common';
 import { ZeniAPIStatus, ZeniReportData } from '../../responsePayload';
 import { ProfitAndLossClassesViewPayload } from './profitAndLossClassesViewPayload';
-import { ProfitAndLossClassesViewState } from './profitAndLossClassesViewState';
+import { ClassViewLayout, ProfitAndLossClassesViewState } from './profitAndLossClassesViewState';
 export declare const initialState: ProfitAndLossClassesViewState;
 export declare const fetchProfitAndLossClassesView: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[cacheOverride?: boolean | undefined], {
     cacheOverride: boolean;
@@ -30,6 +30,8 @@ export declare const fetchProfitAndLossClassesView: import("@reduxjs/toolkit").A
     };
 }, "profitAndLossClassesView/updateProfitAndLossClassesViewUIState">, updateAccountViewMode: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     viewMode: AccountViewMode;
-}, "profitAndLossClassesView/updateAccountViewMode">, resetProfitAndLossClassesNodeCollapseState: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"profitAndLossClassesView/resetProfitAndLossClassesNodeCollapseState">, clearProfitAndLossClassesView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"profitAndLossClassesView/clearProfitAndLossClassesView">;
+}, "profitAndLossClassesView/updateAccountViewMode">, updateClassViewLayout: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    classViewLayout: ClassViewLayout;
+}, "profitAndLossClassesView/updateClassViewLayout">, resetProfitAndLossClassesNodeCollapseState: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"profitAndLossClassesView/resetProfitAndLossClassesNodeCollapseState">, clearProfitAndLossClassesView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"profitAndLossClassesView/clearProfitAndLossClassesView">;
 declare const _default: import("redux").Reducer<ProfitAndLossClassesViewState>;
 export default _default;

package/lib/view/profitAndLossClassesView/profitAndLossClassesViewReducer.js

@@ -1,7 +1,7 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearProfitAndLossClassesView = exports.resetProfitAndLossClassesNodeCollapseState = exports.updateAccountViewMode = exports.updateProfitAndLossClassesViewUIState = exports.updateClassesToFilterOut = exports.updateProfitAndLossForTimeframeClassesViewFailure = exports.updateProfitAndLossForTimeframeClassesView = exports.fetchProfitAndLossForTimeframeClassesView = exports.fetchProfitAndLossClassesView = exports.initialState = void 0;
+exports.clearProfitAndLossClassesView = exports.resetProfitAndLossClassesNodeCollapseState = exports.updateClassViewLayout = exports.updateAccountViewMode = exports.updateProfitAndLossClassesViewUIState = exports.updateClassesToFilterOut = exports.updateProfitAndLossForTimeframeClassesViewFailure = exports.updateProfitAndLossForTimeframeClassesView = exports.fetchProfitAndLossForTimeframeClassesView = exports.fetchProfitAndLossClassesView = exports.initialState = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
 const viewAndReportPayloadv2_1 = require("../../commonPayloadTypes/v2/viewAndReportPayloadv2");
 const getNestedClassIDHierarchyForReport_1 = require("../../commonStateTypes/classesView/getNestedClassIDHierarchyForReport");
@@ -27,6 +27,7 @@ exports.initialState = {
         nodeCollapseState: {},
         scrollPosition: undefined,
         accountViewMode: 'account_group',
+        classViewLayout: 'vertical',
         classesToFilterOut: [],
     },
     firstMonthOfFY: 1,
@@ -98,6 +99,9 @@ const profitAndLossClassesView = (0, toolkit_1.createSlice)({
         updateAccountViewMode(draft, action) {
             draft.uiState.accountViewMode = action.payload.viewMode;
         },
+        updateClassViewLayout(draft, action) {
+            draft.uiState.classViewLayout = action.payload.classViewLayout;
+        },
         resetProfitAndLossClassesNodeCollapseState(draft) {
             draft.uiState.nodeCollapseState = {};
         },
@@ -106,10 +110,11 @@ const profitAndLossClassesView = (0, toolkit_1.createSlice)({
         },
     },
 });
-_a = profitAndLossClassesView.actions, exports.fetchProfitAndLossClassesView = _a.fetchProfitAndLossClassesView, exports.fetchProfitAndLossForTimeframeClassesView = _a.fetchProfitAndLossForTimeframeClassesView, exports.updateProfitAndLossForTimeframeClassesView = _a.updateProfitAndLossForTimeframeClassesView, exports.updateProfitAndLossForTimeframeClassesViewFailure = _a.updateProfitAndLossForTimeframeClassesViewFailure, exports.updateClassesToFilterOut = _a.updateClassesToFilterOut, exports.updateProfitAndLossClassesViewUIState = _a.updateProfitAndLossClassesViewUIState, exports.updateAccountViewMode = _a.updateAccountViewMode, exports.resetProfitAndLossClassesNodeCollapseState = _a.resetProfitAndLossClassesNodeCollapseState, exports.clearProfitAndLossClassesView = _a.clearProfitAndLossClassesView;
+_a = profitAndLossClassesView.actions, exports.fetchProfitAndLossClassesView = _a.fetchProfitAndLossClassesView, exports.fetchProfitAndLossForTimeframeClassesView = _a.fetchProfitAndLossForTimeframeClassesView, exports.updateProfitAndLossForTimeframeClassesView = _a.updateProfitAndLossForTimeframeClassesView, exports.updateProfitAndLossForTimeframeClassesViewFailure = _a.updateProfitAndLossForTimeframeClassesViewFailure, exports.updateClassesToFilterOut = _a.updateClassesToFilterOut, exports.updateProfitAndLossClassesViewUIState = _a.updateProfitAndLossClassesViewUIState, exports.updateAccountViewMode = _a.updateAccountViewMode, exports.updateClassViewLayout = _a.updateClassViewLayout, exports.resetProfitAndLossClassesNodeCollapseState = _a.resetProfitAndLossClassesNodeCollapseState, exports.clearProfitAndLossClassesView = _a.clearProfitAndLossClassesView;
 exports.default = profitAndLossClassesView.reducer;
 const doUpdatedProfitAndLossClassesView = (draft, timeframe, pandLReport) => {
     const report = (0, viewAndReportPayloadv2_1.mapReportPayloadV2ToReportV2)(pandLReport.report);
+    draft.currency = report.currency;
     draft.dataAvailable = report.dataAvailable;
     draft.firstMonthOfFY = report.firstMonthOfFY;
     draft.bookCloseDate = report.bookCloseDate;

package/lib/view/profitAndLossClassesView/profitAndLossClassesViewSelector.js

@@ -4,6 +4,7 @@ exports.getProfitAndLossClassesView = exports.profitAndLossIdsInOrder = void 0;
 const getDifferenceOfBalancesGroupedByPeriod_1 = require("../../commonStateTypes/coaBalance/classBalances/getDifferenceOfBalancesGroupedByPeriod");
 const getSumOfBalancesGroupedByPeriod_1 = require("../../commonStateTypes/coaBalance/classBalances/getSumOfBalancesGroupedByPeriod");
 const coaBalance_1 = require("../../commonStateTypes/coaBalance/coaBalance");
+const reduceFetchState_1 = require("../../commonStateTypes/reduceFetchState");
 const sectionClassesViewSelector_1 = require("../../entity/sectionClassesViewV2/sectionClassesViewSelector");
 const profitAndLossClassesViewSelectorTypes_1 = require("./profitAndLossClassesViewSelectorTypes");
 exports.profitAndLossIdsInOrder = [
@@ -18,7 +19,7 @@ exports.profitAndLossIdsInOrder = [
     'netIncome',
 ];
 const getProfitAndLossClassesView = (filter, accountState, classState, sectionsState, profitAndLossClassesViewState) => {
-    const fetchState = reduceFetchState([
+    const fetchState = (0, reduceFetchState_1.reduceFetchStateParallelTimeframes)([
         profitAndLossClassesViewState.fetchState.month,
         profitAndLossClassesViewState.fetchState.quarter,
         profitAndLossClassesViewState.fetchState.year,
@@ -68,31 +69,3 @@ const getProfitAndLossClassesView = (filter, accountState, classState, sectionsS
     };
 };
 exports.getProfitAndLossClassesView = getProfitAndLossClassesView;
-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/view/profitAndLossClassesView/profitAndLossClassesViewState.d.ts

@@ -1,9 +1,12 @@
+import { Currency } from '../../commonStateTypes/amount';
 import { NestedClassHierarchyForReport, NestedClassID } from '../../commonStateTypes/classesView/nestedClassID';
 import { AccountViewMode, FetchStateAndError, ID } from '../../commonStateTypes/common';
 import { Report } from '../../commonStateTypes/viewAndReport/viewAndReport';
+export type ClassViewLayout = 'vertical' | 'horizontal';
 export interface ProfitAndLossClassesViewUIState {
     accountViewMode: AccountViewMode;
     classesToFilterOut: NestedClassID[];
+    classViewLayout: ClassViewLayout;
     nodeCollapseState: Record<ID, boolean>;
     scrollPosition: {
         scrollTop: number;
@@ -18,4 +21,5 @@ export interface ProfitAndLossClassesViewState extends Report {
         year: FetchStateAndError;
     };
     uiState: ProfitAndLossClassesViewUIState;
+    currency?: Currency;
 }

package/lib/view/profitAndLossClassesView/profitAndLossForTimeframeClassesViewEpic.js

@@ -27,11 +27,13 @@ const fetchProfitAndLossForTimeframeClassesViewEpic = (actions$, _, zeniAPI) =>
         .pipe((0, operators_1.mergeMap)((response) => {
         if (response.data != null && (0, responsePayload_1.isSuccessResponse)(response)) {
             const actions = [];
-            actions.push((0, sectionClassesViewReducer_1.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((0, sectionClassesViewReducer_1.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((0, sectionClassesViewReducer_1.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((0, sectionClassesViewReducer_1.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((0, sectionClassesViewReducer_1.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((0, sectionClassesViewReducer_1.updateSectionClassesView)(action.payload.timeframe, 'cogs', 'profit_and_loss_by_classes', report.cogs, report.classes, report.accounts, currency));
+            actions.push((0, sectionClassesViewReducer_1.updateSectionClassesView)(action.payload.timeframe, 'expenses', 'profit_and_loss_by_classes', report.expenses, report.classes, report.accounts, currency));
+            actions.push((0, sectionClassesViewReducer_1.updateSectionClassesView)(action.payload.timeframe, 'income', 'profit_and_loss_by_classes', report.income, report.classes, report.accounts, currency));
+            actions.push((0, sectionClassesViewReducer_1.updateSectionClassesView)(action.payload.timeframe, 'otherExpenses', 'profit_and_loss_by_classes', report.other_expenses, report.classes, report.accounts, currency));
+            actions.push((0, sectionClassesViewReducer_1.updateSectionClassesView)(action.payload.timeframe, 'otherIncome', 'profit_and_loss_by_classes', report.other_income, report.classes, report.accounts, currency));
             actions.push((0, profitAndLossClassesViewReducer_1.updateProfitAndLossForTimeframeClassesView)({
                 timeframe: action.payload.timeframe,
                 report: response.data,

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

@@ -0,0 +1,6 @@
+import { ProfitAndLossByClassHorizontalReport } from './profitAndLossClassesByClassHorizontalSelectorTypes';
+/**
+ * Populates `sectionHeaderBalancesSlice`, and per-account `accountReportData`, so the
+ * web layer only maps selector output to tree nodes.
+ */
+export declare function enrichProfitAndLossByClassHorizontalReport(report: ProfitAndLossByClassHorizontalReport): void;

package/lib/view/profitAndLossClassesView/profitAndLossHorizontalEnrichment.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichProfitAndLossByClassHorizontalReport = enrichProfitAndLossByClassHorizontalReport;
+const currencyHelper_1 = require("../../commonStateTypes/currencyHelper");
+const profitAndLossClassesByClassHorizontalSelectorTypes_1 = require("./profitAndLossClassesByClassHorizontalSelectorTypes");
+/**
+ * Populates `sectionHeaderBalancesSlice`, and per-account `accountReportData`, so the
+ * web layer only maps selector output to tree nodes.
+ */
+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 parentIndices = computeHorizontalAccountParentIndices(section.accounts);
+    const childrenRowIndicesByParent = buildHorizontalAccountChildIndicesByParent(parentIndices);
+    const childrenRecord = {};
+    childrenRowIndicesByParent.forEach((childIndices, parentIndex) => {
+        childrenRecord[parentIndex] = childIndices;
+    });
+    section.treeLayout = {
+        rootAccountRowIndices: section.accounts
+            .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];
+        // 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: buildHorizontalTreeViewFromPrecomputed(section.accounts, i, parentIndices, siblingsPerRow, hasChildFlags),
+        };
+    }
+}
+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 = currencyHelper_1.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: profitAndLossClassesByClassHorizontalSelectorTypes_1.HORIZONTAL_CLASS_TOTAL_BALANCE_ID,
+        label: 'Total',
+    });
+    return {
+        balances,
+        additionalBalances: [],
+        filter: {
+            firstMonthOfFY: report.firstMonthOfFY,
+            timeframe,
+            balancesRange: {
+                numberOfPeriods: balances.length,
+                orderBy: 'ascending_date',
+            },
+            additionalBalances: [],
+        },
+    };
+}
+/**
+ * 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;
+            }
+            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 parentIndex;
+}
+/** 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);
+    }
+    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 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 buildHorizontalSubAccountAncestorMetadataFromPrecomputed(dfsOrderedAccountRows, currentRowIndex, parentIndices, siblingsPerRow, hasChildFlags) {
+    const chain = [];
+    let walkRowIndex = currentRowIndex;
+    while (walkRowIndex >= 0) {
+        chain.unshift(walkRowIndex);
+        const parentRowIndex = parentIndices[walkRowIndex];
+        if (parentRowIndex == null) {
+            break;
+        }
+        walkRowIndex = parentRowIndex;
+    }
+    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: accountRow.depth - 2,
+            hasSibling: siblingIndices.length > 1,
+            hasChildren: hasChild === true,
+            isLastNode: rowIndex === siblingIndices[siblingIndices.length - 1],
+            name: accountRow.accountName,
+        };
+    });
+}
+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 < parentIndices.length; rowIndex++) {
+        const parentRowIndex = parentIndices[rowIndex];
+        if (parentRowIndex != null && parentRowIndex >= 0) {
+            let childRowIndices = childIndicesByParentRowIndex.get(parentRowIndex);
+            if (childRowIndices == null) {
+                childRowIndices = [];
+                childIndicesByParentRowIndex.set(parentRowIndex, childRowIndices);
+            }
+            childRowIndices.push(rowIndex);
+        }
+    }
+    return childIndicesByParentRowIndex;
+}

package/lib/view/reportUIOptions/updateReportUIOptionCOABalancesRangeEpic.js

@@ -11,9 +11,13 @@ const opExReducer_1 = require("../opEx/opExReducer");
 const revenueReducer_1 = require("../revenue/revenueReducer");
 const reportUIOptionsReducer_1 = require("./reportUIOptionsReducer");
 const updateReportUIOptionCOABalancesRangeEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(reportUIOptionsReducer_1.updateReportUIOptionCOABalancesRange.match), (0, operators_1.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,
@@ -65,9 +69,7 @@ const updateReportUIOptionCOABalancesRangeEpic = (actions$, state$) => actions$.
         thisPeriod: action.payload.highlightedCOABalancesRange != null
             ? action.payload.highlightedCOABalancesRange.thisPeriod
             : thisPeriod,
-        numberOfPeriods: state$.value.reportUIOptionsState.isCompareModeOn === true
-            ? 4
-            : financeStatementReducer_1.initialFinanceStatementState.maxNumOfPeriodsToHighlight,
+        numberOfPeriods: numberOfPeriodsFromSelection,
         orderBy,
     }));
 }));

package/lib/view/taskManager/taskDetailView/taskDetailSelector.js

@@ -116,7 +116,7 @@ exports.allTaskPriority = [
     },
     {
         code: 'medium',
-        name: 'Normal',
+        name: 'Medium',
     },
     {
         code: 'low',

package/lib/view/taskManager/taskListView/epics/bulkUpdateTaskListEpic.d.ts

@@ -16,6 +16,7 @@ interface UpdateTaskPayload {
     description: string;
     due_date: string | null;
     file_ids: ID[];
+    group_assignees: string[];
     name: string;
     priority: string;
     recurring_end_date: string | null;

package/lib/view/taskManager/taskListView/epics/bulkUpdateTaskListEpic.js

@@ -79,6 +79,7 @@ const toTaskPayload = (state, task) => {
         name: task.name,
         assignees: task.assignees,
         description: task.description,
+        group_assignees: task.groupAssignees,
         due_date: task.dueDate != null ? task.dueDate.format(formatZeniDateFY_1.DEFAULT_DATE_FORMAT) : null,
         priority: task.priority.code,
         status: task.status.code,

package/lib/view/taskManager/taskListView/taskListSelector.d.ts

@@ -8,6 +8,7 @@ import { UserState } from '../../../entity/user/userState';
 import { UserRoleState } from '../../../entity/userRole/userRoleState';
 import { RootState } from '../../../reducer';
 import { UserAndRole } from '../../companyView/types/userAndRole';
+import { UserGroupListSelectorView } from '../../userGroupListView/userGroupListViewSelector';
 import { UserListSelectorView } from '../../userListView/userListViewSelector';
 import { TaskListFilters, TaskListLocalData, TaskListState, TaskListUIState } from './taskList';
 export interface TaskWithUserDetails extends Task {
@@ -30,6 +31,7 @@ export interface TaskListSelectorView extends SelectorView {
     taskGroupUpdateStatus: FetchStateAndError;
     uiState: TaskListUIState;
     updateTasksFetchState: FetchStateAndError;
+    userGroupList: UserGroupListSelectorView;
     userList: UserListSelectorView;
 }
 export declare const getTaskListGroupedByAssignees: ({ taskListState, taskState, userState, userRoleState, addressState, tagState, }: {

package/lib/view/taskManager/taskListView/taskListSelector.js

@@ -17,6 +17,7 @@ const taskGroupTemplateSelector_1 = require("../../../entity/taskGroupTemplate/t
 const userSelector_1 = require("../../../entity/user/userSelector");
 const userAndRole_1 = require("../../companyView/types/userAndRole");
 const spendManagementFilterHelpers_1 = require("../../spendManagement/spendManagementFilterHelpers");
+const userGroupListViewSelector_1 = require("../../userGroupListView/userGroupListViewSelector");
 const userListViewSelector_1 = require("../../userListView/userListViewSelector");
 const taskDetailSelector_1 = require("../taskDetailView/taskDetailSelector");
 const taskList_1 = require("./taskList");
@@ -316,7 +317,7 @@ const getTaskGroupsWithTaskList = ({ taskListState, taskState, userState, userRo
         tagState,
     });
 };
-exports.getAllTasks = (0, toolkit_1.createSelector)((state) => state.taskListState, (state) => state.taskState, (state) => state.userState, (state) => state.userRoleState, (state) => state.userListViewState, (state) => state.addressState, (state) => state.taskGroupState, (state) => state.taskGroupViewState, (state) => state.tagViewState, (state) => state.tagState, (state) => state.taskGroupTemplateState, (state) => state.taskGroupTemplateViewState, (_state, isTaskTemplatesEnabled) => isTaskTemplatesEnabled, (taskListState, taskState, userState, userRoleState, userListViewState, addressState, taskGroupState, taskGroupViewState, tagViewState, tagState, taskGroupTemplateState, taskGroupTemplateViewState, isTaskTemplatesEnabled) => {
+exports.getAllTasks = (0, toolkit_1.createSelector)((state) => state.taskListState, (state) => state.taskState, (state) => state.userState, (state) => state.userRoleState, (state) => state.userListViewState, (state) => state.addressState, (state) => state.taskGroupState, (state) => state.taskGroupViewState, (state) => state.tagViewState, (state) => state.tagState, (state) => state.taskGroupTemplateState, (state) => state.taskGroupTemplateViewState, (state) => state.userGroupsState, (state) => state.userGroupListViewState, (_state, isTaskTemplatesEnabled) => isTaskTemplatesEnabled, (taskListState, taskState, userState, userRoleState, userListViewState, addressState, taskGroupState, taskGroupViewState, tagViewState, tagState, taskGroupTemplateState, taskGroupTemplateViewState, userGroupsState, userGroupListViewState, isTaskTemplatesEnabled) => {
     const { localData } = taskListState;
     const taskGroupsWithTasksList = getTaskGroupsWithTaskList({
         taskListState,
@@ -344,6 +345,7 @@ exports.getAllTasks = (0, toolkit_1.createSelector)((state) => state.taskListSta
         taskGroupTemplates,
         fetchState: fetchState,
         userList: (0, userListViewSelector_1.getUserList)(userState, userRoleState, userListViewState, 'taskManagerCandidate'),
+        userGroupList: (0, userGroupListViewSelector_1.getUserGroupList)(userGroupsState, userGroupListViewState, 'taskManagerCandidate'),
         error: error,
         version: 0,
         taskGroupsWithTasksList,

package/lib/view/twoFactorAuthentication/resendOtpEpic.d.ts

@@ -10,4 +10,4 @@ import { resendOtpCardHolder, sendOtpCardHolderFailure, sendOtpCardHolderSuccess
 import { resendOtpSpendManagementSetUp, sendOtpFailureSpendManagementSetUp, sendOtpSuccessSpendManagementSetUp } from '../spendManagement/commonSetup/setupViewReducer';
 import { resendOtp, sendOtpFailure, sendOtpSuccess } from './twoFactorAuthenticationReducer';
 export type ActionType = ReturnType<typeof resendOtp> | ReturnType<typeof sendOtpSuccess> | ReturnType<typeof sendOtpFailure> | ReturnType<typeof resendOtpSpendManagementSetUp> | ReturnType<typeof sendOtpSuccessSpendManagementSetUp> | ReturnType<typeof sendOtpFailureSpendManagementSetUp> | ReturnType<typeof resendOtpVendorView> | ReturnType<typeof sendOtpVendorViewSuccess> | ReturnType<typeof sendOtpVendorViewFailure> | ReturnType<typeof resendOnboardingOfficerOtp> | ReturnType<typeof sendOnboardingOfficerOtpSuccess> | ReturnType<typeof sendOnboardingOfficerOtpFailure> | ReturnType<typeof resendOtpCardUserOnboarding> | ReturnType<typeof sendOtpCardUserOnboardingSuccess> | ReturnType<typeof sendOtpCardUserOnboardingFailure> | ReturnType<typeof resendOtpMyProfile> | ReturnType<typeof resendOtpCardHolder> | ReturnType<typeof sendOtpCardHolderSuccess> | ReturnType<typeof sendOtpCardHolderFailure> | ReturnType<typeof sendOtpMyProfileFailure> | ReturnType<typeof sendOtpMyProfileSuccess>;
-export declare const resendOtpEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;
+export declare const resendOtpEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

package/lib/view/twoFactorAuthentication/resendOtpEpic.js

@@ -11,20 +11,11 @@ const cardUserOnboardingReducer_1 = require("../spendManagement/chargeCards/card
 const chargeCardDetailReducer_1 = require("../spendManagement/chargeCards/chargeCardDetail/chargeCardDetailReducer");
 const setupViewReducer_1 = require("../spendManagement/commonSetup/setupViewReducer");
 const twoFactorAuthenticationReducer_1 = require("./twoFactorAuthenticationReducer");
-const resendOtpEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(twoFactorAuthenticationReducer_1.resendOtp.match), (0, operators_1.mergeMap)((action) => {
+const resendOtpEpic = (actions$, _state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(twoFactorAuthenticationReducer_1.resendOtp.match), (0, operators_1.mergeMap)((action) => {
     const resendOtpActions = [];
     const { otpChallenge, twoFASource, entityId } = action.payload;
-    const chargeCard = twoFASource === 'ChargeCardHolder' && entityId != null
-        ? state$.value.chargeCardState.chargeCardByID[entityId]
-        : null;
     const payload = {
         otp_challenge: otpChallenge,
-        ...(chargeCard != null
-            ? {
-                provider_card_id: chargeCard.cardProviderID,
-                is_for_charge_cards: true,
-            }
-            : {}),
     };
     switch (twoFASource) {
         case 'SpendManagementSetup':
@@ -42,11 +33,6 @@ const resendOtpEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators
         case 'CardUserOnboarding':
             resendOtpActions.push((0, cardUserOnboardingReducer_1.resendOtpCardUserOnboarding)());
             break;
-        case 'ChargeCardHolder':
-            if (entityId != null) {
-                resendOtpActions.push((0, chargeCardDetailReducer_1.resendOtpCardHolder)({ chargeCardId: entityId }));
-            }
-            break;
     }
     const resendOtp$ = zeniAPI
         .putAndGetJSON(`${zeniAPI.apiEndPoints.authMicroServiceBaseUrl}/1.0/otp/resend`, payload)

package/lib/view/userGroupListView/userGroupListViewReducer.d.ts

@@ -0,0 +1,23 @@
+import { ID } from '../../commonStateTypes/common';
+import { UserGroupPayload } from '../../entity/userGroups/userGroupsPayload';
+import { ZeniAPIStatus } from '../../responsePayload';
+import { UserGroupListType, UserGroupListViewState } from './userGroupListViewState';
+export declare const initialState: UserGroupListViewState;
+export declare const fetchUserGroupListByType: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[userGroupType: "taskManagerCandidate", cacheOverride?: any], {
+    userGroupType: "taskManagerCandidate";
+    cacheOverride: any;
+}, "userGroupListView/fetchUserGroupListByType", never, never>, updateUserGroupIds: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    userGroupsPayload: UserGroupPayload[];
+    userGroupType: UserGroupListType;
+}, "userGroupListView/updateUserGroupIds">, addUserGroupId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    id: ID;
+    userGroupType: UserGroupListType;
+}, "userGroupListView/addUserGroupId">, removeUserGroupId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    id: ID;
+    userGroupType: UserGroupListType;
+}, "userGroupListView/removeUserGroupId">, updateUserGroupListFetchFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    status: ZeniAPIStatus;
+    userGroupType: UserGroupListType;
+}, "userGroupListView/updateUserGroupListFetchFailure">, clearUserGroupListView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"userGroupListView/clearUserGroupListView">;
+declare const _default: import("redux").Reducer<UserGroupListViewState>;
+export default _default;