@zeniai/client-epic-state 4.19.19-betaAK3 → 4.19.19

package/lib/esm/view/revenue/revenueReducer.js

@@ -1,412 +0,0 @@
-import { createSlice } from '@reduxjs/toolkit';
-import { mapCOABalanceGroupedByPeriodPayloadV2ToCOABalanceGroupedByPeriod } from '../../commonPayloadTypes/v2/coaBalancePayload';
-import { mapReportPayloadV2ToReportV2 } from '../../commonPayloadTypes/v2/viewAndReportPayloadv2';
-import { getDataAvailableDateRange, getNumberOfPeriods, } from '../../commonStateTypes/dataAvailable';
-import { extractThisPeriod, getMatchingThisPeriod, } from '../../commonStateTypes/viewAndReport/thisPeriodHelpers';
-import { mapInsightsPayloadtoInsightsState } from '../../entity/insights/insightSummaryPayload';
-import { dateNow } from '../../zeniDayJS';
-import { getAvailableCOABalancesWithMostRecentNonZeroBalance, getInitialSelectedAndHighlightedRanges, getSelectedAndHighlightedRangesForNewSelection, getSelectedAndHighlightedRangesForThisPeriod, } from '../common/getSelectedAndHighlightedRanges';
-import { isCOABalanceGroupedByPeriodEmptyForTimeframe } from '../common/reportsHelpers';
-export const defaultPeriods = {
-    numberOfPeriods: 5,
-};
-export const initialRevState = {
-    bookCloseDate: undefined,
-    income: undefined,
-    cogs: undefined,
-    grossMargin: undefined,
-    fetchState: {
-        month: {
-            fetchState: 'Not-Started',
-            error: undefined,
-        },
-        quarter: {
-            fetchState: 'Not-Started',
-            error: undefined,
-        },
-        year: {
-            fetchState: 'Not-Started',
-            error: undefined,
-        },
-    },
-    dataAvailable: undefined,
-    version: 0,
-    firstMonthOfFY: 1,
-    reportId: 'revenue',
-    reportTitle: 'Revenue',
-    insights: [],
-};
-export const initialState = {
-    revenue: initialRevState,
-    revenueByForecastID: {},
-    uiState: {
-        timeframe: 'month',
-        isAdditionalBalancesShown: true,
-        selectedAdditionalBalances: [
-            'this_period_vs_last_period_percent',
-            'year_to_date_total',
-        ],
-        selectedCOABalancesRange: {
-            numberOfPeriods: defaultPeriods.numberOfPeriods,
-            orderBy: 'ascending_date',
-        },
-        highlightedCOABalancesRange: undefined,
-        maxNumOfPeriodsToHighlight: 1,
-        downloadState: 'Not-Started',
-        nodeCollapseState: {},
-        scrollPosition: undefined,
-        isForecastModeOn: false,
-        selectedForecast: undefined,
-        displayOrder: 'ascending_date',
-        reportFormat: 'more_detailed',
-    },
-    lastFetchRequestTime: undefined,
-};
-const revenue = createSlice({
-    name: 'revenue',
-    initialState,
-    reducers: {
-        fetchRevenue: {
-            prepare(fetchFullReport = false, forecastId, cacheOverride = false) {
-                return { payload: { fetchFullReport, forecastId, cacheOverride } };
-            },
-            reducer(
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            _draft, 
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            _action) {
-                // do nothing
-            },
-        },
-        fetchRevenueForTimeframe: {
-            prepare(timeframe, forecastId, fetchFullReport = true, cacheOverride = false) {
-                return {
-                    payload: { forecastId, timeframe, fetchFullReport, cacheOverride },
-                };
-            },
-            reducer(draft, action) {
-                const timeframe = action.payload.timeframe;
-                const revState = getState(draft, draft.uiState.isForecastModeOn, action.payload.forecastId);
-                const fetchState = {
-                    ...revState.fetchState,
-                };
-                fetchState[timeframe] = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-                updateState(draft, action.payload.forecastId, { fetchState });
-            },
-        },
-        fetchRevenueWithForecast: {
-            reducer(draft) {
-                draft.lastFetchRequestTime = dateNow();
-            },
-            prepare(cacheOverride = false, forecastId) {
-                return {
-                    payload: {
-                        cacheOverride,
-                        forecastId,
-                    },
-                };
-            },
-        },
-        waitForForecastListThenFetchRevenueWithForecast: {
-            reducer(draft) {
-                draft.lastFetchRequestTime = dateNow();
-            },
-            prepare(cacheOverride = false, forecastId) {
-                return {
-                    payload: {
-                        cacheOverride,
-                        forecastId,
-                    },
-                };
-            },
-        },
-        updateRevenueForTimeframe(draft, action) {
-            doUpdateRevenue(draft, action.payload.forecastId, action.payload.timeframe, action.payload.report);
-        },
-        updateRevenueForTimeframeFailure: {
-            prepare(error, forecastId, timeframe) {
-                return {
-                    payload: {
-                        error,
-                        forecastId,
-                        timeframe,
-                    },
-                };
-            },
-            reducer(draft, action) {
-                const revState = getState(draft, draft.uiState.isForecastModeOn, action.payload.forecastId);
-                const fetchState = {
-                    ...revState.fetchState,
-                };
-                fetchState[action.payload.timeframe] = {
-                    fetchState: 'Error',
-                    error: action.payload.error,
-                };
-                updateState(draft, action.payload.forecastId, { fetchState });
-            },
-        },
-        updateRevenueAdditionalBalancesSelection(draft, action) {
-            const revenueReport = getState(draft, draft.uiState.isForecastModeOn, draft.uiState.selectedForecast?.id);
-            const { timeframe, selectedCOABalancesRange, highlightedCOABalancesRange } = draft.uiState;
-            const { income, cogs, grossMargin, dataAvailable } = revenueReport;
-            draft.uiState.selectedAdditionalBalances = [
-                ...action.payload.additionalBalances,
-                'year_to_date_total',
-            ];
-            draft.uiState.maxNumOfPeriodsToHighlight =
-                action.payload.maxNumOfPeriodsToHighlight;
-            draft.uiState.isAdditionalBalancesShown =
-                action.payload.isCompareModeOn &&
-                    action.payload.additionalBalances.length != 0
-                    ? true
-                    : false;
-            // Note: We don't want to update selected & highlighted ranges in Ui State when forecast is ON
-            if (dataAvailable != null && draft.uiState.isForecastModeOn === false) {
-                const coaBalances = getAvailableCOABalancesWithMostRecentNonZeroBalance(revenueReport.firstMonthOfFY, timeframe, [income, cogs, grossMargin], dataAvailable);
-                const thisPeriod = extractThisPeriod(revenueReport.firstMonthOfFY, timeframe, selectedCOABalancesRange, coaBalances);
-                if (thisPeriod != null &&
-                    highlightedCOABalancesRange?.thisPeriod != null) {
-                    const selectedCOABalancesRangeWithThisPeriod = {
-                        ...selectedCOABalancesRange,
-                        thisPeriod,
-                    };
-                    const selectionRanges = getSelectedAndHighlightedRangesForThisPeriod({
-                        firstMonthOfFY: revenueReport.firstMonthOfFY,
-                        thisPeriod: highlightedCOABalancesRange?.thisPeriod,
-                        coaBalances,
-                        timeframe,
-                        maxNumOfPeriodsToHighlight: draft.uiState.maxNumOfPeriodsToHighlight,
-                        currentSelection: {
-                            selectedCOABalancesRange: selectedCOABalancesRangeWithThisPeriod,
-                        },
-                        orderBy: 'ascending_date',
-                        maxNumOfPeriodsToSelect: selectedCOABalancesRange.numberOfPeriods,
-                    });
-                    draft.uiState.selectedCOABalancesRange =
-                        selectionRanges.selectedCOABalancesRange;
-                    draft.uiState.highlightedCOABalancesRange =
-                        selectionRanges.highlightedCOABalancesRange;
-                }
-            }
-        },
-        updateRevenueCOABalancesRange(draft, action) {
-            // Note: When thisPeriod changes the selected and highlighted balances ranges should be calculated based on full report period.
-            const revenueReport = getState(draft, undefined, undefined);
-            const { income, cogs, grossMargin, dataAvailable } = revenueReport;
-            const { timeframe, selectedCOABalancesRange, highlightedCOABalancesRange } = draft.uiState;
-            if (dataAvailable != null &&
-                action.payload.selectedCOABalancesRange.thisPeriod != null) {
-                const coaBalances = getAvailableCOABalancesWithMostRecentNonZeroBalance(revenueReport.firstMonthOfFY, timeframe, [income, cogs, grossMargin], dataAvailable);
-                const prevThisPeriod = extractThisPeriod(revenueReport.firstMonthOfFY, timeframe, selectedCOABalancesRange, coaBalances);
-                if (prevThisPeriod != null) {
-                    const selectedCOABalancesRangeWithThisPeriod = {
-                        ...selectedCOABalancesRange,
-                        thisPeriod: prevThisPeriod,
-                    };
-                    const newThisPeriod = getMatchingThisPeriod(revenueReport.firstMonthOfFY, timeframe, action.payload.selectedCOABalancesRange.thisPeriod, coaBalances);
-                    if (newThisPeriod != null) {
-                        const selectionRanges = getSelectedAndHighlightedRangesForNewSelection({
-                            firstMonthOfFY: revenueReport.firstMonthOfFY,
-                            timeframe,
-                            coaBalances,
-                            orderBy: 'ascending_date',
-                            maxNumOfPeriodsToSelect: action.payload.selectedCOABalancesRange.numberOfPeriods,
-                            maxNumOfPeriodsToHighlight: draft.uiState.maxNumOfPeriodsToHighlight,
-                            currentSelection: {
-                                selectedCOABalancesRange: {
-                                    ...action.payload.selectedCOABalancesRange,
-                                    thisPeriod: newThisPeriod,
-                                },
-                                highlightedCOABalancesRange: action.payload.highlightedCOABalancesRange,
-                            },
-                            prevSelection: {
-                                selectedCOABalancesRange: selectedCOABalancesRangeWithThisPeriod,
-                                highlightedCOABalancesRange,
-                            },
-                        });
-                        draft.uiState.selectedCOABalancesRange =
-                            selectionRanges.selectedCOABalancesRange;
-                        draft.uiState.highlightedCOABalancesRange =
-                            selectionRanges.highlightedCOABalancesRange;
-                    }
-                }
-            }
-        },
-        updateRevenueThisPeriod(draft, action) {
-            // Note: When thisPeriod changes the selected and highlighted balances ranges should be calculated based on full report period.
-            const revenueReport = getState(draft, undefined, undefined);
-            const { income, cogs, grossMargin, dataAvailable } = revenueReport;
-            const { timeframe, selectedCOABalancesRange, highlightedCOABalancesRange, maxNumOfPeriodsToHighlight, } = draft.uiState;
-            if (dataAvailable != null && action.payload.thisPeriod != null) {
-                const coaBalances = getAvailableCOABalancesWithMostRecentNonZeroBalance(revenueReport.firstMonthOfFY, timeframe, [income, cogs, grossMargin], dataAvailable);
-                const prevThisPeriod = extractThisPeriod(revenueReport.firstMonthOfFY, timeframe, selectedCOABalancesRange, coaBalances);
-                if (prevThisPeriod != null) {
-                    const selectedCOABalancesRangeWithThisPeriod = {
-                        ...selectedCOABalancesRange,
-                        thisPeriod: prevThisPeriod,
-                    };
-                    const newThisPeriod = getMatchingThisPeriod(revenueReport.firstMonthOfFY, timeframe, action.payload.thisPeriod, coaBalances);
-                    if (newThisPeriod != null) {
-                        const selectionRanges = getSelectedAndHighlightedRangesForThisPeriod({
-                            firstMonthOfFY: revenueReport.firstMonthOfFY,
-                            thisPeriod: newThisPeriod,
-                            coaBalances,
-                            timeframe,
-                            maxNumOfPeriodsToHighlight,
-                            currentSelection: {
-                                selectedCOABalancesRange: selectedCOABalancesRangeWithThisPeriod,
-                                highlightedCOABalancesRange,
-                            },
-                            orderBy: 'ascending_date',
-                            maxNumOfPeriodsToSelect: selectedCOABalancesRange.numberOfPeriods,
-                        });
-                        draft.uiState.selectedCOABalancesRange =
-                            selectionRanges.selectedCOABalancesRange;
-                        draft.uiState.highlightedCOABalancesRange =
-                            selectionRanges.highlightedCOABalancesRange;
-                    }
-                }
-            }
-        },
-        updateRevenueDownloadState(draft, action) {
-            draft.uiState.downloadState = action.payload;
-        },
-        updateRevenueTimeFrame(draft, action) {
-            draft.uiState.timeframe = action.payload;
-            // Note:  When timeframe changes the selected and highlighted balances ranges should be calculated based on full report period.
-            const revenueReport = getState(draft, undefined, undefined);
-            const { income, cogs, grossMargin, dataAvailable } = revenueReport;
-            if (getNumberOfPeriods(revenueReport.firstMonthOfFY, action.payload, dataAvailable) === 1) {
-                draft.uiState.selectedAdditionalBalances =
-                    initialState.uiState.selectedAdditionalBalances;
-                draft.uiState.maxNumOfPeriodsToHighlight =
-                    initialState.uiState.maxNumOfPeriodsToHighlight;
-            }
-            if (dataAvailable != null) {
-                const timeframe = draft.uiState.timeframe;
-                const coaBalances = getAvailableCOABalancesWithMostRecentNonZeroBalance(revenueReport.firstMonthOfFY, timeframe, [income, cogs, grossMargin], dataAvailable);
-                const selectionRanges = getInitialSelectedAndHighlightedRanges({
-                    firstMonthOfFY: revenueReport.firstMonthOfFY,
-                    timeframe,
-                    coaBalances,
-                    orderBy: 'ascending_date',
-                    maxNumOfPeriodsToSelect: defaultPeriods.numberOfPeriods,
-                    maxNumOfPeriodsToHighlight: draft.uiState.maxNumOfPeriodsToHighlight,
-                });
-                if (selectionRanges?.selectedCOABalancesRange != null) {
-                    draft.uiState.selectedCOABalancesRange =
-                        selectionRanges?.selectedCOABalancesRange;
-                }
-                draft.uiState.highlightedCOABalancesRange =
-                    selectionRanges?.highlightedCOABalancesRange;
-            }
-        },
-        updateRevenueUIState(draft, action) {
-            const { nodeCollapseState, scrollPosition, resetLeftScroll } = action.payload;
-            if (nodeCollapseState != null) {
-                draft.uiState.nodeCollapseState = Object.assign({}, draft.uiState.nodeCollapseState, {
-                    [nodeCollapseState.nodeId]: nodeCollapseState.isCollapsed,
-                });
-            }
-            if (resetLeftScroll === true && draft.uiState.scrollPosition != null) {
-                draft.uiState.scrollPosition.scrollLeft = undefined;
-            }
-            else if (scrollPosition != null) {
-                draft.uiState.scrollPosition = scrollPosition;
-            }
-        },
-        revenueToggleForecastMode(draft, action) {
-            draft.uiState.isForecastModeOn = action.payload.isForecastModeOn;
-            draft.uiState.maxNumOfPeriodsToHighlight =
-                action.payload.maxNumOfPeriodsToHighlightWithForecast;
-            if (action.payload.isForecastModeOn == false) {
-                draft.uiState.selectedForecast = undefined;
-            }
-            else {
-                if (action.payload.selectedForecast?.id != null) {
-                    draft.uiState.selectedForecast = action.payload.selectedForecast;
-                }
-            }
-        },
-        clearRevenue(draft) {
-            Object.assign(draft, initialState);
-        },
-    },
-});
-export const { fetchRevenue, fetchRevenueWithForecast, fetchRevenueForTimeframe, waitForForecastListThenFetchRevenueWithForecast, updateRevenueForTimeframe, updateRevenueForTimeframeFailure, updateRevenueAdditionalBalancesSelection, updateRevenueCOABalancesRange, updateRevenueThisPeriod, updateRevenueDownloadState, updateRevenueTimeFrame, updateRevenueUIState, revenueToggleForecastMode, clearRevenue, } = revenue.actions;
-export default revenue.reducer;
-const doUpdateRevenue = (draft, forecastId, timeframe, revReport) => {
-    const revenue = getState(draft, draft.uiState.isForecastModeOn, forecastId);
-    const report = mapReportPayloadV2ToReportV2(revReport.report);
-    const { income, cogs, insights, currency } = revReport.report;
-    const incomeCOABalance = mapCOABalanceGroupedByPeriodPayloadV2ToCOABalanceGroupedByPeriod(income, currency, timeframe);
-    const cogsCOABalance = mapCOABalanceGroupedByPeriodPayloadV2ToCOABalanceGroupedByPeriod(cogs, currency, timeframe);
-    const grossMarginCOABalance = mapCOABalanceGroupedByPeriodPayloadV2ToCOABalanceGroupedByPeriod(revReport.report.gross_profit, currency, timeframe);
-    revenue.income = Object.assign({}, revenue.income, incomeCOABalance);
-    revenue.cogs = Object.assign({}, revenue.cogs, cogsCOABalance);
-    revenue.grossMargin = Object.assign({}, revenue.grossMargin, grossMarginCOABalance);
-    if (timeframe === 'month' && insights != null) {
-        // we will get insights only in the month timeframe api
-        revenue.insights = mapInsightsPayloadtoInsightsState(insights);
-    }
-    const isIncomeEmpty = isCOABalanceGroupedByPeriodEmptyForTimeframe(incomeCOABalance, timeframe);
-    const isCogsEmpty = isCOABalanceGroupedByPeriodEmptyForTimeframe(cogsCOABalance, timeframe);
-    const cogsOrIncome = isIncomeEmpty
-        ? isCogsEmpty
-            ? revenue.grossMargin
-            : revenue.cogs
-        : revenue.income;
-    revenue.dataAvailable = report.dataAvailable
-        ? report.dataAvailable
-        : getDataAvailableDateRange(cogsOrIncome);
-    revenue.firstMonthOfFY = report.firstMonthOfFY;
-    revenue.bookCloseDate = report.bookCloseDate;
-    revenue.fetchState[timeframe].fetchState = 'Completed';
-    revenue.fetchState[timeframe].error = undefined;
-    if (revenue.dataAvailable != null &&
-        forecastId == null // Note: We don't want to update selected & highlighted ranges in Ui State when forecast is ON
-    ) {
-        const timeframe = draft.uiState.timeframe;
-        const coaBalances = getAvailableCOABalancesWithMostRecentNonZeroBalance(revenue.firstMonthOfFY, timeframe, [revenue.income, revenue.cogs, revenue.grossMargin], revenue.dataAvailable);
-        const selectionRanges = getInitialSelectedAndHighlightedRanges({
-            firstMonthOfFY: revenue.firstMonthOfFY,
-            timeframe,
-            coaBalances,
-            orderBy: 'ascending_date',
-            maxNumOfPeriodsToSelect: defaultPeriods.numberOfPeriods,
-            maxNumOfPeriodsToHighlight: draft.uiState.isForecastModeOn == true
-                ? draft.uiState.maxNumOfPeriodsToHighlight
-                : initialState.uiState.maxNumOfPeriodsToHighlight,
-        });
-        if (selectionRanges?.selectedCOABalancesRange != null) {
-            draft.uiState.selectedCOABalancesRange =
-                selectionRanges?.selectedCOABalancesRange;
-        }
-        draft.uiState.highlightedCOABalancesRange =
-            selectionRanges?.highlightedCOABalancesRange;
-    }
-    updateState(draft, forecastId, revenue);
-};
-export function getState(state, isForecastModeOn, forecastId) {
-    if (forecastId != null &&
-        forecastId.length > 0 &&
-        isForecastModeOn === true) {
-        return Object.assign({}, state.revenueByForecastID[forecastId] ?? initialRevState);
-    }
-    else {
-        return state.revenue;
-    }
-}
-function updateState(state, forecastId, updates) {
-    if (forecastId != null && forecastId.length > 0) {
-        const currentValue = state.revenueByForecastID[forecastId] ?? initialRevState;
-        const updatedValue = Object.assign({}, currentValue, updates);
-        state.revenueByForecastID[forecastId] = updatedValue;
-    }
-    else {
-        state.revenue = Object.assign({}, state.revenue, updates);
-    }
-}

package/lib/esm/view/revenue/revenueSelector.js

@@ -1,203 +0,0 @@
-import { createSelector } from '@reduxjs/toolkit';
-import { getCOABalances } from '../../commonStateTypes/coaBalance/coaBalance';
-import { newBalancesFilter, newBalancesFilterForDateRange, } from '../../commonStateTypes/coaBalance/coaBalancesFilter';
-import { getNumberOfPeriods } from '../../commonStateTypes/dataAvailable';
-import { reduceAnyFetchState, reduceFetchState, } from '../../commonStateTypes/reduceFetchState';
-import { pickAndMergeForecastCalculatedSection } from '../../commonStateTypes/selectorTypes/pickAndMergeForecastCalculatedSection';
-import { toTimeframeTick, } from '../../commonStateTypes/timeframeTick';
-import { getForecast } from '../../entity/forecast/forecastSelector';
-import { getCalculatedSectionAccountsViewReport, getSectionAccountsViewReport, getSectionBalances, pickAndMergeForecastSectionAccountsReport, } from '../../entity/sectionAccountsView/sectionAccountsViewSelector';
-import { isCOABalanceGroupedByPeriodEmptyForTimeframe } from '../common/reportsHelpers';
-import { getForecastList } from '../forecastList/forecastListSelector';
-import { ALL_REVENUE_CALCULATED_SECTION_IDS, ALL_REVENUE_SECTION_IDS, revenueIdsInOrder, } from '../revenue/revenueSelectorTypes';
-import { reportIdUniqueKey } from './revenueForTimeframeEpic';
-import { getGrossMarginWithPercent } from './revenueHelper';
-import { getState } from './revenueReducer';
-export const getRevenueReport = (filter, accountState, accountGroupState, sectionsState, forecastListState, revenueWithForecastState, forecastState, forecastId) => {
-    const revState = getState(revenueWithForecastState, revenueWithForecastState.uiState.isForecastModeOn, forecastId);
-    const fetchState = reduceAnyFetchState([
-        revState.fetchState.month,
-        revState.fetchState.quarter,
-        revState.fetchState.year,
-    ]);
-    const reportId = reportIdUniqueKey(forecastId);
-    const sections = {};
-    const calculatedSections = {};
-    let allTimeframeTicks = [];
-    const dataAvailable = revenueWithForecastState.revenue.dataAvailable;
-    if (fetchState.fetchState === 'Completed') {
-        ALL_REVENUE_SECTION_IDS.forEach((sectionId) => {
-            sections[`${sectionId}`] = getSectionAccountsViewReport(accountState, accountGroupState, sectionsState, {
-                reportId,
-                sectionId,
-            }, filter);
-        });
-        ALL_REVENUE_CALCULATED_SECTION_IDS.forEach((sectionId) => {
-            calculatedSections[`${sectionId}`] =
-                getCalculatedSectionAccountsViewReport(sectionsState, {
-                    reportId,
-                    sectionId,
-                }, filter);
-        });
-        calculatedSections.grossMargin = getGrossMarginWithPercent(calculatedSections.grossMargin, sections.income);
-    }
-    if (dataAvailable != null) {
-        const noFilter = newBalancesFilterForDateRange(revState.firstMonthOfFY, revenueWithForecastState.uiState.timeframe, dataAvailable, 'ascending_date', []);
-        const timeframe = revenueWithForecastState.uiState.timeframe;
-        // To get incomeBalances without forecast init.
-        const incomeBalance = getSectionBalances(sectionsState, {
-            reportId: reportIdUniqueKey(), // reportId without forecastId init to fetch Accouts incomeBalances
-            sectionId: 'income',
-        });
-        // To get cogsBalance without forecast init.
-        const cogsBalance = getSectionBalances(sectionsState, {
-            reportId: reportIdUniqueKey(), // reportId without forecastId init to fetch Accouts cogsBalance
-            sectionId: 'cogs',
-        });
-        const grossMarginBalances = getSectionBalances(sectionsState, {
-            reportId: reportIdUniqueKey(), // reportId without forecastId init to fetch Accouts cogsBalance
-            sectionId: 'grossMargin',
-        });
-        const incomeOrCogs = incomeBalance != null
-            ? isCOABalanceGroupedByPeriodEmptyForTimeframe(incomeBalance, timeframe)
-            : false;
-        let incomeOrCogsBalances = incomeOrCogs
-            ? getCOABalances(incomeBalance, noFilter)
-            : getCOABalances(cogsBalance, noFilter);
-        if (incomeOrCogsBalances.balances.length === 0) {
-            // rare case but we should also check grossmargin balances
-            if (grossMarginBalances != null &&
-                isCOABalanceGroupedByPeriodEmptyForTimeframe(grossMarginBalances, timeframe)) {
-                incomeOrCogsBalances = getCOABalances(grossMarginBalances, noFilter);
-            }
-        }
-        allTimeframeTicks = incomeOrCogsBalances.balances.map((balance) => toTimeframeTick(balance));
-    }
-    const forecastList = getForecastList(forecastState, forecastListState);
-    const forecast = revState.forecastId != null
-        ? getForecast(forecastState, revState.forecastId)
-        : undefined;
-    return {
-        sections,
-        calculatedSections,
-        forecast,
-        reportId: revState.reportId,
-        reportTitle: revState.reportTitle,
-        firstMonthOfFY: revState.firstMonthOfFY,
-        dataAvailable: revenueWithForecastState.revenue.dataAvailable, // Picking dataAvailable from base Report
-        bookCloseDate: revState.bookCloseDate,
-        version: revState.version,
-        status: revState.status,
-        fetchState: fetchState.fetchState,
-        error: fetchState.error,
-        filter: filter,
-        downloadState: revenueWithForecastState.uiState.downloadState,
-        idsInOrder: revenueIdsInOrder,
-        forecastList: forecastList,
-        allTimeframeTicks,
-        insights: revenueWithForecastState.revenue.insights ?? [], // Picking insights from RevenueState in both foregast mode on and off
-        availableNumberOfPeriods: getNumberOfPeriods(revState.firstMonthOfFY, filter.timeframe, revState.dataAvailable),
-    };
-};
-export const getRevenueUIState = createSelector((state) => state.revenueState, (state) => state.forecastListState, (revenueWithForecastState, forecastListState) => {
-    const { timeframe, selectedCOABalancesRange, highlightedCOABalancesRange, selectedAdditionalBalances, selectedForecast, isForecastModeOn, downloadState, nodeCollapseState, scrollPosition, maxNumOfPeriodsToHighlight, isAdditionalBalancesShown, displayOrder, reportFormat, } = revenueWithForecastState.uiState;
-    const revState = getState(revenueWithForecastState, isForecastModeOn, selectedForecast?.id);
-    const fetchState = reduceAnyFetchState([
-        revState.fetchState.month,
-        revState.fetchState.quarter,
-        revState.fetchState.year,
-    ]);
-    let effectiveFetchState = fetchState;
-    if (revenueWithForecastState.uiState.isForecastModeOn === true) {
-        const allFetchStates = [
-            fetchState,
-            {
-                fetchState: forecastListState.fetchState,
-                error: forecastListState.error,
-            },
-        ];
-        if (!(forecastListState.fetchState === 'Completed' &&
-            forecastListState.forecastIds.length === 0)) {
-            allFetchStates.push(getRevenueReportFetchState(selectedForecast?.id, revenueWithForecastState));
-        }
-        effectiveFetchState = reduceFetchState(allFetchStates);
-    }
-    return {
-        timeframe,
-        selectedCOABalancesRange,
-        highlightedCOABalancesRange,
-        selectedAdditionalBalances,
-        selectedForecast,
-        isForecastModeOn,
-        downloadState,
-        nodeCollapseState,
-        fetchState: effectiveFetchState.fetchState,
-        error: effectiveFetchState.error,
-        version: revState.version,
-        isAdditionalBalancesShown,
-        maxNumOfPeriodsToHighlight,
-        mode: isAdditionalBalancesShown
-            ? 'compare_mode'
-            : isForecastModeOn // eslint-disable-line @typescript-eslint/strict-boolean-expressions
-                ? 'forecast_mode'
-                : 'off',
-        scrollPosition,
-        displayOrder,
-        reportFormat,
-    };
-});
-export const getRevenueForSelectedRange = createSelector((state) => state.accountState, (state) => state.accountGroupState, (state) => state.revenueState, (state) => state.forecastState, (state) => state.sectionAccountsViewState, (state) => state.forecastListState, (accountState, accountGroupState, revenueWithForecastState, forecastState, sectionAccountsViewState, forecastListState) => {
-    const { timeframe, selectedCOABalancesRange, selectedAdditionalBalances, isForecastModeOn, selectedForecast, } = revenueWithForecastState.uiState;
-    const noFilter = newBalancesFilter(revenueWithForecastState.revenue.firstMonthOfFY, timeframe, selectedCOABalancesRange.numberOfPeriods, selectedCOABalancesRange.thisPeriod, 'ascending_date', selectedAdditionalBalances);
-    return isForecastModeOn === true &&
-        selectedForecast?.id != null &&
-        getRevenueReportFetchState(selectedForecast.id, revenueWithForecastState).fetchState === 'Completed'
-        ? getRevenueWithForecastOnDataAvailableDateRange(noFilter, selectedForecast?.id, accountState, accountGroupState, sectionAccountsViewState, forecastListState, revenueWithForecastState, forecastState)
-        : getRevenueReport(noFilter, accountState, accountGroupState, sectionAccountsViewState, forecastListState, revenueWithForecastState, forecastState, selectedForecast?.id);
-});
-export const getRevenueForHighlightedRange = createSelector((state) => state.accountGroupState, (state) => state.accountState, (state) => state.revenueState, (state) => state.forecastState, (state) => state.forecastListState, (state) => state.sectionAccountsViewState, (accountGroupState, accountState, revenueWithForecastState, forecastState, forecastListState, sectionsState) => {
-    const { timeframe, highlightedCOABalancesRange, selectedAdditionalBalances, maxNumOfPeriodsToHighlight, isForecastModeOn, selectedForecast, } = revenueWithForecastState.uiState;
-    const filter = newBalancesFilter(revenueWithForecastState.revenue.firstMonthOfFY, timeframe, highlightedCOABalancesRange?.numberOfPeriods ??
-        maxNumOfPeriodsToHighlight, highlightedCOABalancesRange?.thisPeriod, 'ascending_date', selectedAdditionalBalances);
-    return isForecastModeOn === true &&
-        selectedForecast?.id != null &&
-        getRevenueReportFetchState(selectedForecast.id, revenueWithForecastState)
-            .fetchState === 'Completed'
-        ? getRevenueWithForecastOnDataAvailableDateRange(filter, selectedForecast?.id, accountState, accountGroupState, sectionsState, forecastListState, revenueWithForecastState, forecastState)
-        : getRevenueReport(filter, accountState, accountGroupState, sectionsState, forecastListState, revenueWithForecastState, forecastState, selectedForecast?.id);
-});
-/**
- * Get Revenue with forecast data overlaid on actuals.
- * @param filter : ;
- * @param forecastId
- * @param accountState
- * @param accountGroupState
- * @param forecastState
- * @param state
- * @notes IMPORTANT:
- * 1. Here the forecast data for the given forecast ID is super imposed on actual data.
- * 2. This method can super impose forecast data on whole data available date range,
- * rather than restricting to ONLY forecast date range.
- * This is different from zeni REST API endpoint where it only super imposes forecast data ONLY for the forecast time period.
- */
-function getRevenueWithForecastOnDataAvailableDateRange(filter, selectedforecastId, accountState, accountGroupState, sectionsState, forecastListState, revenueWithForecaststate, forecastState) {
-    const reportA = getRevenueReport(filter, accountState, accountGroupState, sectionsState, forecastListState, revenueWithForecaststate, forecastState);
-    const reportF = getRevenueReport(filter, accountState, accountGroupState, sectionsState, forecastListState, revenueWithForecaststate, forecastState, selectedforecastId);
-    ALL_REVENUE_SECTION_IDS.forEach((sectionId) => {
-        reportF.sections[`${sectionId}`] =
-            pickAndMergeForecastSectionAccountsReport(reportA.sections[`${sectionId}`], reportF.sections[`${sectionId}`]);
-    });
-    ALL_REVENUE_CALCULATED_SECTION_IDS.forEach((sectionId) => {
-        reportF.calculatedSections[`${sectionId}`] =
-            pickAndMergeForecastCalculatedSection(reportA.calculatedSections[`${sectionId}`], reportF.calculatedSections[`${sectionId}`]);
-    });
-    return reportF;
-}
-export const getRevenueReportFetchState = (forecastId, revenueWithForecastState) => {
-    const revState = getState(revenueWithForecastState, forecastId != null, forecastId);
-    return reduceAnyFetchState([
-        revState.fetchState.month,
-        revState.fetchState.quarter,
-        revState.fetchState.year,
-    ]);
-};

package/lib/esm/view/revenue/revenueSelectorTypes.js

@@ -1,10 +0,0 @@
-import { stringToUnion } from '../../commonStateTypes/stringToUnion';
-export const ALL_REVENUE_SECTION_IDS = ['cogs', 'income'];
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const toRevenueSectionID = (v) => stringToUnion(v, ALL_REVENUE_SECTION_IDS);
-export const isRevenueSectionID = (id) => ALL_REVENUE_SECTION_IDS.find((sectionId) => id === sectionId) != null;
-export const ALL_REVENUE_CALCULATED_SECTION_IDS = ['grossMargin'];
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const toRevenueCalculatedSectionID = (v) => stringToUnion(v, ALL_REVENUE_CALCULATED_SECTION_IDS);
-export const isRevenueCalculatedSectionID = (id) => ALL_REVENUE_CALCULATED_SECTION_IDS.find((calcId) => id === calcId) != null;
-export const revenueIdsInOrder = ['income', 'cogs', 'grossMargin'];

package/lib/esm/view/revenue/revenueState.js

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

package/lib/esm/view/revenueClassesView/revenueClassesViewEpic.js

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

package/lib/esm/view/revenueClassesView/revenueClassesViewPayload.js

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