@zeniai/client-epic-state 5.3.23-beta0AN → 5.3.23-beta1AN

package/lib/commonStateTypes/accountView/getNestedAccountIDHierarchyForReport.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllAccountMetadataRecordsByID = exports.getParentAccountId = void 0;
+exports.geNestedAccountIDHierarchyForReport = geNestedAccountIDHierarchyForReport;
+exports.getNestedAccountIDForAccount = getNestedAccountIDForAccount;
+const accountPayload_1 = require("../../entity/account/accountPayload");
+/**
+ * This function builds the hierarchy which is used to display all accounts
+ * in the selection view
+ * @param accountsMetadata
+ * @returns
+ */
+function geNestedAccountIDHierarchyForReport(accountsMetadata) {
+    const parentAccounts = [];
+    accountsMetadata.forEach((accountMeta) => {
+        if (accountMeta.isSubAccount === false ||
+            // look for its parent in the entire metadata. If not found, then push this also as a rootNode
+            accountsMetadata.find((eachAccount) => eachAccount.accountId === accountMeta.parentAccountId) == null) {
+            parentAccounts.push(accountMeta);
+        }
+    });
+    const nestedParents = parentAccounts.map((parentAccount) => {
+        const accountId = parentAccount.accountId;
+        return {
+            accountId: [accountId],
+            accountName: parentAccount.accountName,
+            qboId: parentAccount.qboId,
+            children: getNestedChildren([accountId], accountsMetadata),
+            hasSiblings: parentAccounts.length > 1,
+            coaId: parentAccount.coaId,
+            isBillEditableCoaAccountType: parentAccount.isBillEditableCoaAccountType,
+            isDeleted: parentAccount.isDeleted,
+        };
+    });
+    return nestedParents;
+}
+const getNestedChildren = (parentAccount, allAccounts) => {
+    const parentId = parentAccount[0];
+    const children = allAccounts.filter((eachAccount) => eachAccount.parentAccountId === parentId);
+    const nestedChildren = children.map((child) => {
+        const childId = [child.accountId, ...parentAccount];
+        return {
+            accountId: childId,
+            accountName: child.accountName,
+            qboId: child.qboId,
+            children: getNestedChildren(childId, allAccounts),
+            hasSiblings: children.length > 1,
+            coaId: child.coaId,
+            isBillEditableCoaAccountType: child.isBillEditableCoaAccountType,
+            isDeleted: child.isDeleted,
+        };
+    });
+    return nestedChildren;
+};
+/**
+ * Modified this function to remove recursion. The accounts metadata will ALWAYS be sorted such that all
+ * parent accounts of any will appear before any child account.
+ * @param accountId
+ * @param accountsMetadata
+ * @returns
+ */
+function getNestedAccountIDForAccount(accountId, accountsMetadata) {
+    let nestedAccountId = undefined;
+    let toFindAccountId = accountId;
+    let toFindParentAccountId = undefined;
+    for (let index = accountsMetadata.length - 1; index >= 0; index--) {
+        if (accountsMetadata[index].accountId === toFindAccountId) {
+            nestedAccountId =
+                nestedAccountId == null
+                    ? [toFindAccountId]
+                    : [...nestedAccountId, toFindAccountId];
+            toFindParentAccountId = accountsMetadata[index].parentAccountId;
+            if (toFindParentAccountId == null) {
+                break;
+            }
+            else {
+                toFindAccountId = toFindParentAccountId;
+                toFindParentAccountId = undefined;
+            }
+        }
+    }
+    if (nestedAccountId == null) {
+        throw Error(`Cannot find accountId ${accountId} in account metadata`);
+    }
+    return nestedAccountId;
+}
+const getParentAccountId = (accountId) => {
+    return accountId.length > 1
+        ? accountId.slice(1)
+        : undefined;
+};
+exports.getParentAccountId = getParentAccountId;
+const getAllAccountMetadataRecordsByID = (accountsMetadataPayload) => {
+    const accountMetadataRecords = {};
+    const accountMetadataRecordsPartial = {};
+    const accountsMetadata = accountsMetadataPayload != null
+        ? accountsMetadataPayload.map((accountPayload) => {
+            const accountMeta = (0, accountPayload_1.mapAccountMetadataPayloadToAccountMetadata)(accountPayload);
+            accountMetadataRecordsPartial[accountMeta.accountId] = Object.assign({}, {
+                payload: accountPayload,
+                meta: accountMeta,
+            });
+            return accountMeta;
+        })
+        : [];
+    accountsMetadata.forEach((accountMeta) => {
+        accountMetadataRecords[accountMeta.accountId] = Object.assign({}, {
+            nestedAccountId: getNestedAccountIDForAccount(accountMeta.accountId, accountsMetadata),
+            accountMetadata: accountMetadataRecordsPartial[accountMeta.accountId].meta,
+            accountMetadataPayload: accountMetadataRecordsPartial[accountMeta.accountId].payload,
+        });
+    });
+    return accountMetadataRecords;
+};
+exports.getAllAccountMetadataRecordsByID = getAllAccountMetadataRecordsByID;

package/lib/commonStateTypes/accountView/nestedAccountID.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEqualNestedAccountId = void 0;
+exports.getNestedAccountIDStr = getNestedAccountIDStr;
+function getNestedAccountIDStr(nestedAccountId) {
+    const [accountId, parentAccountId, greatParentAccountId, greatGreatParentAccountId, greatGreatGreatParentAccountId,] = nestedAccountId;
+    return `${accountId}-${parentAccountId ?? ''}-${greatParentAccountId ?? ''}-${greatGreatParentAccountId ?? ''}-${greatGreatGreatParentAccountId ?? ''}`;
+}
+const isEqualNestedAccountId = (nestedAccountIdA, nestedAccountIdB) => {
+    const nestedStringA = getNestedAccountIDStr(nestedAccountIdA);
+    const nestedStringB = getNestedAccountIDStr(nestedAccountIdB);
+    return nestedStringA === nestedStringB;
+};
+exports.isEqualNestedAccountId = isEqualNestedAccountId;

package/lib/commonStateTypes/agingBalance/agingBalance.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAgingBalancesKey = exports.toAgingPeriod = exports.AGING_PERIODS = void 0;
+const stringToUnion_1 = require("../stringToUnion");
+const timePeriod_1 = require("../timePeriod");
+exports.AGING_PERIODS = [
+    'current_due',
+    'due_1-30_days',
+    'due_31-60_days',
+    'due_61-90_days',
+    'due_over_90_days',
+];
+const toAgingPeriod = (v) => (0, stringToUnion_1.stringToUnion)(v, exports.AGING_PERIODS);
+exports.toAgingPeriod = toAgingPeriod;
+const getAgingBalancesKey = (reportDate) => `${reportDate.format(timePeriod_1.DEFAULT_DATE_FORMAT)}`;
+exports.getAgingBalancesKey = getAgingBalancesKey;

package/lib/commonStateTypes/allowedValue.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowedValueWithCode = isAllowedValueWithCode;
+exports.isAllowedValueWithID = isAllowedValueWithID;
+function isAllowedValueWithCode(allowedValue) {
+    return allowedValue.code !== undefined;
+}
+function isAllowedValueWithID(allowedValue) {
+    return allowedValue.id !== undefined;
+}

package/lib/commonStateTypes/amount.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAmountWC = exports.toAmount = void 0;
+const toAmount = (amount, currency_code, currency_symbol) => ({
+    amount: amount,
+    currencyCode: currency_code,
+    currencySymbol: currency_symbol,
+});
+exports.toAmount = toAmount;
+/* to amount with currency */
+const toAmountWC = (amount, currency) => (0, exports.toAmount)(amount, currency.currencyCode, currency.currencySymbol);
+exports.toAmountWC = toAmountWC;

package/lib/commonStateTypes/animations.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnimationsFileName = void 0;
+const stringToUnion_1 = require("./stringToUnion");
+const ALL_ANIMATIONS_FILE_NAMES = [
+    'AiAgent',
+    'AiIconEntry',
+    'AiIconExit',
+    'AiIconLoop',
+    'AiStar',
+    'AiStarIcon',
+    'AiStarPlain',
+    'AIPoweredInvoiceDark',
+    'AIPoweredInvoiceLight',
+    'Angry',
+    'AutoTransfer',
+    'CloseCard',
+    'Confetti',
+    'ConfettiSuccess',
+    'DashboardChristmasSnow',
+    'DashboardHalloweenBats',
+    'DashboardNewYearShow',
+    'DashboardSidebarBottomChristmas',
+    'DashboardSidebarBottomNewYear',
+    'DashboardSidebarBottomThanksgiving',
+    'DashboardSidebarTopChristmas',
+    'DashboardSidebarTopNewYear',
+    'DashboardSidebarTopThanksgiving',
+    'Distribution',
+    'DistributionDark',
+    'EarnYield',
+    'FastestWayDark',
+    'FastestWayLight',
+    'FinanceTeamDark',
+    'FinanceTeamLight',
+    'Happy',
+    'Liquidity',
+    'LockCard',
+    'MoneyTransferSuccess',
+    'MultiLevelApprovalDark',
+    'MultiLevelApprovalLight',
+    'NotHappy',
+    'Protection',
+    'ReceiptDark',
+    'ReceiptLight',
+    'Recurring',
+    'RecurringDark',
+    'ReimburseDark',
+    'ReimburseLight',
+    'RewardsDark',
+    'RewardsDarkHover',
+    'RewardsLight',
+    'RewardsLightHover',
+    'Ripple',
+    'Secure',
+    'Success',
+    'Target',
+    'TargetDark',
+    'UnlockCard',
+    'VeryHappy',
+    'Welcome',
+    'ZeniAssist',
+];
+const toAnimationsFileName = (v) => (0, stringToUnion_1.stringToUnion)(v, ALL_ANIMATIONS_FILE_NAMES);
+exports.toAnimationsFileName = toAnimationsFileName;

package/lib/commonStateTypes/balance.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonStateTypes/balanceTimeseries.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonStateTypes/bookCloseDateHelper.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIncompleteMonthPresentInTimeframeTick = exports.getTimeframeTickTag = void 0;
+const zeniDayJS_1 = require("../zeniDayJS");
+const getFYQuarterAndYear_1 = require("./fiscalYearHelpers/getFYQuarterAndYear");
+const getTimeframeTickTag = (timeframe, firstMonthOfFY, timeframeTick, bookCloseDate, dataAvailable) => {
+    const bookCloseDateQtr = (0, getFYQuarterAndYear_1.getFYQuarterAndYear)(bookCloseDate, firstMonthOfFY);
+    const periodQtrYear = (0, getFYQuarterAndYear_1.getFYQuarterAndYear)(timeframeTick.startDate, firstMonthOfFY);
+    const lastDayOfEndDateMonth = (0, zeniDayJS_1.date)(new Date(timeframeTick.endDate.year(), timeframeTick.endDate.month() + 1, 0).toDateString());
+    /*
+       timeframe: year
+       Book close date : 31st Dec 2022, Timeframe tick: Start date- 5th Jan 2023 End date - 31st Dec 2023, Data avaialble till 5th Jan
+       lastDayOfEndDateMonth: 31st Dec 2023
+        In this case incomplete tag needs to be shown for 2023 year
+    */
+    if (lastDayOfEndDateMonth.isSame(timeframeTick.endDate, 'day') === false ||
+        dataAvailable.endDate.isSameOrBefore(timeframeTick.endDate, 'day')) {
+        return 'incomplete';
+    }
+    switch (timeframe) {
+        case 'month':
+            return timeframeTick.startDate.isAfter(bookCloseDate, 'day')
+                ? 'under_review'
+                : undefined;
+        case 'quarter':
+            return timeframeTick.endDate.isAfter(bookCloseDate, 'day')
+                ? 'under_review'
+                : undefined;
+        case 'year': {
+            return timeframeTick.endDate.isAfter(bookCloseDate, 'day') &&
+                periodQtrYear.fyYear >= bookCloseDateQtr.fyYear &&
+                dataAvailable.endDate.isAfter(bookCloseDate)
+                ? 'under_review'
+                : undefined;
+        }
+        default:
+            return undefined;
+    }
+};
+exports.getTimeframeTickTag = getTimeframeTickTag;
+const isIncompleteMonthPresentInTimeframeTick = (timeframeTick) => {
+    const lastDayOfEndDateMonth = (0, zeniDayJS_1.date)(new Date(timeframeTick.endDate.year(), timeframeTick.endDate.month() + 1, 0).toDateString());
+    if (lastDayOfEndDateMonth.isSame(timeframeTick.endDate, 'day') === false) {
+        return true;
+    }
+    return false;
+};
+exports.isIncompleteMonthPresentInTimeframeTick = isIncompleteMonthPresentInTimeframeTick;

package/lib/commonStateTypes/bulkOperationType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonStateTypes/cacheOverrideFetchReducer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCacheOverrideFetchReducer = void 0;
+/**
+ * Factory for `fetchXxx` reducers that support Pusher-driven silent refresh.
+ * When `cacheOverride=true`, fetchState and error are left untouched so the
+ * UI doesn't flash a skeleton. When `false`, `applyTo` runs the normal
+ * 'In-Progress' transition.
+ */
+const createCacheOverrideFetchReducer = (applyTo) => ({
+    reducer(draft, action) {
+        if (action.payload.cacheOverride !== true) {
+            applyTo(draft);
+        }
+    },
+    prepare(cacheOverride = false) {
+        return { payload: { cacheOverride } };
+    },
+});
+exports.createCacheOverrideFetchReducer = createCacheOverrideFetchReducer;

package/lib/commonStateTypes/classesView/classMetadataRecords.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonStateTypes/classesView/getNestedClassIDHierarchyForReport.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllClassMetadataRecordsByID = exports.getParentClassId = void 0;
+exports.geNestedClassIDHierarchyForReport = geNestedClassIDHierarchyForReport;
+exports.getNestedClassIDForClass = getNestedClassIDForClass;
+const classPayload_1 = require("../../entity/class/classPayload");
+/**
+ * This function builds the hierarchy which is used to display all classes
+ * in the selection view
+ * @param classesMetadata
+ * @returns
+ */
+function geNestedClassIDHierarchyForReport(classesMetadata) {
+    const parentClasses = [];
+    classesMetadata.forEach((classMeta) => {
+        if (classMeta.isSubclass === false ||
+            // look for its parent in the entire metadata. If not found, then push this also as a rootNode
+            classesMetadata.find((eachClass) => eachClass.classId === classMeta.parentClassId) == null) {
+            parentClasses.push(classMeta);
+        }
+    });
+    const nestedParents = parentClasses.map((parentClass) => {
+        const classId = parentClass.classId;
+        return {
+            classId: [classId],
+            className: parentClass.className,
+            isDeleted: parentClass.isDeleted,
+            qboId: parentClass.qboId,
+            fullyQualifiedAccountingClassName: parentClass.fullyQualifiedAccountingClassName,
+            accountingClassNumber: parentClass.accountingClassNumber,
+            children: getNestedChildren([classId], classesMetadata),
+            hasSiblings: parentClasses.length > 1,
+        };
+    });
+    return nestedParents;
+}
+const getNestedChildren = (parentClass, allClasses) => {
+    const parentId = parentClass[0];
+    const children = allClasses.filter((eachClass) => eachClass.parentClassId === parentId);
+    const nestedChildren = children.map((child) => {
+        const childId = [child.classId, ...parentClass];
+        return {
+            classId: childId,
+            className: child.className,
+            isDeleted: child.isDeleted,
+            qboId: child.qboId,
+            fullyQualifiedAccountingClassName: child.fullyQualifiedAccountingClassName,
+            accountingClassNumber: child.accountingClassNumber,
+            children: getNestedChildren(childId, allClasses),
+            hasSiblings: children.length > 1,
+        };
+    });
+    return nestedChildren;
+};
+/**
+ * Modified this function to remove recursion. The classes metadata will ALWAYS be sorted such that all
+ * parent classes of any will appear before any child class.
+ * @param classId
+ * @param classesMetadata
+ * @returns
+ */
+function getNestedClassIDForClass(classId, classesMetadata) {
+    let nestedClassId = undefined;
+    let toFindClassId = classId;
+    let toFindParentClassId = undefined;
+    for (let index = classesMetadata.length - 1; index >= 0; index--) {
+        if (classesMetadata[index].classId === toFindClassId) {
+            nestedClassId =
+                nestedClassId == null
+                    ? [toFindClassId]
+                    : [...nestedClassId, toFindClassId];
+            toFindParentClassId = classesMetadata[index].parentClassId;
+            if (toFindParentClassId == null) {
+                break;
+            }
+            else {
+                toFindClassId = toFindParentClassId;
+                toFindParentClassId = undefined;
+            }
+        }
+    }
+    if (nestedClassId == null) {
+        throw Error(`Cannot find classId ${classId} in class metadata`);
+    }
+    return nestedClassId;
+}
+const getParentClassId = (classId) => {
+    return classId.length > 1 ? classId.slice(1) : undefined;
+};
+exports.getParentClassId = getParentClassId;
+const getAllClassMetadataRecordsByID = (classesMetadataPayload) => {
+    const classMetadataRecords = {};
+    const classMetadataRecordsPartial = {};
+    const classesMetadata = classesMetadataPayload != null
+        ? classesMetadataPayload.map((classPayload) => {
+            const classMeta = (0, classPayload_1.toClassMetadata)(classPayload);
+            classMetadataRecordsPartial[classMeta.classId] = Object.assign({}, {
+                payload: classPayload,
+                meta: classMeta,
+            });
+            return classMeta;
+        })
+        : [];
+    classesMetadata.forEach((classMeta) => {
+        classMetadataRecords[classMeta.classId] = Object.assign({}, {
+            nestedClassId: getNestedClassIDForClass(classMeta.classId, classesMetadata),
+            classMetadata: classMetadataRecordsPartial[classMeta.classId].meta,
+            classMetadataPayload: classMetadataRecordsPartial[classMeta.classId].payload,
+        });
+    });
+    return classMetadataRecords;
+};
+exports.getAllClassMetadataRecordsByID = getAllClassMetadataRecordsByID;

package/lib/commonStateTypes/classesView/nestedClassID.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNestedClassIDStr = getNestedClassIDStr;
+function getNestedClassIDStr(nestedClassId) {
+    const [classId, parentClassId, greatParentClassId, greatGreatParentClassId, greatGreatGreatParentClassId,] = nestedClassId;
+    return `${classId}-${parentClassId ?? ''}-${greatParentClassId ?? ''}-${greatGreatParentClassId ?? ''}-${greatGreatGreatParentClassId ?? ''}`;
+}

package/lib/commonStateTypes/coaBalance/additionalBalances/getAdditionalBalances.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newAdditionalBalancesOptions = newAdditionalBalancesOptions;
+exports.getAdditionalBalance = getAdditionalBalance;
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const getComparisionBalance_1 = require("./getComparisionBalance");
+const getSamePeriodLastYearBalance_1 = require("./getSamePeriodLastYearBalance");
+const getSummationBalance_1 = require("./getSummationBalance");
+const sliceCOABalances_1 = require("./sliceCOABalances");
+/**
+ * Instantiate a new Additional balances option.
+ * @param isBalanceSheetBalances is balance sheet balances
+ * @param isCashFlowCashAndEquivalents is cash flow CashAndEquivalent balances. one of `opening_balance, closing_balance, closing_minus_opening_balance`
+ * @param cashAndEquivalents set only when `isCashFlowCashAndEquivalents === closing_minus_opening_balance`
+ * @returns
+ */
+function newAdditionalBalancesOptions(isBalanceSheetBalances, isCashFlowCashAndEquivalents = undefined, cashAndEquivalents = undefined) {
+    return {
+        isBalanceSheetBalances,
+        isCashFlowCashAndEquivalents,
+        cashAndEquivalents,
+    };
+}
+/**
+ * Get additional balance of given balance type
+ * @param balanceType balance type
+ * @param resultSlice result slice where the last element represents `thisMonth`
+ * @param resultBalancesOrder order of balances in the result slice.
+ * @param allBalancesOrderedAsc  all balances ordered
+ * @param allMonthlyBalancesOrderedAsc all balances ordered in monthly timeframe
+ * @param options other options to generate additional balances.
+ */
+function getAdditionalBalance(firstMonthOfFY, balanceType, resultSlice, resultFilter, allBalancesOrderedAsc, allMonthlyBalancesOrderedAsc, options) {
+    const resultBalancesOrder = resultFilter.balancesRange.orderBy;
+    switch (balanceType) {
+        case 'same_period_last_year':
+            return (0, getSamePeriodLastYearBalance_1.getSamePeriodLastYearBalance)(resultFilter.timeframe, resultSlice, resultBalancesOrder, allBalancesOrderedAsc);
+        case 'this_period_vs_last_period':
+        case 'this_period_vs_last_period_percent':
+        case 'this_period_vs_same_period_last_year':
+        case 'this_period_vs_same_period_last_year_percent':
+            return (0, getComparisionBalance_1.getComparisionBalance)(balanceType, resultFilter.timeframe, resultSlice, resultBalancesOrder, allBalancesOrderedAsc);
+        case 'year_to_date_total':
+        case 'year_to_date_last_year_total':
+        case 'rolling_12_months':
+        case 'rolling_12_months_average':
+            return (0, getSummationBalance_1.getSummationBalance)(balanceType, firstMonthOfFY, resultFilter.timeframe, resultSlice, resultBalancesOrder, allMonthlyBalancesOrderedAsc, options?.isBalanceSheetBalances ?? false, options?.isCashFlowCashAndEquivalents, {
+                allOpeningMonthlyBalanceOrderedAsc: options?.cashAndEquivalents?.openingBalanceGrouped?.months ?? [],
+                allClosingMonthlyBalanceOrderedAsc: options?.cashAndEquivalents?.closingBalanceGrouped?.months ?? [],
+            });
+        case 'free_range_total':
+            if (options == null ||
+                (options.isBalanceSheetBalances === false &&
+                    options.isBalanceSheetBalances == null)) {
+                return (0, getSummationBalance_1.getSummationFreeRangeTotalBalance)(resultSlice);
+            }
+            else if (options.isBalanceSheetBalances === true) {
+                // Note: for balanceSheet balances, the sum is nothing but the latest balance.
+                let latestBalance = undefined;
+                if (resultSlice.length > 0) {
+                    latestBalance =
+                        resultBalancesOrder === 'ascending_date'
+                            ? resultSlice[resultSlice.length - 1]
+                            : resultSlice[0];
+                }
+                return Object.assign({}, latestBalance, { type: 'free_range_total' });
+            }
+            else if (options.isCashFlowCashAndEquivalents != null) {
+                return cashAndEquivalentsFreeRangeBalances(resultSlice, resultFilter, options.isCashFlowCashAndEquivalents, options.cashAndEquivalents);
+            }
+            else {
+                console.error('Invalid request for free range total');
+                return undefined;
+            }
+        case 'period_total':
+        case 'default':
+        case 'default_with_percent':
+        case 'default_with_null_balance':
+            return undefined;
+    }
+}
+function cashAndEquivalentsFreeRangeBalances(resultSlice, resultFilter, isCashFlowCashAndEquivalents, 
+// This `cashAndEquivalents` is set only when isCashFlowCashAndEquivalents === 'closing_minus_opening_balance'
+cashAndEquivalents) {
+    const resultBalancesOrder = resultFilter.balancesRange.orderBy;
+    switch (isCashFlowCashAndEquivalents) {
+        case 'closing_balance':
+            return (0, getSummationBalance_1.getFreeRangeCashAndEquivalentsClosingBalance)(resultSlice, resultBalancesOrder);
+        case 'opening_balance':
+            return (0, getSummationBalance_1.getFreeRangeCashAndEquivalentsOpeningBalance)(resultSlice, resultBalancesOrder);
+        case 'closing_minus_opening_balance': {
+            if (cashAndEquivalents == null) {
+                console.error("Can't calculate closing_minus_opening_balance without opening & closing balances");
+                return undefined;
+            }
+            const openingBalance = (0, getSummationBalance_1.getFreeRangeCashAndEquivalentsOpeningBalance)(getCOABalancesInTimeframe(cashAndEquivalents.openingBalanceGrouped, resultFilter), resultBalancesOrder);
+            const closingBalance = (0, getSummationBalance_1.getFreeRangeCashAndEquivalentsClosingBalance)(getCOABalancesInTimeframe(cashAndEquivalents.closingBalanceGrouped, resultFilter), resultBalancesOrder);
+            let result = undefined;
+            if (openingBalance != null && closingBalance != null) {
+                result = (0, cloneDeep_1.default)(closingBalance);
+                result.balance.amount =
+                    closingBalance.balance.amount - openingBalance.balance.amount;
+            }
+            return result;
+        }
+    }
+}
+function getCOABalancesInTimeframe(coaBalanceGrouped, filter) {
+    if (coaBalanceGrouped == null) {
+        return [];
+    }
+    let allBalancesInTimeframe = [];
+    switch (filter.timeframe) {
+        case 'week':
+            allBalancesInTimeframe = coaBalanceGrouped.weeks ?? [];
+            break;
+        case 'month':
+            allBalancesInTimeframe = coaBalanceGrouped.months ?? [];
+            break;
+        case 'quarter':
+            allBalancesInTimeframe = coaBalanceGrouped.quarters ?? [];
+            break;
+        case 'year':
+            allBalancesInTimeframe = coaBalanceGrouped.years ?? [];
+            break;
+        case 'free_range':
+            console.error('Querying by free_range is not supported!');
+            break;
+    }
+    const resultBalances = (0, sliceCOABalances_1.sliceCOABalances)(allBalancesInTimeframe, filter.balancesRange);
+    return resultBalances;
+}