@zeniai/client-epic-state 4.14.48 → 4.14.49

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/classesView/getNestedClassIDHierarchyForReport.d.ts

@@ -0,0 +1,21 @@
+import { ClassMetadataPayload } from '../../entity/class/classPayload';
+import { ClassMetadata } from '../../entity/class/classState';
+import { ID } from '../common';
+import { ClassMetadataRecordsByID, NestedClassHierarchyForReport, NestedClassID } from './nestedClassID';
+/**
+ * This function builds the hierarchy which is used to display all classes
+ * in the selection view
+ * @param classesMetadata
+ * @returns
+ */
+export declare function geNestedClassIDHierarchyForReport(classesMetadata: ClassMetadata[]): NestedClassHierarchyForReport[];
+/**
+ * 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
+ */
+export declare function getNestedClassIDForClass(classId: ID, classesMetadata: ClassMetadata[]): NestedClassID;
+export declare const getParentClassId: (classId: NestedClassID) => NestedClassID | undefined;
+export declare const getAllClassMetadataRecordsByID: (classesMetadataPayload: ClassMetadataPayload[]) => ClassMetadataRecordsByID;

package/lib/commonStateTypes/classesView/getNestedClassIDHierarchyForReport.js

@@ -0,0 +1,111 @@
+"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,
+            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,
+            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.d.ts

@@ -0,0 +1,55 @@
+import { ClassMetadataPayload } from '../../entity/class/classPayload';
+import { ClassMetadata } from '../../entity/class/classState';
+import { ID } from '../common';
+type ClassIDPlus0SubClass = [thisClassId: string];
+type ClassIDPlus1SubClass = [thisClassId: string, parentClassId: string];
+type ClassIDPlus2SubClass = [
+    thisClassId: string,
+    parentClassId: string,
+    greatParentClassId: string
+];
+type ClassIDPlus3SubClass = [
+    thisClassId: string,
+    parentClassId: string,
+    greatParentClassId: string,
+    greatGreatParentClassId: string
+];
+type ClassIDPlus4SubClass = [
+    thisClassId: string,
+    parentClassId: string,
+    greatParentClassId: string,
+    greatGreatParentClassId: string,
+    greatGreatGreatParentClassId: string
+];
+/**
+ * Example usage:
+ * Root level class ID = ["thisClassId"]
+ * ID of a class with one parent class, 1 level nesting = ["parentClassId", "thisClassId"];
+ * ID of a class which has a parent and a grand parent, 2 level nesting = ["grandParentClassId", "parentClassId", "thisClassId"]
+ * and so on..
+ */
+export type NestedClassID = ClassIDPlus0SubClass | ClassIDPlus1SubClass | ClassIDPlus2SubClass | ClassIDPlus3SubClass | ClassIDPlus4SubClass;
+export declare function getNestedClassIDStr(nestedClassId: NestedClassID): `${string}-${string}-${string}-${string}-${string}`;
+export interface ClassesViewParentID {
+    sectionId: ID;
+    parentClassId?: NestedClassID;
+}
+export interface NestedClassIDHierarchy {
+    id: NestedClassID;
+    children: NestedClassIDHierarchy[];
+}
+export interface NestedClassHierarchyForReport {
+    classId: NestedClassID;
+    className: string;
+    qboId: ID | undefined;
+    fullyQualifiedAccountingClassName: string;
+    accountingClassNumber: string | undefined;
+    children: NestedClassHierarchyForReport[];
+    hasSiblings: boolean;
+}
+export type ClassMetadataRecordsByID = Record<ID, {
+    nestedClassId: NestedClassID;
+    classMetadata: ClassMetadata;
+    classMetadataPayload: ClassMetadataPayload;
+}>;
+export {};

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 !== null && parentClassId !== void 0 ? parentClassId : ''}-${greatParentClassId !== null && greatParentClassId !== void 0 ? greatParentClassId : ''}-${greatGreatParentClassId !== null && greatGreatParentClassId !== void 0 ? greatGreatParentClassId : ''}-${greatGreatGreatParentClassId !== null && greatGreatGreatParentClassId !== void 0 ? greatGreatGreatParentClassId : ''}`;
+}

package/lib/commonStateTypes/coaBalance/additionalBalances/getAdditionalBalances.d.ts

@@ -0,0 +1,33 @@
+import { Month } from '../../timePeriod';
+import { COABalance, COABalanceGroupedByPeriod } from '../coaBalance';
+import { COABalanceType } from '../coaBalanceType';
+import { COABalancesFilter } from '../coaBalancesFilter';
+export interface AdditionalBalancesOptions {
+    isBalanceSheetBalances: boolean;
+    isCashFlowCashAndEquivalents?: 'opening_balance' | 'closing_balance' | 'closing_minus_opening_balance';
+    cashAndEquivalents?: {
+        openingBalanceGrouped?: COABalanceGroupedByPeriod;
+        closingBalanceGrouped?: COABalanceGroupedByPeriod;
+    };
+}
+/**
+ * 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
+ */
+export declare function newAdditionalBalancesOptions(isBalanceSheetBalances: boolean, isCashFlowCashAndEquivalents?: 'opening_balance' | 'closing_balance' | 'closing_minus_opening_balance' | undefined, cashAndEquivalents?: {
+    openingBalanceGrouped?: COABalanceGroupedByPeriod;
+    closingBalanceGrouped?: COABalanceGroupedByPeriod;
+} | undefined): AdditionalBalancesOptions;
+/**
+ * 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.
+ */
+export declare function getAdditionalBalance(firstMonthOfFY: Month, balanceType: COABalanceType, resultSlice: COABalance[], resultFilter: COABalancesFilter, allBalancesOrderedAsc: COABalance[], allMonthlyBalancesOrderedAsc: COABalance[], options?: AdditionalBalancesOptions): COABalance | undefined;

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

@@ -0,0 +1,137 @@
+"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) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    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, (_a = options === null || options === void 0 ? void 0 : options.isBalanceSheetBalances) !== null && _a !== void 0 ? _a : false, options === null || options === void 0 ? void 0 : options.isCashFlowCashAndEquivalents, {
+                allOpeningMonthlyBalanceOrderedAsc: (_d = (_c = (_b = options === null || options === void 0 ? void 0 : options.cashAndEquivalents) === null || _b === void 0 ? void 0 : _b.openingBalanceGrouped) === null || _c === void 0 ? void 0 : _c.months) !== null && _d !== void 0 ? _d : [],
+                allClosingMonthlyBalanceOrderedAsc: (_g = (_f = (_e = options === null || options === void 0 ? void 0 : options.cashAndEquivalents) === null || _e === void 0 ? void 0 : _e.closingBalanceGrouped) === null || _f === void 0 ? void 0 : _f.months) !== null && _g !== void 0 ? _g : [],
+            });
+        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) {
+    var _a, _b, _c, _d;
+    if (coaBalanceGrouped == null) {
+        return [];
+    }
+    let allBalancesInTimeframe = [];
+    switch (filter.timeframe) {
+        case 'week':
+            allBalancesInTimeframe = (_a = coaBalanceGrouped.weeks) !== null && _a !== void 0 ? _a : [];
+            break;
+        case 'month':
+            allBalancesInTimeframe = (_b = coaBalanceGrouped.months) !== null && _b !== void 0 ? _b : [];
+            break;
+        case 'quarter':
+            allBalancesInTimeframe = (_c = coaBalanceGrouped.quarters) !== null && _c !== void 0 ? _c : [];
+            break;
+        case 'year':
+            allBalancesInTimeframe = (_d = coaBalanceGrouped.years) !== null && _d !== void 0 ? _d : [];
+            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;
+}

package/lib/commonStateTypes/coaBalance/additionalBalances/getComparisionBalance.d.ts

@@ -0,0 +1,3 @@
+import { COABalance, COABalanceTimeFrame, COABalanceWithPercent } from '../coaBalance';
+import { COABalancesOrder } from '../coaBalancesFilter';
+export declare function getComparisionBalance(comparisionType: 'this_period_vs_last_period' | 'this_period_vs_last_period_percent' | 'this_period_vs_same_period_last_year' | 'this_period_vs_same_period_last_year_percent', timeframe: COABalanceTimeFrame, resultSlice: COABalance[], resultBalancesOrder: COABalancesOrder, allBalancesOrderedAsc: COABalance[]): COABalanceWithPercent | undefined;

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComparisionBalance = getComparisionBalance;
+const getSamePeriodLastYearBalance_1 = require("./getSamePeriodLastYearBalance");
+function getComparisionBalance(comparisionType, timeframe, resultSlice, resultBalancesOrder, allBalancesOrderedAsc) {
+    if (allBalancesOrderedAsc.length === 0 || resultSlice.length === 0) {
+        return undefined;
+    }
+    switch (comparisionType) {
+        case 'this_period_vs_last_period':
+        case 'this_period_vs_last_period_percent':
+            if (resultSlice.length >= 2) {
+                const currentPeriod = resultBalancesOrder === 'ascending_date'
+                    ? resultSlice[resultSlice.length - 1]
+                    : resultSlice[0];
+                const lastPeriod = resultBalancesOrder === 'ascending_date'
+                    ? resultSlice[resultSlice.length - 2]
+                    : resultSlice[1];
+                return getBalancesDiff(currentPeriod, lastPeriod, comparisionType);
+            }
+            break;
+        case 'this_period_vs_same_period_last_year':
+        case 'this_period_vs_same_period_last_year_percent':
+            {
+                const currentPeriod = resultBalancesOrder === 'ascending_date'
+                    ? resultSlice[resultSlice.length - 1]
+                    : resultSlice[0];
+                const samePeriodLY = (0, getSamePeriodLastYearBalance_1.getSamePeriodLastYearBalance)(timeframe, resultSlice, resultBalancesOrder, allBalancesOrderedAsc);
+                if (samePeriodLY != null) {
+                    return getBalancesDiff(currentPeriod, samePeriodLY, comparisionType);
+                }
+            }
+            break;
+    }
+    return undefined;
+}
+function getBalancesDiff(thisPeriodBalance, lastPeriodBalance, type) {
+    const balancesDiff = thisPeriodBalance.balance.amount - lastPeriodBalance.balance.amount;
+    let balancesDiffInPercent = undefined;
+    if (lastPeriodBalance.balance.amount !== 0 &&
+        !isNaN(lastPeriodBalance.balance.amount)) {
+        balancesDiffInPercent =
+            balancesDiff / Math.abs(lastPeriodBalance.balance.amount);
+    }
+    const comparisonTotalAmount = getComparisonTotalAmount(thisPeriodBalance, lastPeriodBalance);
+    const comparisonForecastTotalAmount = getComparisonTotalForecastAmount(thisPeriodBalance, lastPeriodBalance);
+    const resultBalance = Object.assign({}, thisPeriodBalance, {
+        type: type,
+        balanceTimeFrame: 'free_range',
+        balance: Object.assign({}, thisPeriodBalance.balance, {
+            amount: balancesDiff,
+        }),
+        percentValue: balancesDiffInPercent,
+        label: '',
+        totalBalance: comparisonTotalAmount.totalBalanceDiff,
+        totalForecast: comparisonForecastTotalAmount.totalBalanceDiff,
+        forecastPercentValue: comparisonForecastTotalAmount.totalPercentDiff,
+        totalPercentValue: comparisonTotalAmount.totalPercentDiff,
+    });
+    return resultBalance;
+}
+function getComparisonTotalAmount(thisPeriodBalanceWithTotal, lastPeriodBalanceWithTotal) {
+    let thisBalanceAmount = undefined;
+    let lastBalanceAmount = undefined;
+    if ((thisPeriodBalanceWithTotal === null || thisPeriodBalanceWithTotal === void 0 ? void 0 : thisPeriodBalanceWithTotal.totalBalance) != null &&
+        (lastPeriodBalanceWithTotal === null || lastPeriodBalanceWithTotal === void 0 ? void 0 : lastPeriodBalanceWithTotal.totalBalance) != null) {
+        thisBalanceAmount = thisPeriodBalanceWithTotal.totalBalance;
+        lastBalanceAmount = lastPeriodBalanceWithTotal.totalBalance;
+    }
+    else if ((thisPeriodBalanceWithTotal === null || thisPeriodBalanceWithTotal === void 0 ? void 0 : thisPeriodBalanceWithTotal.totalBalance) != null &&
+        (lastPeriodBalanceWithTotal === null || lastPeriodBalanceWithTotal === void 0 ? void 0 : lastPeriodBalanceWithTotal.totalBalance) == null) {
+        thisBalanceAmount = thisPeriodBalanceWithTotal.totalBalance;
+        lastBalanceAmount = Object.assign(Object.assign({}, thisBalanceAmount), { amount: 0 });
+    }
+    else if ((thisPeriodBalanceWithTotal === null || thisPeriodBalanceWithTotal === void 0 ? void 0 : thisPeriodBalanceWithTotal.totalBalance) == null &&
+        (lastPeriodBalanceWithTotal === null || lastPeriodBalanceWithTotal === void 0 ? void 0 : lastPeriodBalanceWithTotal.totalBalance) != null) {
+        lastBalanceAmount = lastPeriodBalanceWithTotal.totalBalance;
+        thisBalanceAmount = Object.assign(Object.assign({}, lastBalanceAmount), { amount: 0 });
+    }
+    if (thisBalanceAmount != null && lastBalanceAmount != null) {
+        const { amountDiff, amountDiffInPercent } = getAmountDiffAndPercentDiff(thisBalanceAmount, lastBalanceAmount);
+        return {
+            totalBalanceDiff: amountDiff,
+            totalPercentDiff: amountDiffInPercent,
+        };
+    }
+    else {
+        return {
+            totalBalanceDiff: undefined,
+            totalPercentDiff: undefined,
+        };
+    }
+}
+function getComparisonTotalForecastAmount(thisPeriodBalanceWithTotal, lastPeriodBalanceWithTotal) {
+    let thisBalanceAmount = undefined;
+    let lastBalanceAmount = undefined;
+    if ((thisPeriodBalanceWithTotal === null || thisPeriodBalanceWithTotal === void 0 ? void 0 : thisPeriodBalanceWithTotal.totalForecast) != null &&
+        (lastPeriodBalanceWithTotal === null || lastPeriodBalanceWithTotal === void 0 ? void 0 : lastPeriodBalanceWithTotal.totalForecast) != null) {
+        thisBalanceAmount = thisPeriodBalanceWithTotal.totalForecast;
+        lastBalanceAmount = lastPeriodBalanceWithTotal.totalForecast;
+    }
+    else if ((thisPeriodBalanceWithTotal === null || thisPeriodBalanceWithTotal === void 0 ? void 0 : thisPeriodBalanceWithTotal.totalForecast) != null &&
+        (lastPeriodBalanceWithTotal === null || lastPeriodBalanceWithTotal === void 0 ? void 0 : lastPeriodBalanceWithTotal.totalForecast) == null) {
+        thisBalanceAmount = thisPeriodBalanceWithTotal.totalForecast;
+        lastBalanceAmount = Object.assign(Object.assign({}, thisBalanceAmount), { amount: 0 });
+    }
+    else if ((thisPeriodBalanceWithTotal === null || thisPeriodBalanceWithTotal === void 0 ? void 0 : thisPeriodBalanceWithTotal.totalForecast) == null &&
+        (lastPeriodBalanceWithTotal === null || lastPeriodBalanceWithTotal === void 0 ? void 0 : lastPeriodBalanceWithTotal.totalForecast) != null) {
+        lastBalanceAmount = lastPeriodBalanceWithTotal.totalForecast;
+        thisBalanceAmount = Object.assign(Object.assign({}, lastBalanceAmount), { amount: 0 });
+    }
+    if (thisBalanceAmount != null && lastBalanceAmount != null) {
+        const { amountDiff, amountDiffInPercent } = getAmountDiffAndPercentDiff(thisBalanceAmount, lastBalanceAmount);
+        return {
+            totalBalanceDiff: amountDiff,
+            totalPercentDiff: amountDiffInPercent,
+        };
+    }
+    else {
+        return {
+            totalBalanceDiff: undefined,
+            totalPercentDiff: undefined,
+        };
+    }
+}
+function getAmountDiffAndPercentDiff(thisPeriodAmount, lastPeriodAmount) {
+    const amountDiff = thisPeriodAmount.amount - lastPeriodAmount.amount;
+    let amountDiffInPercent = undefined;
+    if (lastPeriodAmount.amount !== 0 && !isNaN(lastPeriodAmount.amount)) {
+        amountDiffInPercent = amountDiff / Math.abs(lastPeriodAmount.amount);
+    }
+    return {
+        amountDiff: Object.assign(Object.assign({}, thisPeriodAmount), { amount: amountDiff }),
+        amountDiffInPercent,
+    };
+}

package/lib/commonStateTypes/coaBalance/additionalBalances/getSamePeriodLastYearBalance.d.ts

@@ -0,0 +1,6 @@
+import { Month } from '../../timePeriod';
+import { TimeframeTick } from '../../timeframeTick';
+import { COABalance, COABalanceTimeFrame } from '../coaBalance';
+import { COABalancesOrder } from '../coaBalancesFilter';
+export declare function getSamePeriodLastYearBalance(timeframe: COABalanceTimeFrame, resultSlice: COABalance[], resultBalanceOrder: COABalancesOrder, allBalancesOrderedAsc: COABalance[]): COABalance | undefined;
+export declare function getThisPeriodForLastYear(firstMonthOfFY: Month, thisPeriod: TimeframeTick, timeframe: COABalanceTimeFrame): TimeframeTick;

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

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamePeriodLastYearBalance = getSamePeriodLastYearBalance;
+exports.getThisPeriodForLastYear = getThisPeriodForLastYear;
+const findLastIndex_1 = __importDefault(require("lodash/findLastIndex"));
+const getStartOfAndEndOfTimeframeFY_1 = require("../../fiscalYearHelpers/getStartOfAndEndOfTimeframeFY");
+function getSamePeriodLastYearBalance(timeframe, resultSlice, resultBalanceOrder, allBalancesOrderedAsc) {
+    if (allBalancesOrderedAsc.length === 0 || resultSlice.length === 0) {
+        return undefined;
+    }
+    const thisPeriod = resultBalanceOrder === 'ascending_date'
+        ? resultSlice[resultSlice.length - 1]
+        : resultSlice[0];
+    let startDateLY = undefined;
+    let endDateLY = undefined;
+    switch (timeframe) {
+        case 'month':
+        case 'quarter':
+        case 'year':
+            {
+                startDateLY = thisPeriod.startDate
+                    .subtract(1, 'year')
+                    .startOf(timeframe);
+                endDateLY = startDateLY.endOf(timeframe);
+            }
+            break;
+        default:
+            console.error(`timeframe ${timeframe} is not supported for getSamePeriodLastYearBalance`);
+            break;
+    }
+    if (startDateLY != null && endDateLY != null) {
+        const lastYearBalanceIndex = (0, findLastIndex_1.default)(allBalancesOrderedAsc, (value) => value.startDate.isSame(startDateLY, 'day') && // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            value.endDate.isSame(endDateLY, 'day') // eslint-disable-line @typescript-eslint/no-non-null-assertion
+        );
+        return lastYearBalanceIndex != -1
+            ? allBalancesOrderedAsc[lastYearBalanceIndex]
+            : undefined;
+    }
+    else {
+        return undefined;
+    }
+}
+function getThisPeriodForLastYear(firstMonthOfFY, thisPeriod, timeframe) {
+    let startDateLY = undefined;
+    let endDateLY = undefined;
+    switch (timeframe) {
+        case 'month':
+        case 'quarter':
+        case 'year':
+            {
+                const { startOfTimeframeFY } = (0, getStartOfAndEndOfTimeframeFY_1.getStartOfAndEndOfTimeframeForFY)(thisPeriod.startDate.subtract(1, 'year'), firstMonthOfFY, timeframe);
+                startDateLY = startOfTimeframeFY;
+                endDateLY = thisPeriod.endDate.subtract(1, 'year').endOf('month');
+            }
+            break;
+        case 'week':
+        case 'free_range':
+            {
+                console.warn('Be carefull!! getThisPeriodLastYear for week or free_range is not intended');
+                startDateLY = thisPeriod.startDate.subtract(1, 'year');
+                endDateLY = thisPeriod.endDate.subtract(1, 'year');
+            }
+            break;
+    }
+    return { startDate: startDateLY, endDate: endDateLY };
+}

package/lib/commonStateTypes/coaBalance/additionalBalances/getSummationBalance.d.ts

@@ -0,0 +1,18 @@
+import { Month } from '../../timePeriod';
+import { COABalance, COABalanceTimeFrame } from '../coaBalance';
+import { COABalancesOrder } from '../coaBalancesFilter';
+/**
+ * Get summation balance
+ * @param summationType summation type
+ * @param resultSlice  result slice
+ * @param allMonthlyBalancesOrderedAsc all montly balances in ascending order
+ * @param isBalanceSheetBalances is this a balance sheet balance. Note that for balance sheet balances, the sum is nothing but the latest period balance.
+ * @returns
+ */
+export declare function getSummationBalance(summationType: 'year_to_date_total' | 'year_to_date_last_year_total' | 'rolling_12_months' | 'rolling_12_months_average', firstMonthOfFY: Month, timeframe: COABalanceTimeFrame, resultSlice: COABalance[], resultBalancesOrder: COABalancesOrder, allMonthlyBalancesOrderedAsc: COABalance[], isBalanceSheetBalances: boolean, isCashFlowCashAndEquivalents?: 'opening_balance' | 'closing_balance' | 'closing_minus_opening_balance', cashAndEquivalents?: {
+    allOpeningMonthlyBalanceOrderedAsc: COABalance[];
+    allClosingMonthlyBalanceOrderedAsc: COABalance[];
+} | undefined): COABalance | undefined;
+export declare function getSummationFreeRangeTotalBalance(resultSlice: COABalance[]): COABalance | undefined;
+export declare function getFreeRangeCashAndEquivalentsOpeningBalance(resultSlice: COABalance[], resultBalancesOrder: COABalancesOrder): COABalance | undefined;
+export declare function getFreeRangeCashAndEquivalentsClosingBalance(resultSlice: COABalance[], resultBalancesOrder: COABalancesOrder): COABalance | undefined;