@zeniai/client-epic-state 5.1.94 → 5.1.95

package/lib/esm/view/balanceSheetClassesView/balanceSheetClassesViewEpic.js

@@ -0,0 +1,30 @@
+import { from } from 'rxjs';
+import { filter, switchMap } from 'rxjs/operators';
+import { fetchBalanceSheetClassesView, fetchBalanceSheetForTimeframeClassesView, } from './balanceSheetClassesViewReducer';
+export const fetchBalanceSheetClassesViewEpic = (actions$, state) => actions$.pipe(filter(fetchBalanceSheetClassesView.match), switchMap((action) => {
+    const { cacheOverride } = action.payload;
+    if (cacheOverride === true) {
+        return from([
+            fetchBalanceSheetForTimeframeClassesView('month', true),
+            fetchBalanceSheetForTimeframeClassesView('quarter', true),
+            fetchBalanceSheetForTimeframeClassesView('year', true),
+        ]);
+    }
+    else {
+        const fetchActions = [];
+        const classFetchState = state.value.balanceSheetClassesViewState.fetchState;
+        if (classFetchState['month'].fetchState !== 'In-Progress' &&
+            classFetchState['month'].fetchState !== 'Completed') {
+            fetchActions.push(fetchBalanceSheetForTimeframeClassesView('month'));
+        }
+        if (classFetchState['quarter'].fetchState !== 'In-Progress' &&
+            classFetchState['quarter'].fetchState !== 'Completed') {
+            fetchActions.push(fetchBalanceSheetForTimeframeClassesView('quarter'));
+        }
+        if (classFetchState['year'].fetchState !== 'In-Progress' &&
+            classFetchState['year'].fetchState !== 'Completed') {
+            fetchActions.push(fetchBalanceSheetForTimeframeClassesView('year'));
+        }
+        return from(fetchActions);
+    }
+}));

package/lib/esm/view/balanceSheetClassesView/balanceSheetClassesViewPayload.js

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

package/lib/esm/view/balanceSheetClassesView/balanceSheetClassesViewReducer.js

@@ -0,0 +1,132 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { mapReportPayloadV2ToReportV2 } from '../../commonPayloadTypes/v2/viewAndReportPayloadv2';
+import { geNestedClassIDHierarchyForReport } from '../../commonStateTypes/classesView/getNestedClassIDHierarchyForReport';
+import { toClassMetadata } from '../../entity/class/classPayload';
+import { clearAll } from '../../rootActions';
+export const initialState = {
+    classHierarchy: [],
+    bookCloseDate: undefined,
+    fetchState: {
+        month: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        quarter: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        year: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    },
+    uiState: {
+        nodeCollapseState: {},
+        scrollPosition: undefined,
+        accountViewMode: 'account_group',
+        classesToFilterOut: [],
+    },
+    firstMonthOfFY: 1,
+    reportId: 'balance_sheet_by_classes',
+    reportTitle: 'balance_sheet_by_classes',
+};
+const balanceSheetClassesView = createSlice({
+    name: 'balanceSheetClassesView',
+    initialState,
+    reducers: {
+        fetchBalanceSheetClassesView: {
+            prepare(cacheOverride = false) {
+                return { payload: { cacheOverride } };
+            },
+            reducer(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                // nothing to do here
+            },
+        },
+        fetchBalanceSheetForTimeframeClassesView: {
+            prepare(timeframe, cacheOverride = false) {
+                return { payload: { timeframe, cacheOverride } };
+            },
+            reducer(draft, action) {
+                const timeframe = action.payload.timeframe;
+                draft.fetchState[timeframe].fetchState = 'In-Progress';
+                draft.fetchState[timeframe].error = undefined;
+            },
+        },
+        updateBalanceSheetForTimeframeClassesView(draft, action) {
+            doUpdateBalanceSheetClassesView(draft, action.payload.timeframe, action.payload.report);
+        },
+        updateBalanceSheetForTimeframeClassesViewFailure: {
+            prepare(error, timeframe) {
+                return {
+                    payload: {
+                        error,
+                        timeframe,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                draft.fetchState[action.payload.timeframe] = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+            },
+        },
+        updateBalanceSheetClassesToFilterOut(draft, action) {
+            draft.uiState.classesToFilterOut = action.payload.classesToFilterOut;
+        },
+        updateBalanceSheetClassesViewUIState(draft, action) {
+            const { nodeCollapseState, scrollPosition, resetLeftScroll } = action.payload;
+            if (nodeCollapseState != null) {
+                draft.uiState.nodeCollapseState = Object.assign({}, draft.uiState.nodeCollapseState, {
+                    [nodeCollapseState.nodeId]: nodeCollapseState.isCollapsed,
+                });
+            }
+            // Mutually exclusive: resetLeftScroll clears only scrollLeft from the
+            // recorded position, scrollPosition replaces the whole record.
+            if (resetLeftScroll === true && draft.uiState.scrollPosition != null) {
+                draft.uiState.scrollPosition.scrollLeft = undefined;
+            }
+            else if (scrollPosition != null) {
+                draft.uiState.scrollPosition = scrollPosition;
+            }
+        },
+        updateBalanceSheetClassesViewAccountViewMode(draft, action) {
+            draft.uiState.accountViewMode = action.payload.viewMode;
+        },
+        resetBalanceSheetClassesNodeCollapseState(draft) {
+            draft.uiState.nodeCollapseState = {};
+        },
+        clearBalanceSheetClassesView(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(clearAll, (draft) => {
+            Object.assign(draft, initialState);
+        });
+    },
+});
+export const { fetchBalanceSheetClassesView, fetchBalanceSheetForTimeframeClassesView, updateBalanceSheetForTimeframeClassesView, updateBalanceSheetForTimeframeClassesViewFailure, updateBalanceSheetClassesToFilterOut, updateBalanceSheetClassesViewUIState, updateBalanceSheetClassesViewAccountViewMode, resetBalanceSheetClassesNodeCollapseState, clearBalanceSheetClassesView, } = balanceSheetClassesView.actions;
+export default balanceSheetClassesView.reducer;
+const doUpdateBalanceSheetClassesView = (draft, timeframe, balanceSheetReport) => {
+    const report = mapReportPayloadV2ToReportV2(balanceSheetReport.report);
+    draft.currency = report.currency;
+    draft.dataAvailable = report.dataAvailable;
+    draft.firstMonthOfFY = report.firstMonthOfFY;
+    draft.bookCloseDate = report.bookCloseDate;
+    draft.status = report.status;
+    draft.fetchState[timeframe].fetchState = 'Completed';
+    draft.fetchState[timeframe].error = undefined;
+    const classMetadata = balanceSheetReport.report.classes.map((eachClass) => toClassMetadata(eachClass));
+    // Populated once and then left alone, so a per-timeframe response cannot
+    // clobber a hierarchy built from a full one. A class added mid-session is
+    // therefore not picked up until the store is cleared, even by a hard refresh —
+    // the same trade-off profitAndLossClassesViewReducer makes.
+    if (draft.classHierarchy.length <= 0) {
+        draft.classHierarchy = geNestedClassIDHierarchyForReport(classMetadata);
+    }
+};

package/lib/esm/view/balanceSheetClassesView/balanceSheetClassesViewSelector.js

@@ -0,0 +1,90 @@
+import { newAdditionalBalancesOptions } from '../../commonStateTypes/coaBalance/additionalBalances/getAdditionalBalances';
+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_BALANCE_SHEET_REPORT_VIEW_ASSET_IDS, ALL_BALANCE_SHEET_REPORT_VIEW_EQUITY_IDS, ALL_BALANCE_SHEET_REPORT_VIEW_LIABILITY_IDS, ALL_BALANCE_SHEET_REPORT_VIEW_SECTION_IDS, balanceSheetSectionIdsInOrder, } from '../balanceSheet/balanceSheetSelectorTypes';
+// The section-id constants and the display order are both module-level, so the
+// sorted groupings are computed once instead of on every selector call.
+const byDisplayOrder = (a, b) => balanceSheetSectionIdsInOrder.indexOf(a) -
+    balanceSheetSectionIdsInOrder.indexOf(b);
+const ASSET_IDS_IN_ORDER = [...ALL_BALANCE_SHEET_REPORT_VIEW_ASSET_IDS].sort(byDisplayOrder);
+const LIABILITY_IDS_IN_ORDER = [
+    ...ALL_BALANCE_SHEET_REPORT_VIEW_LIABILITY_IDS,
+].sort(byDisplayOrder);
+const EQUITY_IDS_IN_ORDER = [...ALL_BALANCE_SHEET_REPORT_VIEW_EQUITY_IDS].sort(byDisplayOrder);
+export const getBalanceSheetClassesView = (filter, accountState, classState, sectionsState, balanceSheetClassesViewState) => {
+    const fetchState = reduceFetchStateParallelTimeframes([
+        balanceSheetClassesViewState.fetchState.month,
+        balanceSheetClassesViewState.fetchState.quarter,
+        balanceSheetClassesViewState.fetchState.year,
+    ]);
+    const reportId = 'balance_sheet_by_classes';
+    const sections = {};
+    const calculatedSections = {};
+    if (fetchState.fetchState === 'Completed') {
+        // Balance Sheet balances are point-in-time, so the extra columns must be
+        // read as snapshots rather than period sums.
+        const additionalBalancesOptions = newAdditionalBalancesOptions(true);
+        ALL_BALANCE_SHEET_REPORT_VIEW_SECTION_IDS.forEach((sectionId) => {
+            sections[`${sectionId}`] = getSectionClassesViewReport(accountState, classState, sectionsState, {
+                reportId,
+                sectionId,
+            }, filter, additionalBalancesOptions);
+        });
+        const totalCurrentAssetsBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            sections['cashAndEquivalents'].sectionBalancesTotalByPeriod,
+            sections['accountsReceiable'].sectionBalancesTotalByPeriod,
+            sections['otherCurrentAssets'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['totalCurrentAssets'] = getCOABalances(totalCurrentAssetsBalancesByPeriod, filter, additionalBalancesOptions);
+        const totalAssetsBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            totalCurrentAssetsBalancesByPeriod ?? {},
+            sections['fixedAssets'].sectionBalancesTotalByPeriod,
+            sections['otherAssets'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['totalAssets'] = getCOABalances(totalAssetsBalancesByPeriod, filter, additionalBalancesOptions);
+        const totalCurrentLiabilitiesBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            sections['accountsPayable'].sectionBalancesTotalByPeriod,
+            sections['creditCards'].sectionBalancesTotalByPeriod,
+            sections['otherCurrentLiabilities'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['totalCurrentLiabilities'] = getCOABalances(totalCurrentLiabilitiesBalancesByPeriod, filter, additionalBalancesOptions);
+        calculatedSections['totalNonCurrentLiabilities'] = getCOABalances(sections['longTermLiabilities'].sectionBalancesTotalByPeriod, filter, additionalBalancesOptions);
+        const totalLiabilitiesBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            totalCurrentLiabilitiesBalancesByPeriod ?? {},
+            sections['longTermLiabilities'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['totalLiabilities'] = getCOABalances(totalLiabilitiesBalancesByPeriod, filter, additionalBalancesOptions);
+        calculatedSections['totalEquity'] = getCOABalances(sections['equity'].sectionBalancesTotalByPeriod, filter, additionalBalancesOptions);
+        const liabilitiesAndEquityBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            totalLiabilitiesBalancesByPeriod ?? {},
+            sections['equity'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['liabilitiesAndEquity'] = getCOABalances(liabilitiesAndEquityBalancesByPeriod, filter, additionalBalancesOptions);
+    }
+    const classHierarchy = balanceSheetClassesViewState.classHierarchy;
+    return {
+        sections,
+        calculatedSections,
+        reportId: balanceSheetClassesViewState.reportId,
+        reportTitle: balanceSheetClassesViewState.reportTitle,
+        firstMonthOfFY: balanceSheetClassesViewState.firstMonthOfFY,
+        dataAvailable: balanceSheetClassesViewState.dataAvailable,
+        bookCloseDate: balanceSheetClassesViewState.bookCloseDate,
+        version: balanceSheetClassesViewState.version,
+        status: balanceSheetClassesViewState.status,
+        fetchState: fetchState.fetchState,
+        error: fetchState.error,
+        filter,
+        uiState: balanceSheetClassesViewState.uiState,
+        classHierarchy,
+        classesToFilterOut: balanceSheetClassesViewState.uiState.classesToFilterOut,
+        idsInOrder: balanceSheetSectionIdsInOrder,
+        rootSectionsWithSubSectionIds: {
+            assets: ASSET_IDS_IN_ORDER,
+            liabilities: LIABILITY_IDS_IN_ORDER,
+            equity: EQUITY_IDS_IN_ORDER,
+        },
+    };
+};

package/lib/esm/view/balanceSheetClassesView/balanceSheetClassesViewSelectorTypes.js

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

package/lib/esm/view/balanceSheetClassesView/balanceSheetClassesViewState.js

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

package/lib/esm/view/balanceSheetClassesView/balanceSheetForTimeframeClassesViewEpic.js

@@ -0,0 +1,61 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateSectionClassesView } from '../../entity/sectionClassesViewV2/sectionClassesViewReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
+import { toSectionId } from '../balanceSheet/balanceSheetPayload';
+import { fetchBalanceSheetForTimeframeClassesView, updateBalanceSheetForTimeframeClassesView, updateBalanceSheetForTimeframeClassesViewFailure, } from './balanceSheetClassesViewReducer';
+const getTimeSeriesGroup = (timeframe) => {
+    switch (timeframe) {
+        case 'month':
+            return 'months';
+        case 'quarter':
+            return 'quarters';
+        case 'year':
+            return 'years';
+    }
+};
+export const reportIdUniqueKey = () => 'balance_sheet_by_classes';
+export const fetchBalanceSheetForTimeframeClassesViewEpic = (actions$, _, zeniAPI) => actions$.pipe(filter(fetchBalanceSheetForTimeframeClassesView.match), mergeMap((action) => {
+    const queryValue = {
+        // The report endpoint rejects a falsey is_full_response, so it is fixed.
+        is_full_response: true,
+        time_series_groups: [getTimeSeriesGroup(action.payload.timeframe)],
+        is_group_by_class: true,
+        // Only sent when refreshing: the flag makes the backend bypass its saved
+        // report and regenerate, so a normal lookup must not carry it.
+        ...(action.payload.cacheOverride === true
+            ? { is_hard_refresh: true }
+            : {}),
+    };
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/2.0/reports/balance_sheet?query=${encodeURIComponent(JSON.stringify(queryValue))}`)
+        .pipe(mergeMap((response) => {
+        if (response.data != null && isSuccessResponse(response)) {
+            const actions = [];
+            const { report } = response.data;
+            const currency = report.currency;
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('cash_and_equivalents'), reportIdUniqueKey(), report.assets.current_assets.cash_and_equivalents, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('accounts_receivable'), reportIdUniqueKey(), report.assets.current_assets.accounts_receivable, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('other_current_assets'), reportIdUniqueKey(), report.assets.current_assets.other_current_assets, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('fixed_assets'), reportIdUniqueKey(), report.assets.fixed_assets, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('other_assets'), reportIdUniqueKey(), report.assets.other_assets, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('accounts_payable'), reportIdUniqueKey(), report.liabilities.current_liabilities.accounts_payable, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('credit_cards'), reportIdUniqueKey(), report.liabilities.current_liabilities.credit_cards, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('other_current_liabilities'), reportIdUniqueKey(), report.liabilities.current_liabilities
+                .other_current_liabilities, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('long_term_liabilities'), reportIdUniqueKey(), report.liabilities.long_term_liabilities, report.classes, report.accounts, currency));
+            actions.push(updateSectionClassesView(action.payload.timeframe, toSectionId('equity'), reportIdUniqueKey(), report.equity, report.classes, report.accounts, currency));
+            actions.push(updateBalanceSheetForTimeframeClassesView({
+                timeframe: action.payload.timeframe,
+                report: response.data,
+            }));
+            return from(actions);
+        }
+        else {
+            return of(updateBalanceSheetForTimeframeClassesViewFailure(response.status, action.payload.timeframe));
+        }
+    }), catchError((error) => of(updateBalanceSheetForTimeframeClassesViewFailure(createZeniAPIStatus('Unexpected Error', 'Balance Sheet by Class REST API call errored out: ' +
+        (error instanceof Error
+            ? error.message
+            : JSON.stringify(error))), action.payload.timeframe))));
+}));

package/lib/esm/view/balanceSheetProjectView/balanceSheetForTimeframeProjectViewEpic.js

@@ -0,0 +1,63 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateProjects } from '../../entity/project/projectReducer';
+import { updateSectionProjectView } from '../../entity/sectionProjectView/sectionProjectViewReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
+import { toSectionId } from '../balanceSheet/balanceSheetPayload';
+import { fetchBalanceSheetForTimeframeProjectView, updateBalanceSheetForTimeframeProjectView, updateBalanceSheetForTimeframeProjectViewFailure, } from './balanceSheetProjectViewReducer';
+const getTimeSeriesGroup = (timeframe) => {
+    switch (timeframe) {
+        case 'month':
+            return 'months';
+        case 'quarter':
+            return 'quarters';
+        case 'year':
+            return 'years';
+    }
+};
+export const reportIdUniqueKey = () => 'balance_sheet_by_projects';
+export const fetchBalanceSheetForTimeframeProjectViewEpic = (actions$, _, zeniAPI) => actions$.pipe(filter(fetchBalanceSheetForTimeframeProjectView.match), mergeMap((action) => {
+    const queryValue = {
+        // The report endpoint rejects a falsey is_full_response, so it is fixed.
+        is_full_response: true,
+        time_series_groups: [getTimeSeriesGroup(action.payload.timeframe)],
+        is_group_by_project: true,
+        // Only sent when refreshing: the flag makes the backend bypass its saved
+        // report and regenerate, so a normal lookup must not carry it.
+        ...(action.payload.cacheOverride === true
+            ? { is_hard_refresh: true }
+            : {}),
+    };
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/2.0/reports/balance_sheet?query=${encodeURIComponent(JSON.stringify(queryValue))}`)
+        .pipe(mergeMap((response) => {
+        if (response.data != null && isSuccessResponse(response)) {
+            const actions = [];
+            const { report } = response.data;
+            const currency = report.currency;
+            actions.push(updateProjects(report.projects));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('cash_and_equivalents'), reportIdUniqueKey(), report.assets.current_assets.cash_and_equivalents, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('accounts_receivable'), reportIdUniqueKey(), report.assets.current_assets.accounts_receivable, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('other_current_assets'), reportIdUniqueKey(), report.assets.current_assets.other_current_assets, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('fixed_assets'), reportIdUniqueKey(), report.assets.fixed_assets, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('other_assets'), reportIdUniqueKey(), report.assets.other_assets, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('accounts_payable'), reportIdUniqueKey(), report.liabilities.current_liabilities.accounts_payable, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('credit_cards'), reportIdUniqueKey(), report.liabilities.current_liabilities.credit_cards, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('other_current_liabilities'), reportIdUniqueKey(), report.liabilities.current_liabilities
+                .other_current_liabilities, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('long_term_liabilities'), reportIdUniqueKey(), report.liabilities.long_term_liabilities, report.accounts, currency));
+            actions.push(updateSectionProjectView(action.payload.timeframe, toSectionId('equity'), reportIdUniqueKey(), report.equity, report.accounts, currency));
+            actions.push(updateBalanceSheetForTimeframeProjectView({
+                timeframe: action.payload.timeframe,
+                report: response.data,
+            }));
+            return from(actions);
+        }
+        else {
+            return of(updateBalanceSheetForTimeframeProjectViewFailure(response.status, action.payload.timeframe));
+        }
+    }), catchError((error) => of(updateBalanceSheetForTimeframeProjectViewFailure(createZeniAPIStatus('Unexpected Error', 'Balance Sheet by Project REST API call errored out: ' +
+        (error instanceof Error
+            ? error.message
+            : JSON.stringify(error))), action.payload.timeframe))));
+}));

package/lib/esm/view/balanceSheetProjectView/balanceSheetProjectViewEpic.js

@@ -0,0 +1,30 @@
+import { from } from 'rxjs';
+import { filter, switchMap } from 'rxjs/operators';
+import { fetchBalanceSheetForTimeframeProjectView, fetchBalanceSheetProjectView, } from './balanceSheetProjectViewReducer';
+export const fetchBalanceSheetProjectViewEpic = (actions$, state) => actions$.pipe(filter(fetchBalanceSheetProjectView.match), switchMap((action) => {
+    const { cacheOverride } = action.payload;
+    if (cacheOverride === true) {
+        return from([
+            fetchBalanceSheetForTimeframeProjectView('month', true),
+            fetchBalanceSheetForTimeframeProjectView('quarter', true),
+            fetchBalanceSheetForTimeframeProjectView('year', true),
+        ]);
+    }
+    else {
+        const fetchActions = [];
+        const projectFetchState = state.value.balanceSheetProjectViewState.fetchState;
+        if (projectFetchState['month'].fetchState !== 'In-Progress' &&
+            projectFetchState['month'].fetchState !== 'Completed') {
+            fetchActions.push(fetchBalanceSheetForTimeframeProjectView('month'));
+        }
+        if (projectFetchState['quarter'].fetchState !== 'In-Progress' &&
+            projectFetchState['quarter'].fetchState !== 'Completed') {
+            fetchActions.push(fetchBalanceSheetForTimeframeProjectView('quarter'));
+        }
+        if (projectFetchState['year'].fetchState !== 'In-Progress' &&
+            projectFetchState['year'].fetchState !== 'Completed') {
+            fetchActions.push(fetchBalanceSheetForTimeframeProjectView('year'));
+        }
+        return from(fetchActions);
+    }
+}));

package/lib/esm/view/balanceSheetProjectView/balanceSheetProjectViewPayload.js

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

package/lib/esm/view/balanceSheetProjectView/balanceSheetProjectViewReducer.js

@@ -0,0 +1,128 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { mapReportPayloadV2ToReportV2 } from '../../commonPayloadTypes/v2/viewAndReportPayloadv2';
+import { clearAll } from '../../rootActions';
+export const initialState = {
+    bookCloseDate: undefined,
+    fetchState: {
+        month: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        quarter: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        year: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    },
+    firstMonthOfFY: 1,
+    projectIds: [],
+    reportId: 'balance_sheet_by_projects',
+    reportTitle: 'balance_sheet_by_projects',
+    uiState: {
+        accountViewMode: 'account_group',
+        nodeCollapseState: {},
+        projectsToFilterOut: [],
+        scrollPosition: undefined,
+    },
+};
+const balanceSheetProjectView = createSlice({
+    name: 'balanceSheetProjectView',
+    initialState,
+    reducers: {
+        fetchBalanceSheetProjectView: {
+            prepare(cacheOverride = false) {
+                return { payload: { cacheOverride } };
+            },
+            reducer(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                // nothing to do here
+            },
+        },
+        fetchBalanceSheetForTimeframeProjectView: {
+            prepare(timeframe, cacheOverride = false) {
+                return { payload: { timeframe, cacheOverride } };
+            },
+            reducer(draft, action) {
+                const timeframe = action.payload.timeframe;
+                draft.fetchState[timeframe].fetchState = 'In-Progress';
+                draft.fetchState[timeframe].error = undefined;
+            },
+        },
+        updateBalanceSheetForTimeframeProjectView(draft, action) {
+            doUpdateBalanceSheetProjectView(draft, action.payload.timeframe, action.payload.report);
+        },
+        updateBalanceSheetForTimeframeProjectViewFailure: {
+            prepare(error, timeframe) {
+                return {
+                    payload: {
+                        error,
+                        timeframe,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                draft.fetchState[action.payload.timeframe] = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+            },
+        },
+        updateBalanceSheetProjectsToFilterOut(draft, action) {
+            draft.uiState.projectsToFilterOut = action.payload.projectsToFilterOut;
+        },
+        updateBalanceSheetProjectViewUIState(draft, action) {
+            const { nodeCollapseState, scrollPosition, resetLeftScroll } = action.payload;
+            if (nodeCollapseState != null) {
+                draft.uiState.nodeCollapseState = Object.assign({}, draft.uiState.nodeCollapseState, {
+                    [nodeCollapseState.nodeId]: nodeCollapseState.isCollapsed,
+                });
+            }
+            // Mutually exclusive: resetLeftScroll clears only scrollLeft from the
+            // recorded position, scrollPosition replaces the whole record.
+            if (resetLeftScroll === true && draft.uiState.scrollPosition != null) {
+                draft.uiState.scrollPosition.scrollLeft = undefined;
+            }
+            else if (scrollPosition != null) {
+                draft.uiState.scrollPosition = scrollPosition;
+            }
+        },
+        updateBalanceSheetProjectViewAccountViewMode(draft, action) {
+            draft.uiState.accountViewMode = action.payload.viewMode;
+        },
+        resetBalanceSheetProjectNodeCollapseState(draft) {
+            draft.uiState.nodeCollapseState = {};
+        },
+        clearBalanceSheetProjectView(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(clearAll, (draft) => {
+            Object.assign(draft, initialState);
+        });
+    },
+});
+export const { fetchBalanceSheetProjectView, fetchBalanceSheetForTimeframeProjectView, updateBalanceSheetForTimeframeProjectView, updateBalanceSheetForTimeframeProjectViewFailure, updateBalanceSheetProjectsToFilterOut, updateBalanceSheetProjectViewUIState, updateBalanceSheetProjectViewAccountViewMode, resetBalanceSheetProjectNodeCollapseState, clearBalanceSheetProjectView, } = balanceSheetProjectView.actions;
+export default balanceSheetProjectView.reducer;
+const doUpdateBalanceSheetProjectView = (draft, timeframe, balanceSheetReport) => {
+    const report = mapReportPayloadV2ToReportV2(balanceSheetReport.report);
+    draft.currency = report.currency;
+    draft.dataAvailable = report.dataAvailable;
+    draft.firstMonthOfFY = report.firstMonthOfFY;
+    draft.bookCloseDate = report.bookCloseDate;
+    draft.status = report.status;
+    draft.fetchState[timeframe].fetchState = 'Completed';
+    draft.fetchState[timeframe].error = undefined;
+    // Populated once, as with classHierarchy in the classes view: a project added
+    // mid-session is not picked up until the store is cleared, even by a hard
+    // refresh. Matches profitAndLossProjectViewReducer.
+    if (draft.projectIds.length <= 0) {
+        draft.projectIds = balanceSheetReport.report.projects.map((project) => project.accounting_project_id);
+    }
+};

package/lib/esm/view/balanceSheetProjectView/balanceSheetProjectViewSelector.js

@@ -0,0 +1,90 @@
+import { newAdditionalBalancesOptions } from '../../commonStateTypes/coaBalance/additionalBalances/getAdditionalBalances';
+import { getSumOfBalancesByGroupedByPeriod } from '../../commonStateTypes/coaBalance/classBalances/getSumOfBalancesGroupedByPeriod';
+import { getCOABalances } from '../../commonStateTypes/coaBalance/coaBalance';
+import { reduceFetchStateParallelTimeframes } from '../../commonStateTypes/reduceFetchState';
+import { getProjectsByIds } from '../../entity/project/projectSelector';
+import { getSectionProjectViewReport } from '../../entity/sectionProjectView/sectionProjectViewSelector';
+import { ALL_BALANCE_SHEET_REPORT_VIEW_ASSET_IDS, ALL_BALANCE_SHEET_REPORT_VIEW_EQUITY_IDS, ALL_BALANCE_SHEET_REPORT_VIEW_LIABILITY_IDS, ALL_BALANCE_SHEET_REPORT_VIEW_SECTION_IDS, balanceSheetSectionIdsInOrder, } from '../balanceSheet/balanceSheetSelectorTypes';
+// The section-id constants and the display order are both module-level, so the
+// sorted groupings are computed once instead of on every selector call.
+const byDisplayOrder = (a, b) => balanceSheetSectionIdsInOrder.indexOf(a) -
+    balanceSheetSectionIdsInOrder.indexOf(b);
+const ASSET_IDS_IN_ORDER = [...ALL_BALANCE_SHEET_REPORT_VIEW_ASSET_IDS].sort(byDisplayOrder);
+const LIABILITY_IDS_IN_ORDER = [
+    ...ALL_BALANCE_SHEET_REPORT_VIEW_LIABILITY_IDS,
+].sort(byDisplayOrder);
+const EQUITY_IDS_IN_ORDER = [...ALL_BALANCE_SHEET_REPORT_VIEW_EQUITY_IDS].sort(byDisplayOrder);
+export const getBalanceSheetProjectView = (filter, accountState, projectState, sectionsState, balanceSheetProjectViewState) => {
+    const fetchState = reduceFetchStateParallelTimeframes([
+        balanceSheetProjectViewState.fetchState.month,
+        balanceSheetProjectViewState.fetchState.quarter,
+        balanceSheetProjectViewState.fetchState.year,
+    ]);
+    const reportId = 'balance_sheet_by_projects';
+    const sections = {};
+    const calculatedSections = {};
+    if (fetchState.fetchState === 'Completed') {
+        // Balance Sheet balances are point-in-time, so the extra columns must be
+        // read as snapshots rather than period sums.
+        const additionalBalancesOptions = newAdditionalBalancesOptions(true);
+        ALL_BALANCE_SHEET_REPORT_VIEW_SECTION_IDS.forEach((sectionId) => {
+            sections[`${sectionId}`] = getSectionProjectViewReport(accountState, projectState, sectionsState, balanceSheetProjectViewState.projectIds, {
+                reportId,
+                sectionId,
+            }, filter, additionalBalancesOptions);
+        });
+        const totalCurrentAssetsBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            sections['cashAndEquivalents'].sectionBalancesTotalByPeriod,
+            sections['accountsReceiable'].sectionBalancesTotalByPeriod,
+            sections['otherCurrentAssets'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['totalCurrentAssets'] = getCOABalances(totalCurrentAssetsBalancesByPeriod, filter, additionalBalancesOptions);
+        const totalAssetsBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            totalCurrentAssetsBalancesByPeriod ?? {},
+            sections['fixedAssets'].sectionBalancesTotalByPeriod,
+            sections['otherAssets'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['totalAssets'] = getCOABalances(totalAssetsBalancesByPeriod, filter, additionalBalancesOptions);
+        const totalCurrentLiabilitiesBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            sections['accountsPayable'].sectionBalancesTotalByPeriod,
+            sections['creditCards'].sectionBalancesTotalByPeriod,
+            sections['otherCurrentLiabilities'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['totalCurrentLiabilities'] = getCOABalances(totalCurrentLiabilitiesBalancesByPeriod, filter, additionalBalancesOptions);
+        calculatedSections['totalNonCurrentLiabilities'] = getCOABalances(sections['longTermLiabilities'].sectionBalancesTotalByPeriod, filter, additionalBalancesOptions);
+        const totalLiabilitiesBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            totalCurrentLiabilitiesBalancesByPeriod ?? {},
+            sections['longTermLiabilities'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['totalLiabilities'] = getCOABalances(totalLiabilitiesBalancesByPeriod, filter, additionalBalancesOptions);
+        calculatedSections['totalEquity'] = getCOABalances(sections['equity'].sectionBalancesTotalByPeriod, filter, additionalBalancesOptions);
+        const liabilitiesAndEquityBalancesByPeriod = getSumOfBalancesByGroupedByPeriod([
+            totalLiabilitiesBalancesByPeriod ?? {},
+            sections['equity'].sectionBalancesTotalByPeriod,
+        ]);
+        calculatedSections['liabilitiesAndEquity'] = getCOABalances(liabilitiesAndEquityBalancesByPeriod, filter, additionalBalancesOptions);
+    }
+    return {
+        sections,
+        calculatedSections,
+        reportId: balanceSheetProjectViewState.reportId,
+        reportTitle: balanceSheetProjectViewState.reportTitle,
+        firstMonthOfFY: balanceSheetProjectViewState.firstMonthOfFY,
+        dataAvailable: balanceSheetProjectViewState.dataAvailable,
+        bookCloseDate: balanceSheetProjectViewState.bookCloseDate,
+        version: balanceSheetProjectViewState.version,
+        status: balanceSheetProjectViewState.status,
+        fetchState: fetchState.fetchState,
+        error: fetchState.error,
+        filter,
+        uiState: balanceSheetProjectViewState.uiState,
+        projects: getProjectsByIds(projectState, balanceSheetProjectViewState.projectIds),
+        projectsToFilterOut: balanceSheetProjectViewState.uiState.projectsToFilterOut,
+        idsInOrder: balanceSheetSectionIdsInOrder,
+        rootSectionsWithSubSectionIds: {
+            assets: ASSET_IDS_IN_ORDER,
+            liabilities: LIABILITY_IDS_IN_ORDER,
+            equity: EQUITY_IDS_IN_ORDER,
+        },
+    };
+};

package/lib/esm/view/balanceSheetProjectView/balanceSheetProjectViewSelectorTypes.js

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

package/lib/esm/view/balanceSheetProjectView/balanceSheetProjectViewState.js

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