@zeniai/client-epic-state 4.20.3 → 4.20.5

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

@@ -1,331 +0,0 @@
-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';
-/** Standard class ID returned by the accounting platform for transactions without an assigned class. */
-export const NOT_SPECIFIED_CLASS_ID = 'not_specified';
-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) {
-        reportCurrency =
-            profitAndLossClassesViewState.currency ?? defaultCustomerCurrency;
-        // Fetch each section and pivot class→account to account→class in one pass
-        HORIZONTAL_PANDL_SECTION_IDS.forEach((sectionId) => {
-            const sectionReport = getSectionClassesViewReport(accountState, classState, sectionsState, { reportId, sectionId }, filter);
-            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) => {
-        const aIsNotSpecified = a.classId === NOT_SPECIFIED_CLASS_ID;
-        const bIsNotSpecified = b.classId === NOT_SPECIFIED_CLASS_ID;
-        if (aIsNotSpecified && !bIsNotSpecified) {
-            return 1;
-        }
-        if (!aIsNotSpecified && bIsNotSpecified) {
-            return -1;
-        }
-        return 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

@@ -1,9 +0,0 @@
-/** 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/profitAndLossHorizontalEnrichment.js

@@ -1,262 +0,0 @@
-import { defaultCustomerCurrency } from '../../commonStateTypes/currencyHelper';
-import { getEmptyHorizontalSectionBalancesSlice } from './horizontalSectionEmptyBalancesSlice';
-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 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 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: buildHorizontalTreeViewFromPrecomputed(section.accounts, accountIndex, 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 = 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';
-    if (report.selectedPeriod == null) {
-        return getEmptyHorizontalSectionBalancesSlice(report.firstMonthOfFY, timeframe);
-    }
-    const { startDate, endDate } = report.selectedPeriod;
-    const balances = report.classColumns.map((col, columnIndex) => {
-        const amount = classAmounts[columnIndex] ?? 0;
-        return {
-            balance: {
-                amount,
-                currencyCode,
-                currencySymbol,
-            },
-            balanceTimeFrame: timeframe,
-            startDate,
-            endDate,
-            type: amount === 0 ? 'default_with_null_balance' : 'default',
-            id: col.classId,
-            label: col.className,
-        };
-    });
-    balances.push({
-        balance: {
-            amount: totalAmount,
-            currencyCode,
-            currencySymbol,
-        },
-        balanceTimeFrame: timeframe,
-        startDate,
-        endDate,
-        type: totalAmount === 0 ? 'default_with_null_balance' : '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: [],
-        },
-    };
-}
-/**
- * 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;
-            }
-        }
-        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 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 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 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 < 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/esm/view/userGroupListView/userGroupListViewReducer.js

@@ -1,65 +0,0 @@
-import { createSlice } from '@reduxjs/toolkit';
-const initialUserGroupList = {
-    ids: [],
-    fetchState: 'Not-Started',
-    error: undefined,
-    hasValidState() {
-        return this.fetchState == 'Completed';
-    },
-};
-export const initialState = {
-    userGroupListByType: {
-        taskManagerCandidate: initialUserGroupList,
-    },
-};
-const userGroupListView = createSlice({
-    name: 'userGroupListView',
-    initialState,
-    reducers: {
-        fetchUserGroupListByType: {
-            reducer(draft, action) {
-                const { userGroupType } = action.payload;
-                draft.userGroupListByType[userGroupType].fetchState = 'In-Progress';
-                draft.userGroupListByType[userGroupType].error = undefined;
-            },
-            prepare(userGroupType, cacheOverride = false) {
-                return {
-                    payload: {
-                        userGroupType,
-                        cacheOverride,
-                    },
-                };
-            },
-        },
-        updateUserGroupIds(draft, action) {
-            const { userGroupType, userGroupsPayload } = action.payload;
-            draft.userGroupListByType[userGroupType].fetchState = 'Completed';
-            draft.userGroupListByType[userGroupType].error = undefined;
-            draft.userGroupListByType[userGroupType].ids = userGroupsPayload.map((userGroup) => userGroup.id);
-        },
-        addUserGroupId(draft, action) {
-            const { userGroupType, id } = action.payload;
-            const index = draft.userGroupListByType[userGroupType].ids.indexOf(id);
-            if (index < 0) {
-                draft.userGroupListByType[userGroupType].ids.push(id);
-            }
-        },
-        removeUserGroupId(draft, action) {
-            const { userGroupType, id } = action.payload;
-            const index = draft.userGroupListByType[userGroupType].ids.indexOf(id);
-            if (index > -1) {
-                draft.userGroupListByType[userGroupType].ids.splice(index, 1);
-            }
-        },
-        updateUserGroupListFetchFailure(draft, action) {
-            const { userGroupType, status } = action.payload;
-            draft.userGroupListByType[userGroupType].fetchState = 'Error';
-            draft.userGroupListByType[userGroupType].error = status;
-        },
-        clearUserGroupListView(draft) {
-            Object.assign(draft, initialState);
-        },
-    },
-});
-export const { fetchUserGroupListByType, updateUserGroupIds, addUserGroupId, removeUserGroupId, updateUserGroupListFetchFailure, clearUserGroupListView, } = userGroupListView.actions;
-export default userGroupListView.reducer;

package/lib/esm/view/userGroupListView/userGroupListViewSelector.js

@@ -1,16 +0,0 @@
-import { getUserGroupByUserGroupId } from '../../entity/userGroups/userGroupsSelector';
-export const getUserGroupList = (userGroupsState, userGroupListViewState, userGroupType) => {
-    const listState = userGroupListViewState.userGroupListByType[userGroupType];
-    return {
-        userGroups: getUserGroupListByIds(userGroupsState, userGroupListViewState, userGroupType),
-        fetchState: listState?.fetchState,
-        error: listState?.error,
-        version: 0,
-    };
-};
-function getUserGroupListByIds(userGroupsState, userGroupListViewState, type) {
-    const userGroupIds = userGroupListViewState.userGroupListByType[type].ids;
-    return userGroupIds
-        .map((id) => getUserGroupByUserGroupId(userGroupsState, id))
-        .filter((value) => value != null);
-}

package/lib/esm/view/userGroupListView/userGroupListViewState.js

@@ -1 +0,0 @@
-export {};