@zeniai/client-epic-state 4.9.30 → 4.9.31

package/lib/commonPayloadTypes/v2/getSumOfBalancesGroupedByPeriod.d.ts

@@ -0,0 +1,8 @@
+import { COABalanceGroupedByPeriodPayloadV2 } from './coaBalancePayload';
+/**
+ * Given an array of COABalanceGroupedByPeriodPayload, this function will add all balances
+ * across timeframes for every balance
+ * @param coaBalancesByPeriodPayloadArray
+ * @returns
+ */
+export declare const getSumOfBalancesByGroupedByPeriodPayload: (coaBalancesByPeriodPayloadArray: COABalanceGroupedByPeriodPayloadV2[]) => COABalanceGroupedByPeriodPayloadV2 | undefined;

package/lib/commonPayloadTypes/v2/getSumOfBalancesGroupedByPeriod.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSumOfBalancesByGroupedByPeriodPayload = void 0;
+/**
+ * Given an array of COABalanceGroupedByPeriodPayload, this function will add all balances
+ * across timeframes for every balance
+ * @param coaBalancesByPeriodPayloadArray
+ * @returns
+ */
+const getSumOfBalancesByGroupedByPeriodPayload = (coaBalancesByPeriodPayloadArray) => {
+    if (coaBalancesByPeriodPayloadArray.length <= 0) {
+        return undefined;
+    }
+    const coaBalancesArrayPayloadByPeriodPayload = extractCOABalancesArrayByPeriodPayload(coaBalancesByPeriodPayloadArray);
+    const resultCOABalanceGroupedByPeriodPayload = {
+        weeks: getSumForCOABalancesPayload(coaBalancesArrayPayloadByPeriodPayload.weeks),
+        months: getSumForCOABalancesPayload(coaBalancesArrayPayloadByPeriodPayload.months),
+        quarters: getSumForCOABalancesPayload(coaBalancesArrayPayloadByPeriodPayload.quarters),
+        years: getSumForCOABalancesPayload(coaBalancesArrayPayloadByPeriodPayload.years),
+    };
+    return resultCOABalanceGroupedByPeriodPayload;
+};
+exports.getSumOfBalancesByGroupedByPeriodPayload = getSumOfBalancesByGroupedByPeriodPayload;
+const extractCOABalancesArrayByPeriodPayload = (coaBalancesPeriodPayloadArray) => {
+    const allBalancesPayloadInWeeks = [];
+    const allBalancesPayloadInMonths = [];
+    const allBalancesPayloadInQuarters = [];
+    const allBalancesPayloadInYears = [];
+    coaBalancesPeriodPayloadArray.forEach((coaBalanceGroupedPaylod) => {
+        if (coaBalanceGroupedPaylod.weeks != null &&
+            coaBalanceGroupedPaylod.weeks.length !== 0) {
+            allBalancesPayloadInWeeks.push(coaBalanceGroupedPaylod.weeks);
+        }
+        if (coaBalanceGroupedPaylod.months != null &&
+            coaBalanceGroupedPaylod.months.length !== 0) {
+            allBalancesPayloadInMonths.push(coaBalanceGroupedPaylod.months);
+        }
+        if (coaBalanceGroupedPaylod.quarters != null &&
+            coaBalanceGroupedPaylod.quarters.length !== 0) {
+            allBalancesPayloadInQuarters.push(coaBalanceGroupedPaylod.quarters);
+        }
+        if (coaBalanceGroupedPaylod.years != null &&
+            coaBalanceGroupedPaylod.years.length !== 0) {
+            allBalancesPayloadInYears.push(coaBalanceGroupedPaylod.years);
+        }
+    });
+    return {
+        weeks: allBalancesPayloadInWeeks,
+        months: allBalancesPayloadInMonths,
+        quarters: allBalancesPayloadInQuarters,
+        years: allBalancesPayloadInYears,
+    };
+};
+const getSumForCOABalancesPayload = (coaBalancesArrayPayload) => {
+    var _a;
+    if (coaBalancesArrayPayload.length <= 0) {
+        return undefined;
+    }
+    if (coaBalancesArrayPayload.length === 1) {
+        return coaBalancesArrayPayload[0];
+    }
+    const balancesLength = coaBalancesArrayPayload[0].length;
+    const totalBalances = coaBalancesArrayPayload.length;
+    const resultBalances = [];
+    for (let index = 1; index < totalBalances; index++) {
+        if (coaBalancesArrayPayload[index].length !== balancesLength) {
+            throw Error('Cannot calculate sum of balances with different lengths');
+        }
+    }
+    for (let dateIndex = 0; dateIndex < balancesLength; dateIndex++) {
+        let sumAmount = 0;
+        for (let totalIndex = 0; totalIndex < totalBalances; totalIndex++) {
+            sumAmount +=
+                (_a = coaBalancesArrayPayload[totalIndex][dateIndex].amount.value) !== null && _a !== void 0 ? _a : 0;
+        }
+        const resultBalance = Object.assign({}, coaBalancesArrayPayload[0][dateIndex], {
+            balance: Object.assign({}, coaBalancesArrayPayload[0][dateIndex].amount, {
+                value: sumAmount,
+            }),
+        });
+        resultBalances.push(resultBalance);
+    }
+    return resultBalances;
+};

package/lib/commonStateTypes/bookCloseDateHelper.d.ts

@@ -0,0 +1,8 @@
+import { ZeniDate } from '../zeniDayJS';
+import { COABalanceTimeFrame } from './coaBalance/coaBalance';
+import { DataAvailable } from './dataAvailable';
+import { TimeframeTick } from './timeframeTick';
+import { Month } from './timePeriod';
+export declare type TimeFrameTickTag = 'under_review' | 'incomplete' | undefined;
+export declare const getTimeframeTickTag: (timeframe: COABalanceTimeFrame, firstMonthOfFY: Month, timeframeTick: TimeframeTick, bookCloseDate: ZeniDate, dataAvailable: DataAvailable) => TimeFrameTickTag;
+export declare const isIncompleteMonthPresentInTimeframeTick: (timeframeTick: TimeframeTick) => boolean;

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/coaBalance/classBalances/getDifferenceOfBalancesGroupedByPeriod.d.ts

@@ -0,0 +1,8 @@
+import { COABalanceGroupedByPeriod } from '../coaBalance';
+/**
+ *
+ * @param coaBalanceSlices Given a set of balance slices, this function will extract all balances for the same period
+ * across each slice and sum them up
+ * @returns
+ */
+export declare const getDifferenceOfBalancesGroupedByPeriod: (groupedBalancesA: COABalanceGroupedByPeriod | undefined, groupedBalancesB: COABalanceGroupedByPeriod | undefined) => COABalanceGroupedByPeriod;

package/lib/commonStateTypes/coaBalance/classBalances/getDifferenceOfBalancesGroupedByPeriod.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDifferenceOfBalancesGroupedByPeriod = void 0;
+/**
+ *
+ * @param coaBalanceSlices Given a set of balance slices, this function will extract all balances for the same period
+ * across each slice and sum them up
+ * @returns
+ */
+const getDifferenceOfBalancesGroupedByPeriod = (groupedBalancesA, groupedBalancesB) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (groupedBalancesA == null && groupedBalancesB == null) {
+        return {};
+    }
+    const resultCOABalanceGroupedByPeriod = {
+        weeks: getDifferenceOfCOABalances((_a = groupedBalancesA === null || groupedBalancesA === void 0 ? void 0 : groupedBalancesA.weeks) !== null && _a !== void 0 ? _a : [], (_b = groupedBalancesB === null || groupedBalancesB === void 0 ? void 0 : groupedBalancesB.weeks) !== null && _b !== void 0 ? _b : []),
+        months: getDifferenceOfCOABalances((_c = groupedBalancesA === null || groupedBalancesA === void 0 ? void 0 : groupedBalancesA.months) !== null && _c !== void 0 ? _c : [], (_d = groupedBalancesB === null || groupedBalancesB === void 0 ? void 0 : groupedBalancesB.months) !== null && _d !== void 0 ? _d : []),
+        quarters: getDifferenceOfCOABalances((_e = groupedBalancesA === null || groupedBalancesA === void 0 ? void 0 : groupedBalancesA.quarters) !== null && _e !== void 0 ? _e : [], (_f = groupedBalancesB === null || groupedBalancesB === void 0 ? void 0 : groupedBalancesB.quarters) !== null && _f !== void 0 ? _f : []),
+        years: getDifferenceOfCOABalances((_g = groupedBalancesA === null || groupedBalancesA === void 0 ? void 0 : groupedBalancesA.years) !== null && _g !== void 0 ? _g : [], (_h = groupedBalancesB === null || groupedBalancesB === void 0 ? void 0 : groupedBalancesB.years) !== null && _h !== void 0 ? _h : []),
+    };
+    return resultCOABalanceGroupedByPeriod;
+};
+exports.getDifferenceOfBalancesGroupedByPeriod = getDifferenceOfBalancesGroupedByPeriod;
+const getDifferenceOfCOABalances = (balancesA, balancesB) => {
+    if (balancesB.length === 0 && balancesA.length > 0) {
+        return balancesA;
+    }
+    else if (balancesA.length === 0 && balancesB.length > 0) {
+        // return a negation of BalancesB
+        return balancesB.map((balanceB) => {
+            return Object.assign({}, balanceB, {
+                balance: Object.assign({}, balanceB.balance, {
+                    amount: 0 - balanceB.balance.amount,
+                }),
+                label: '',
+            });
+        });
+    }
+    if (balancesB.length !== balancesA.length) {
+        throw Error('Cannot calculate difference of balances with different lengths');
+    }
+    const balanceDifference = balancesA.map((balanceA, index) => {
+        let newBalance = Object.assign({}, balanceA);
+        const balanceToSubtract = balancesB[index];
+        if (balanceToSubtract != null) {
+            const balancesDiff = balanceA.balance.amount - balanceToSubtract.balance.amount;
+            const percentValue = balancesDiff && balanceA.balance.amount != 0
+                ? balancesDiff / balanceA.balance.amount
+                : 0;
+            newBalance = Object.assign({}, balanceA, {
+                balance: Object.assign({}, balanceA.balance, {
+                    amount: balancesDiff,
+                }),
+                label: '',
+                type: 'default_with_percent',
+                percentValue,
+            });
+        }
+        return newBalance;
+    });
+    return balanceDifference;
+};

package/lib/commonStateTypes/currencyHelper.d.ts

@@ -0,0 +1 @@
+export declare const isUsdCurrency: (currencyCode: string) => boolean;

package/lib/commonStateTypes/currencyHelper.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUsdCurrency = void 0;
+const isUsdCurrency = (currencyCode) => {
+    return currencyCode === 'USD';
+};
+exports.isUsdCurrency = isUsdCurrency;

package/lib/commonStateTypes/fileType.d.ts

@@ -0,0 +1,3 @@
+export declare const ALL_FILE_TYPES: readonly ["pdf", "excel"];
+export declare const toFileTypeStrict: (v?: string | undefined) => "excel" | "pdf" | undefined;
+export declare type FileType = NonNullable<ReturnType<typeof toFileTypeStrict>>;

package/lib/commonStateTypes/fileType.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toFileTypeStrict = exports.ALL_FILE_TYPES = void 0;
+const stringToUnion_1 = require("./stringToUnion");
+exports.ALL_FILE_TYPES = ['pdf', 'excel'];
+const toFileTypeStrict = (v) => { var _a; return (0, stringToUnion_1.stringToUnionStrict)((_a = v === null || v === void 0 ? void 0 : v.toLocaleLowerCase()) !== null && _a !== void 0 ? _a : '', exports.ALL_FILE_TYPES); };
+exports.toFileTypeStrict = toFileTypeStrict;

package/lib/commonStateTypes/fiscalYearHelpers/getActualPeriod.d.ts

@@ -0,0 +1,4 @@
+import { TimeframeTick } from '../timeframeTick';
+import { Month, Quarter } from '../timePeriod';
+export declare function getActualPeriodOfFYQtr(firstMonthOfFY: Month, fyQuarter: Quarter, fyYear: number): TimeframeTick;
+export declare function getActualPeriodOfFY(firstMonthOfFY: Month, fyYear: number): TimeframeTick;

package/lib/commonStateTypes/fiscalYearHelpers/getActualPeriod.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActualPeriodOfFY = exports.getActualPeriodOfFYQtr = void 0;
+const zeniDayJS_1 = require("../../zeniDayJS");
+const getFYMonths_1 = require("./getFYMonths");
+const getStartOfAndEndOfTimeframeFY_1 = require("./getStartOfAndEndOfTimeframeFY");
+function getActualPeriodOfFYQtr(firstMonthOfFY, fyQuarter, fyYear) {
+    const { fiscalYearMonths, fiscalYearMonthsYearOffset } = (0, getFYMonths_1.getFYMonths)(firstMonthOfFY);
+    const startMonthIndex = (fyQuarter - 1) * getFYMonths_1.NUM_OF_MONTHS_IN_QTR;
+    const year = fyYear - fiscalYearMonthsYearOffset[startMonthIndex];
+    const startMonth = fiscalYearMonths[startMonthIndex];
+    const startDate = (0, zeniDayJS_1.dateNow)()
+        .set('year', year)
+        .set('month', startMonth - 1) /** In ZeniDate months are [0-11] */
+        .startOf('month');
+    const { endOfTimeframeFY: endDate } = (0, getStartOfAndEndOfTimeframeFY_1.getStartOfAndEndOfTimeframeForFY)(startDate, firstMonthOfFY, 'quarter');
+    return {
+        startDate,
+        endDate,
+    };
+}
+exports.getActualPeriodOfFYQtr = getActualPeriodOfFYQtr;
+function getActualPeriodOfFY(firstMonthOfFY, fyYear) {
+    const { fiscalYearMonths } = (0, getFYMonths_1.getFYMonths)(firstMonthOfFY);
+    const startDate = (0, zeniDayJS_1.dateNow)()
+        .set('year', firstMonthOfFY === 1 ? fyYear : fyYear - 1)
+        .set('month', fiscalYearMonths[0] - 1) /** In ZeniDate months are [0-11] */
+        .startOf('month');
+    const endDate = (0, zeniDayJS_1.dateNow)()
+        .set('year', fyYear)
+        .set('month', fiscalYearMonths[11] - 1) /** In ZeniDate months are [0-11] */
+        .endOf('month');
+    return {
+        startDate,
+        endDate,
+    };
+}
+exports.getActualPeriodOfFY = getActualPeriodOfFY;

package/lib/commonStateTypes/selectorTypes/pickAndMergeForecastSection.d.ts

@@ -0,0 +1,2 @@
+import { Section } from './selectorTypes';
+export declare function pickAndMergeForecastSection(sectionA: Section, sectionF: Section): Section;

package/lib/commonStateTypes/selectorTypes/pickAndMergeForecastSection.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickAndMergeForecastSection = void 0;
+const pickAndMergeForecastAccountReport_1 = require("../../entity/account/pickAndMergeForecastAccountReport");
+const pickAndMergeForecastAcGroupReport_1 = require("../../entity/accountGroup/pickAndMergeForecastAcGroupReport");
+const pickAndMergeForecast_1 = require("../coaBalance/pickAndMergeForecast");
+function pickAndMergeForecastSection(sectionA, sectionF) {
+    const resultSection = Object.assign({}, sectionA, (0, pickAndMergeForecast_1.pickAndMergeForecast)(sectionA, sectionF));
+    resultSection.accountsOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(sectionA.accountsOrdered, sectionF.accountsOrdered);
+    resultSection.accountGroupsOrdered = (0, pickAndMergeForecastAcGroupReport_1.pickAndMergeForecastAccountGroups)(sectionA.accountGroupsOrdered, sectionF.accountGroupsOrdered);
+    return resultSection;
+}
+exports.pickAndMergeForecastSection = pickAndMergeForecastSection;

package/lib/commonStateTypes/selectorTypes/pickAndMergeForecastSectionWithAcOnly.d.ts

@@ -0,0 +1,2 @@
+import { SectionWithAccountOnly } from './selectorTypes';
+export declare function pickAndMergeForecastSectionWithAcOnly(sectionA: SectionWithAccountOnly, sectionF: SectionWithAccountOnly): SectionWithAccountOnly;

package/lib/commonStateTypes/selectorTypes/pickAndMergeForecastSectionWithAcOnly.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickAndMergeForecastSectionWithAcOnly = void 0;
+const pickAndMergeForecast_1 = require("../coaBalance/pickAndMergeForecast");
+const pickAndMergeForecastAccountReport_1 = require("../../entity/account/pickAndMergeForecastAccountReport");
+function pickAndMergeForecastSectionWithAcOnly(sectionA, sectionF) {
+    const resultSection = Object.assign({}, sectionA, (0, pickAndMergeForecast_1.pickAndMergeForecast)(sectionA, sectionF));
+    resultSection.accountsOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(sectionA.accountsOrdered, sectionF.accountsOrdered);
+    return resultSection;
+}
+exports.pickAndMergeForecastSectionWithAcOnly = pickAndMergeForecastSectionWithAcOnly;

package/lib/commonStateTypes/viewAndReport/reportIDHelper.d.ts

@@ -0,0 +1,8 @@
+import { ReportIDPlusForecastID } from './viewAndReport';
+export declare const isPAndLReport: (reportId: ReportIDPlusForecastID) => boolean;
+export declare const isPAndLClassesViewReport: (reportId: ReportIDPlusForecastID) => boolean;
+export declare const isDashboardReport: (reportId: ReportIDPlusForecastID) => boolean;
+export declare const isDashboardClassesViewReport: (reportId: ReportIDPlusForecastID) => boolean;
+export declare const isCashFlowOrBalanceSheetReport: (reportId: ReportIDPlusForecastID) => boolean;
+export declare const isAgingReport: (reportId: ReportIDPlusForecastID) => boolean;
+export declare const isOpExByVendorReport: (reportId: ReportIDPlusForecastID) => boolean;

package/lib/commonStateTypes/viewAndReport/reportIDHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOpExByVendorReport = exports.isAgingReport = exports.isCashFlowOrBalanceSheetReport = exports.isDashboardClassesViewReport = exports.isDashboardReport = exports.isPAndLClassesViewReport = exports.isPAndLReport = void 0;
+const isPAndLReport = (reportId) => reportId.startsWith('profit_and_loss');
+exports.isPAndLReport = isPAndLReport;
+const isPAndLClassesViewReport = (reportId) => reportId.startsWith('profit_and_loss_by_classes');
+exports.isPAndLClassesViewReport = isPAndLClassesViewReport;
+const isDashboardReport = (reportId) => {
+    const ids = reportId.split('+');
+    const report = ids[0];
+    switch (report) {
+        case 'net_burn_or_income':
+        case 'net_burn_or_income_story_card':
+        case 'operating_expenses':
+        case 'cash_in_cash_out':
+        case 'revenue':
+        case 'cash_position':
+            return true;
+    }
+    return false;
+};
+exports.isDashboardReport = isDashboardReport;
+const isDashboardClassesViewReport = (reportId) => {
+    const ids = reportId.split('+');
+    const report = ids[0];
+    switch (report) {
+        case 'net_burn_or_income_by_classes':
+        case 'operating_expenses_by_classes':
+        case 'revenue_by_classes':
+            return true;
+    }
+    return false;
+};
+exports.isDashboardClassesViewReport = isDashboardClassesViewReport;
+const isCashFlowOrBalanceSheetReport = (reportId) => reportId.startsWith('cash_flow') || reportId.startsWith('balance_sheet');
+exports.isCashFlowOrBalanceSheetReport = isCashFlowOrBalanceSheetReport;
+const isAgingReport = (reportId) => {
+    return (reportId === 'accounts_payable_aging' ||
+        reportId === 'accounts_receivable_aging');
+};
+exports.isAgingReport = isAgingReport;
+const isOpExByVendorReport = (reportId) => reportId.startsWith('operating_expenses_by_vendor');
+exports.isOpExByVendorReport = isOpExByVendorReport;

package/lib/configureStore.d.ts

@@ -0,0 +1,9 @@
+import { Store } from 'redux';
+import { RootState } from './reducer';
+import { ZeniAPI } from './zeniAPI';
+declare global {
+    interface Window {
+        __REDUX_DEVTOOLS_EXTENSION_COMPOSE__: Function;
+    }
+}
+export default function configureNewStore(zeniAPI: ZeniAPI, includeReduxDevTools?: boolean): Store<RootState>;

package/lib/configureStore.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redux_1 = require("redux");
+const redux_observable_1 = require("redux-observable");
+const epic_1 = __importDefault(require("./epic"));
+const reducer_1 = __importDefault(require("./reducer"));
+let epicMiddleware;
+function configureNewStore(zeniAPI, includeReduxDevTools = false) {
+    epicMiddleware = (0, redux_observable_1.createEpicMiddleware)({ dependencies: zeniAPI });
+    const composeEnhancers = includeReduxDevTools &&
+        typeof window === 'object' &&
+        window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ != null
+        ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
+        // Specify extension’s options like name, actionsBlacklist, actionsCreators, serialize...
+        })
+        : redux_1.compose;
+    const store = (0, redux_1.createStore)(reducer_1.default, composeEnhancers((0, redux_1.applyMiddleware)(epicMiddleware)));
+    epicMiddleware.run(epic_1.default);
+    return store;
+}
+exports.default = configureNewStore;

package/lib/entity/accountGroup/pickAndMergeForecastAcGroupReport.d.ts

@@ -0,0 +1,3 @@
+import { AccountGroupReport } from './accountGroupSelector';
+export declare function pickAndMergeForecastAcGroupReport(reportA: AccountGroupReport, reportF: AccountGroupReport): AccountGroupReport;
+export declare function pickAndMergeForecastAccountGroups(acGroupsA: AccountGroupReport[], acGroupsF: AccountGroupReport[]): AccountGroupReport[];

package/lib/entity/accountGroup/pickAndMergeForecastAcGroupReport.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickAndMergeForecastAccountGroups = exports.pickAndMergeForecastAcGroupReport = void 0;
+const differenceBy_1 = __importDefault(require("lodash/differenceBy"));
+const pickAndMergeForecast_1 = require("../../commonStateTypes/coaBalance/pickAndMergeForecast");
+const pickAndMergeForecastAccountReport_1 = require("../account/pickAndMergeForecastAccountReport");
+function pickAndMergeForecastAcGroupReport(reportA, reportF) {
+    const reportResult = Object.assign({}, reportA);
+    reportResult.accountsWithExpensesOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithExpensesOrdered, reportF.accountsWithExpensesOrdered);
+    reportResult.expensesInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.expensesInTimeframe, reportF.expensesInTimeframe);
+    reportResult.accountsWithIncomeOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithIncomeOrdered, reportF.accountsWithIncomeOrdered);
+    reportResult.incomeInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.incomeInTimeframe, reportF.incomeInTimeframe);
+    reportResult.accountsWithCogsOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithCogsOrdered, reportF.accountsWithCogsOrdered);
+    reportResult.cogsInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.cogsInTimeframe, reportF.cogsInTimeframe);
+    reportResult.accountsWithCashInOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithCashInOrdered, reportF.accountsWithCashInOrdered);
+    reportResult.cashInInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.cashInInTimeframe, reportF.cashInInTimeframe);
+    reportResult.accountsWithCashOutOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithCashOutOrdered, reportF.accountsWithCashOutOrdered);
+    reportResult.cashOutInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.cashOutInTimeframe, reportF.cashOutInTimeframe);
+    reportResult.accountsWithEquityOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithEquityOrdered, reportF.accountsWithEquityOrdered);
+    reportResult.equityInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.equityInTimeframe, reportF.equityInTimeframe);
+    reportResult.accountsWithAssetsOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithAssetsOrdered, reportF.accountsWithAssetsOrdered);
+    reportResult.assetsInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.assetsInTimeframe, reportF.assetsInTimeframe);
+    reportResult.accountsWithLiabilitiesOrdered = (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithLiabilitiesOrdered, reportF.accountsWithLiabilitiesOrdered);
+    reportResult.liabilitiesInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.liabilitiesInTimeframe, reportF.liabilitiesInTimeframe);
+    reportResult.accountsWithOperatingActivitiesOrdered =
+        (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithOperatingActivitiesOrdered, reportF.accountsWithOperatingActivitiesOrdered);
+    reportResult.operatingActivitiesInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.operatingActivitiesInTimeframe, reportF.operatingActivitiesInTimeframe);
+    reportResult.accountsWithInvestingActivitiesOrdered =
+        (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithInvestingActivitiesOrdered, reportF.accountsWithInvestingActivitiesOrdered);
+    reportResult.investingActivitiesInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.investingActivitiesInTimeframe, reportF.investingActivitiesInTimeframe);
+    reportResult.accountsWithFinancingActivitiesOrdered =
+        (0, pickAndMergeForecastAccountReport_1.pickAndMergeForecastAccounts)(reportA.accountsWithFinancingActivitiesOrdered, reportF.accountsWithFinancingActivitiesOrdered);
+    reportResult.financingActivitiesInTimeframe = (0, pickAndMergeForecast_1.pickAndMergeForecast)(reportA.financingActivitiesInTimeframe, reportF.financingActivitiesInTimeframe);
+    return reportResult;
+}
+exports.pickAndMergeForecastAcGroupReport = pickAndMergeForecastAcGroupReport;
+function pickAndMergeForecastAccountGroups(acGroupsA, acGroupsF) {
+    const resultAcGroups = [];
+    const forecastOnlyAcGroups = (0, differenceBy_1.default)(acGroupsF, acGroupsA, 'accountGroupId');
+    const zeroActualsAcGroup = forecastOnlyAcGroups.map((acGroup) => cloneAccountGroupWithZeroBalance(acGroup));
+    const targetAcGroupsA = [...acGroupsA, ...zeroActualsAcGroup];
+    targetAcGroupsA.forEach((acGroupA) => {
+        const matchingAcGroupF = acGroupsF.find((acGroupF) => acGroupF.accountGroupId === acGroupA.accountGroupId);
+        if (matchingAcGroupF != null) {
+            resultAcGroups.push(pickAndMergeForecastAcGroupReport(acGroupA, matchingAcGroupF));
+        }
+        else {
+            resultAcGroups.push(acGroupA);
+        }
+    });
+    return resultAcGroups;
+}
+exports.pickAndMergeForecastAccountGroups = pickAndMergeForecastAccountGroups;
+function cloneAccountGroupWithZeroBalance(acGroup) {
+    const clonedAcGroup = Object.assign({}, acGroup); //Note: Just shallow copy is enough because the balances are clonedDeep.
+    clonedAcGroup.accountsWithExpensesOrdered = (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithExpensesOrdered);
+    clonedAcGroup.expensesInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.expensesInTimeframe);
+    clonedAcGroup.accountsWithIncomeOrdered = (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithIncomeOrdered);
+    clonedAcGroup.incomeInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.incomeInTimeframe);
+    clonedAcGroup.accountsWithCogsOrdered = (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithCogsOrdered);
+    clonedAcGroup.cogsInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.cogsInTimeframe);
+    clonedAcGroup.accountsWithCashInOrdered = (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithCashInOrdered);
+    clonedAcGroup.cashInInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.cashInInTimeframe);
+    clonedAcGroup.accountsWithCashOutOrdered = (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithCashOutOrdered);
+    clonedAcGroup.cashOutInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.cashOutInTimeframe);
+    clonedAcGroup.accountsWithEquityOrdered = (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithEquityOrdered);
+    clonedAcGroup.equityInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.equityInTimeframe);
+    clonedAcGroup.accountsWithAssetsOrdered = (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithAssetsOrdered);
+    clonedAcGroup.assetsInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.assetsInTimeframe);
+    clonedAcGroup.accountsWithLiabilitiesOrdered = (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithLiabilitiesOrdered);
+    clonedAcGroup.liabilitiesInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.liabilitiesInTimeframe);
+    clonedAcGroup.accountsWithOperatingActivitiesOrdered =
+        (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithOperatingActivitiesOrdered);
+    clonedAcGroup.operatingActivitiesInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.operatingActivitiesInTimeframe);
+    clonedAcGroup.accountsWithInvestingActivitiesOrdered =
+        (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithInvestingActivitiesOrdered);
+    clonedAcGroup.investingActivitiesInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.investingActivitiesInTimeframe);
+    clonedAcGroup.accountsWithFinancingActivitiesOrdered =
+        (0, pickAndMergeForecastAccountReport_1.cloneAccountsWithZeroBalance)(clonedAcGroup.accountsWithFinancingActivitiesOrdered);
+    clonedAcGroup.financingActivitiesInTimeframe = (0, pickAndMergeForecast_1.cloneAndResetBalanceSlice)(clonedAcGroup.financingActivitiesInTimeframe);
+    return clonedAcGroup;
+}

package/lib/entity/chargeCard/chargeCardSelector.d.ts

@@ -0,0 +1,4 @@
+import { ID } from '../../commonStateTypes/common';
+import { ChargeCardState, ChargeCard } from './chargeCard';
+export declare function getChargeCardsByIds(chargeCardState: ChargeCardState, chargeCardIds: ID[]): ChargeCard[];
+export declare function getChargeCardById(chargeCardState: ChargeCardState, chargeCardId: ID): ChargeCard | undefined;

package/lib/entity/chargeCard/chargeCardSelector.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChargeCardById = exports.getChargeCardsByIds = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+function getChargeCardsByIds(chargeCardState, chargeCardIds) {
+    const chargeCards = chargeCardIds
+        .map((cardId) => getChargeCardById(chargeCardState, cardId))
+        .filter((value) => value != null);
+    return chargeCards;
+}
+exports.getChargeCardsByIds = getChargeCardsByIds;
+function getChargeCardById(chargeCardState, chargeCardId) {
+    return (0, get_1.default)(chargeCardState.chargeCardByID, chargeCardId, undefined);
+}
+exports.getChargeCardById = getChargeCardById;

package/lib/entity/chargeCardTransaction/chargeCardTransactionSelector.d.ts

@@ -0,0 +1,4 @@
+import { ID } from '../../commonStateTypes/common';
+import { ChargeCardTransactionState, ChargeCardTransaction } from './chargeCardTransaction';
+export declare function getChargeCardTransactionsByIds(chargeCardTransactionState: ChargeCardTransactionState, chargeCardTransIds: ID[]): ChargeCardTransaction[];
+export declare function getChargeCardTransactionById(chargeCardTransactionState: ChargeCardTransactionState, chargeCardTransId: ID): ChargeCardTransaction | undefined;

package/lib/entity/chargeCardTransaction/chargeCardTransactionSelector.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChargeCardTransactionById = exports.getChargeCardTransactionsByIds = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+function getChargeCardTransactionsByIds(chargeCardTransactionState, chargeCardTransIds) {
+    const chargeCardTransactions = chargeCardTransIds
+        .map((tranId) => getChargeCardTransactionById(chargeCardTransactionState, tranId))
+        .filter((value) => value != null);
+    return chargeCardTransactions;
+}
+exports.getChargeCardTransactionsByIds = getChargeCardTransactionsByIds;
+function getChargeCardTransactionById(chargeCardTransactionState, chargeCardTransId) {
+    return (0, get_1.default)(chargeCardTransactionState.chargeCardTransactionById, chargeCardTransId, undefined);
+}
+exports.getChargeCardTransactionById = getChargeCardTransactionById;

package/lib/entity/company/companyHelper.d.ts

@@ -0,0 +1,5 @@
+import { ID } from '../../commonStateTypes/common';
+import { User } from '../user/userState';
+export declare const getControllersEmails: (controllers: User[]) => string[];
+export declare const getFirstControllerEmail: (controllers: User[]) => string[];
+export declare const getFirstControllerId: (controllerUserIds: ID[]) => ID[];

package/lib/entity/company/companyHelper.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFirstControllerId = exports.getFirstControllerEmail = exports.getControllersEmails = void 0;
+const getControllersEmails = (controllers) => {
+    return controllers
+        .map((controller) => controller.email)
+        .filter((email) => Boolean(email));
+};
+exports.getControllersEmails = getControllersEmails;
+const getFirstControllerEmail = (controllers) => {
+    const controllerEmail = (0, exports.getControllersEmails)(controllers);
+    if (controllerEmail.length === 0) {
+        return [];
+    }
+    const firstControllerEmail = controllerEmail[0];
+    return [firstControllerEmail];
+};
+exports.getFirstControllerEmail = getFirstControllerEmail;
+const getFirstControllerId = (controllerUserIds) => {
+    if (controllerUserIds.length === 0) {
+        return [];
+    }
+    const firstControllerId = controllerUserIds[0];
+    return [firstControllerId];
+};
+exports.getFirstControllerId = getFirstControllerId;

package/lib/entity/companyHealthMetric/companyHealthMetricSelector.d.ts

@@ -0,0 +1,4 @@
+import { ID } from '../../commonStateTypes/common';
+import { CompanyHealthMetric, CompanyHealthState } from './companyHealthMetricState';
+export declare function getCompanyHealthMetricByCompanyId(companyHealthState: CompanyHealthState, companyId: ID): CompanyHealthMetric | undefined;
+export declare function getCompanyHealthMetricByCompanyIds(companyHealthState: CompanyHealthState, companyIds: ID[]): CompanyHealthMetric[];

package/lib/entity/companyHealthMetric/companyHealthMetricSelector.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompanyHealthMetricByCompanyIds = exports.getCompanyHealthMetricByCompanyId = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+function getCompanyHealthMetricByCompanyId(companyHealthState, companyId) {
+    return (0, get_1.default)(companyHealthState.companyHealthStateByCompanyId, companyId, undefined);
+}
+exports.getCompanyHealthMetricByCompanyId = getCompanyHealthMetricByCompanyId;
+function getCompanyHealthMetricByCompanyIds(companyHealthState, companyIds) {
+    const companiesHealthMetrics = companyIds
+        .map((Id) => getCompanyHealthMetricByCompanyId(companyHealthState, Id))
+        .filter((value) => value != null);
+    return companiesHealthMetrics;
+}
+exports.getCompanyHealthMetricByCompanyIds = getCompanyHealthMetricByCompanyIds;