sec-edgar-api 0.0.1

package/build/services/ReportParser/ReportTranslatedProxy.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var _ReportTranslatedProxy = /** @class */ (function () {
+    function _ReportTranslatedProxy(report) {
+        this.changedKeys = new Set();
+        var reportKeys = new Set(Object.keys(report));
+        return new Proxy(this, {
+            // when accessing property of report, return the value of the report instead of the wrapper
+            get: function (target, key, receiver) {
+                return reportKeys.has(String(key)) ? Reflect.get(report, key) : Reflect.get(target, key, receiver);
+            },
+            // record changed properties
+            set: function (target, key, value, receiver) {
+                if (reportKeys.has(String(key))) {
+                    target.changedKeys.add(String(key));
+                    return Reflect.set(report, key, value);
+                }
+                return Reflect.set(target, key, value, receiver);
+            },
+            // makes Object.keys return report keys
+            ownKeys: function () {
+                return Reflect.ownKeys(report);
+            },
+            getOwnPropertyDescriptor: function (target, key) {
+                return reportKeys.has(String(key))
+                    ? Reflect.getOwnPropertyDescriptor(report, key)
+                    : Reflect.getOwnPropertyDescriptor(target, key);
+            },
+        });
+    }
+    _ReportTranslatedProxy.prototype.getChangedKeys = function () {
+        return Array.from(this.changedKeys);
+    };
+    return _ReportTranslatedProxy;
+}());
+/**
+ * Used to make ReportWrapper implement ReportTranslated interface via proxy
+ */
+var ReportTranslatedProxy = _ReportTranslatedProxy;
+exports.default = ReportTranslatedProxy;

package/build/services/ReportParser/ReportWrapper.d.ts

@@ -0,0 +1,27 @@
+import { FiscalPeriod, ReportRaw, ReportTranslated } from '../../types';
+import ReportTranslatedProxy from './ReportTranslatedProxy';
+/**
+ * Contains translated report and raw report with methods to access other reports
+ */
+export default class ReportWrapper extends ReportTranslatedProxy implements ReportTranslated {
+    private readonly report;
+    private readonly reportMap;
+    private readonly reportRaw;
+    constructor(report: ReportTranslated, reportRaw?: ReportRaw, reportMap?: Map<string, ReportWrapper>);
+    /**
+     * when using JSON.stringify on this class instance, it will stringify the report
+     */
+    toJSON(): ReportTranslated;
+    getReportRaw(): ReportRaw;
+    getReport(): ReportTranslated;
+    /**
+     * Gets report wrapper for prev or future report
+     *
+     * @param offset positive number returns future report, negative returns past
+     */
+    getReportOffset(offset: number, reportType: 'QUARTERLY' | 'ANNUAL'): ReportWrapper | null;
+    /**
+     * Gets report wrappers in the same fiscal year as this report
+     */
+    getReportsFiscalYearByPeriod(fiscalYear?: number): Record<FiscalPeriod, ReportWrapper | null>;
+}

package/build/services/ReportParser/ReportWrapper.js

@@ -0,0 +1,89 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ReportTranslatedProxy_1 = require("./ReportTranslatedProxy");
+/**
+ * Contains translated report and raw report with methods to access other reports
+ */
+var ReportWrapper = /** @class */ (function (_super) {
+    __extends(ReportWrapper, _super);
+    function ReportWrapper(report, reportRaw, reportMap) {
+        var _this = this;
+        var _a;
+        _this = _super.call(this, report) || this;
+        _this.report = report;
+        _this.reportMap = reportMap !== null && reportMap !== void 0 ? reportMap : new Map();
+        _this.reportRaw = reportRaw !== null && reportRaw !== void 0 ? reportRaw : {
+            dateFiled: report.dateFiled,
+            dateReport: report.dateReport,
+            form: report.form,
+            isTTM: report.isTTM,
+            frame: '',
+            taxonomy: '',
+            reportType: report.isTTM ? 'ANNUAL' : 'QUARTERLY',
+            fiscalPeriod: (_a = report.fiscalPeriod) !== null && _a !== void 0 ? _a : '',
+            fiscalYear: report.fiscalYear,
+        };
+        return _this;
+    }
+    /**
+     * when using JSON.stringify on this class instance, it will stringify the report
+     */
+    ReportWrapper.prototype.toJSON = function () {
+        return this.report;
+    };
+    ReportWrapper.prototype.getReportRaw = function () {
+        return this.reportRaw;
+    };
+    ReportWrapper.prototype.getReport = function () {
+        return this.report;
+    };
+    /**
+     * Gets report wrapper for prev or future report
+     *
+     * @param offset positive number returns future report, negative returns past
+     */
+    ReportWrapper.prototype.getReportOffset = function (offset, reportType) {
+        var _a, _b;
+        var _c = this.report, fiscalPeriod = _c.fiscalPeriod, fiscalYear = _c.fiscalYear;
+        if (reportType === 'ANNUAL') {
+            return (_a = this.reportMap.get("".concat(fiscalYear + offset, "_FY"))) !== null && _a !== void 0 ? _a : null;
+        }
+        var period = fiscalPeriod === 'FY' ? 'Q4' : fiscalPeriod;
+        var currentQuarter = Number(period.substring(1));
+        var isCeilOffsetYear = currentQuarter + (offset % 4) > 4 || (offset < 0 && currentQuarter + (offset % 4) > 0);
+        var targetYear = isCeilOffsetYear ? fiscalYear + Math.ceil(offset / 4) : fiscalYear + Math.floor(offset / 4);
+        var targetQuarter = Math.abs(currentQuarter + offset < 0 ? ((currentQuarter + offset) % 4) + 4 : (currentQuarter + offset) % 4 || 4);
+        return (_b = this.reportMap.get("".concat(targetYear, "_Q").concat(targetQuarter))) !== null && _b !== void 0 ? _b : null;
+    };
+    /**
+     * Gets report wrappers in the same fiscal year as this report
+     */
+    ReportWrapper.prototype.getReportsFiscalYearByPeriod = function (fiscalYear) {
+        var _a, _b, _c, _d, _e;
+        if (fiscalYear === void 0) { fiscalYear = this.report.fiscalYear; }
+        return {
+            FY: (_a = this.reportMap.get("".concat(fiscalYear, "_FY"))) !== null && _a !== void 0 ? _a : null,
+            Q1: (_b = this.reportMap.get("".concat(fiscalYear, "_Q1"))) !== null && _b !== void 0 ? _b : null,
+            Q2: (_c = this.reportMap.get("".concat(fiscalYear, "_Q2"))) !== null && _c !== void 0 ? _c : null,
+            Q3: (_d = this.reportMap.get("".concat(fiscalYear, "_Q3"))) !== null && _d !== void 0 ? _d : null,
+            Q4: (_e = this.reportMap.get("".concat(fiscalYear, "_Q4"))) !== null && _e !== void 0 ? _e : null,
+        };
+    };
+    return ReportWrapper;
+}(ReportTranslatedProxy_1.default));
+exports.default = ReportWrapper;

package/build/services/ReportParser/index.d.ts

@@ -0,0 +1,2 @@
+import ReportParser from './ReportParser';
+export default ReportParser;

package/build/services/ReportParser/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ReportParser_1 = require("./ReportParser");
+exports.default = ReportParser_1.default;

package/build/services/ReportParser/resolvers/helpers.d.ts

@@ -0,0 +1,21 @@
+import { ReportTranslated } from '../../../types';
+interface SplitValueBetweenReportsParams {
+    key: keyof ReportTranslated;
+    value: number;
+    reports: ReportTranslated[];
+    roundToPlaces: number;
+}
+export type ExcludeNulls<T> = {
+    [K in keyof T]: Exclude<T[K], null>;
+};
+export declare function getSingleNullKey<T>(obj: T): keyof T | null;
+export declare function round(num: number, places: number): number;
+/**
+ * returns the number of places the number is rounded to
+ */
+export declare function getRoundToPlaces(num: number): 1 | 1000000 | 1000;
+/**
+ * distributes a value between each report evenly, and rounds to the nearest roundToPlaces. gives remainder to last report
+ */
+export declare function splitValueBetweenReports(params: SplitValueBetweenReportsParams): void;
+export {};

package/build/services/ReportParser/resolvers/helpers.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitValueBetweenReports = exports.getRoundToPlaces = exports.round = exports.getSingleNullKey = void 0;
+function getSingleNullKey(obj) {
+    var singleNullKey = null;
+    for (var key in obj) {
+        if (obj[key] !== null)
+            continue;
+        if (singleNullKey === null)
+            singleNullKey = key;
+        else
+            return null;
+    }
+    return singleNullKey;
+}
+exports.getSingleNullKey = getSingleNullKey;
+function round(num, places) {
+    return Math.round(num / places) * places;
+}
+exports.round = round;
+/**
+ * returns the number of places the number is rounded to
+ */
+function getRoundToPlaces(num) {
+    if (num.toString().endsWith('000000'))
+        return 1000000;
+    if (num.toString().endsWith('000'))
+        return 1000;
+    return 1;
+}
+exports.getRoundToPlaces = getRoundToPlaces;
+/**
+ * distributes a value between each report evenly, and rounds to the nearest roundToPlaces. gives remainder to last report
+ */
+function splitValueBetweenReports(params) {
+    var _a;
+    var key = params.key, value = params.value, roundToPlaces = params.roundToPlaces;
+    var reports = params.reports;
+    var remainder = ((value / roundToPlaces) % reports.length) * roundToPlaces;
+    var valueToDistribute = (value - remainder) / reports.length;
+    reports.forEach(function (report) {
+        var _a;
+        var diffAdded = round(((_a = report[key]) !== null && _a !== void 0 ? _a : 0) + valueToDistribute, roundToPlaces);
+        report[key] = diffAdded;
+    });
+    var reportLast = reports[reports.length - 1];
+    reportLast[key] = ((_a = reportLast[key]) !== null && _a !== void 0 ? _a : 0) + remainder;
+}
+exports.splitValueBetweenReports = splitValueBetweenReports;

package/build/services/ReportParser/resolvers/index.d.ts

@@ -0,0 +1,31 @@
+import { resolveAssetCurrent } from './resolve-asset-current';
+import { resolveAssetNonCurrentPPEGross } from './resolve-asset-non-current-ppe-gross';
+import { resolveCashFlowCapex } from './resolve-cash-flow-capex';
+import { resolveCashFlowFree } from './resolve-cash-flow-free';
+import { resolveCashFlowOperating } from './resolve-cash-flow-operating';
+import { resolveCashFlowWorkingCapitalNonCash } from './resolve-cash-flow-working-capital-non-cash';
+import { resolveEbit } from './resolve-ebit';
+import { resolveExpenseDepreciation } from './resolve-expense-depreciation';
+import { resolveExpenseOperating } from './resolve-expense-operating';
+import { resolveExpenseTotal } from './resolve-expense-total';
+import { resolveFiscalYearCumulativeProperties } from './resolve-fiscal-year-cumulative-properties';
+import { resolveLiabilityCurrent } from './resolve-liability-current';
+import { resolveQ4FiscalYearMatchingProperties } from './resolve-q4-fiscal-year-matching-properties';
+import { resolveRevenueTotal } from './resolve-revenue-total';
+declare const resolvers: {
+    resolveAssetNonCurrentPPEGross: typeof resolveAssetNonCurrentPPEGross;
+    resolveExpenseDepreciation: typeof resolveExpenseDepreciation;
+    resolveExpenseOperating: typeof resolveExpenseOperating;
+    resolveCashFlowFree: typeof resolveCashFlowFree;
+    resolveEbit: typeof resolveEbit;
+    resolveAssetCurrent: typeof resolveAssetCurrent;
+    resolveCashFlowCapex: typeof resolveCashFlowCapex;
+    resolveFiscalYearCumulativeProperties: typeof resolveFiscalYearCumulativeProperties;
+    resolveRevenueTotal: typeof resolveRevenueTotal;
+    resolveExpenseTotal: typeof resolveExpenseTotal;
+    resolveCashFlowOperating: typeof resolveCashFlowOperating;
+    resolveLiabilityCurrent: typeof resolveLiabilityCurrent;
+    resolveQ4FiscalYearMatchingProperties: typeof resolveQ4FiscalYearMatchingProperties;
+    resolveCashFlowWorkingCapitalNonCash: typeof resolveCashFlowWorkingCapitalNonCash;
+};
+export default resolvers;

package/build/services/ReportParser/resolvers/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var resolve_asset_current_1 = require("./resolve-asset-current");
+var resolve_asset_non_current_ppe_gross_1 = require("./resolve-asset-non-current-ppe-gross");
+var resolve_cash_flow_capex_1 = require("./resolve-cash-flow-capex");
+var resolve_cash_flow_free_1 = require("./resolve-cash-flow-free");
+var resolve_cash_flow_operating_1 = require("./resolve-cash-flow-operating");
+var resolve_cash_flow_working_capital_non_cash_1 = require("./resolve-cash-flow-working-capital-non-cash");
+var resolve_ebit_1 = require("./resolve-ebit");
+var resolve_expense_depreciation_1 = require("./resolve-expense-depreciation");
+var resolve_expense_operating_1 = require("./resolve-expense-operating");
+var resolve_expense_total_1 = require("./resolve-expense-total");
+var resolve_fiscal_year_cumulative_properties_1 = require("./resolve-fiscal-year-cumulative-properties");
+var resolve_liability_current_1 = require("./resolve-liability-current");
+var resolve_q4_fiscal_year_matching_properties_1 = require("./resolve-q4-fiscal-year-matching-properties");
+var resolve_revenue_total_1 = require("./resolve-revenue-total");
+var resolvers = {
+    resolveAssetNonCurrentPPEGross: resolve_asset_non_current_ppe_gross_1.resolveAssetNonCurrentPPEGross,
+    resolveExpenseDepreciation: resolve_expense_depreciation_1.resolveExpenseDepreciation,
+    resolveExpenseOperating: resolve_expense_operating_1.resolveExpenseOperating,
+    resolveCashFlowFree: resolve_cash_flow_free_1.resolveCashFlowFree,
+    resolveEbit: resolve_ebit_1.resolveEbit,
+    resolveAssetCurrent: resolve_asset_current_1.resolveAssetCurrent,
+    resolveCashFlowCapex: resolve_cash_flow_capex_1.resolveCashFlowCapex,
+    resolveFiscalYearCumulativeProperties: resolve_fiscal_year_cumulative_properties_1.resolveFiscalYearCumulativeProperties,
+    resolveRevenueTotal: resolve_revenue_total_1.resolveRevenueTotal,
+    resolveExpenseTotal: resolve_expense_total_1.resolveExpenseTotal,
+    resolveCashFlowOperating: resolve_cash_flow_operating_1.resolveCashFlowOperating,
+    resolveLiabilityCurrent: resolve_liability_current_1.resolveLiabilityCurrent,
+    resolveQ4FiscalYearMatchingProperties: resolve_q4_fiscal_year_matching_properties_1.resolveQ4FiscalYearMatchingProperties,
+    resolveCashFlowWorkingCapitalNonCash: resolve_cash_flow_working_capital_non_cash_1.resolveCashFlowWorkingCapitalNonCash,
+};
+exports.default = resolvers;

package/build/services/ReportParser/resolvers/resolve-asset-current.d.ts

@@ -0,0 +1,2 @@
+import ReportWrapper from '../ReportWrapper';
+export declare function resolveAssetCurrent(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-asset-current.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAssetCurrent = void 0;
+var helpers_1 = require("./helpers");
+function resolveAssetCurrent(report) {
+    var _a = report, assetCurrent = _a.assetCurrent, assetNonCurrent = _a.assetNonCurrent, assetTotal = _a.assetTotal;
+    var nullKey = (0, helpers_1.getSingleNullKey)({ assetCurrent: assetCurrent, assetNonCurrent: assetNonCurrent, assetTotal: assetTotal });
+    switch (nullKey) {
+        case 'assetCurrent':
+            report.assetCurrent = assetTotal - assetNonCurrent;
+            break;
+        case 'assetNonCurrent':
+            report.assetNonCurrent = assetTotal - assetCurrent;
+            break;
+        case 'assetTotal':
+            report.assetTotal = assetCurrent + assetNonCurrent;
+            break;
+    }
+}
+exports.resolveAssetCurrent = resolveAssetCurrent;

package/build/services/ReportParser/resolvers/resolve-asset-non-current-ppe-gross.d.ts

@@ -0,0 +1,2 @@
+import ReportWrapper from '../ReportWrapper';
+export declare function resolveAssetNonCurrentPPEGross(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-asset-non-current-ppe-gross.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAssetNonCurrentPPEGross = void 0;
+var helpers_1 = require("./helpers");
+function resolveAssetNonCurrentPPEGross(report) {
+    var _a = report, expenseDepreciationAccumulated = _a.expenseDepreciationAccumulated, assetNonCurrentPPEGross = _a.assetNonCurrentPPEGross, assetNonCurrentPPENet = _a.assetNonCurrentPPENet;
+    var nullKey = (0, helpers_1.getSingleNullKey)({ expenseDepreciationAccumulated: expenseDepreciationAccumulated, assetNonCurrentPPEGross: assetNonCurrentPPEGross, assetNonCurrentPPENet: assetNonCurrentPPENet });
+    switch (nullKey) {
+        case 'assetNonCurrentPPEGross':
+            report.assetNonCurrentPPEGross = assetNonCurrentPPENet + expenseDepreciationAccumulated;
+            break;
+        case 'assetNonCurrentPPENet':
+            report.assetNonCurrentPPENet = assetNonCurrentPPEGross - expenseDepreciationAccumulated;
+            break;
+        case 'expenseDepreciationAccumulated':
+            report.expenseDepreciationAccumulated = assetNonCurrentPPEGross - assetNonCurrentPPENet;
+            break;
+    }
+}
+exports.resolveAssetNonCurrentPPEGross = resolveAssetNonCurrentPPEGross;

package/build/services/ReportParser/resolvers/resolve-cash-flow-capex.d.ts

@@ -0,0 +1,5 @@
+import ReportWrapper from '../ReportWrapper';
+/**
+ * This only an estimate. splits remaining capex between quarters if FY has capex, or adds quarterly capex if Quarters have it
+ */
+export declare function resolveCashFlowCapex(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-cash-flow-capex.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCashFlowCapex = void 0;
+var helpers_1 = require("./helpers");
+/**
+ * This only an estimate. splits remaining capex between quarters if FY has capex, or adds quarterly capex if Quarters have it
+ */
+function resolveCashFlowCapex(report) {
+    var _a, _b, _c;
+    if (report.fiscalYear !== 2022 || report.cashFlowCapex !== null)
+        return;
+    var reportPrev = report.getReportOffset(-1, report.isTTM ? 'ANNUAL' : 'QUARTERLY');
+    var _d = report.getReportsFiscalYearByPeriod(), FY = _d.FY, Q1 = _d.Q1, Q2 = _d.Q2, Q3 = _d.Q3, Q4 = _d.Q4;
+    if (FY === null) {
+        report.cashFlowCapex = (_a = reportPrev === null || reportPrev === void 0 ? void 0 : reportPrev.cashFlowCapex) !== null && _a !== void 0 ? _a : null;
+        return;
+    }
+    var sumQuarters = [Q1, Q2, Q3, Q4].reduce(function (sum, rep) { var _a; return sum + ((_a = rep === null || rep === void 0 ? void 0 : rep.cashFlowCapex) !== null && _a !== void 0 ? _a : 0); }, 0);
+    var reportsQuarterlyWithoutCapex = [Q1, Q2, Q3, Q4].filter(function (rep) { return rep && rep.cashFlowCapex === null; });
+    if (report.isTTM) {
+        if (reportsQuarterlyWithoutCapex.length === 0)
+            report.cashFlowCapex = sumQuarters;
+        return;
+    }
+    var reportTTMOrPrev = (_c = (_b = report.getReportOffset(0, 'ANNUAL')) !== null && _b !== void 0 ? _b : report.getReportOffset(-1, 'ANNUAL')) !== null && _c !== void 0 ? _c : report.getReportOffset(-1, 'QUARTERLY');
+    var roundToPlaces = (0, helpers_1.getRoundToPlaces)(Number(reportTTMOrPrev === null || reportTTMOrPrev === void 0 ? void 0 : reportTTMOrPrev.cashFlowCapex));
+    var cashFlowCapexFY = FY.cashFlowCapex;
+    if (cashFlowCapexFY !== null) {
+        (0, helpers_1.splitValueBetweenReports)({
+            key: 'cashFlowCapex',
+            reports: reportsQuarterlyWithoutCapex,
+            roundToPlaces: roundToPlaces,
+            value: cashFlowCapexFY - sumQuarters,
+        });
+    }
+}
+exports.resolveCashFlowCapex = resolveCashFlowCapex;

package/build/services/ReportParser/resolvers/resolve-cash-flow-free.d.ts

@@ -0,0 +1,2 @@
+import ReportWrapper from '../ReportWrapper';
+export declare function resolveCashFlowFree(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-cash-flow-free.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCashFlowFree = void 0;
+var helpers_1 = require("./helpers");
+function resolveCashFlowFree(report) {
+    var _a = report, cashFlowFree = _a.cashFlowFree, cashFlowOperating = _a.cashFlowOperating, cashFlowCapex = _a.cashFlowCapex;
+    var nullKey = (0, helpers_1.getSingleNullKey)({ cashFlowFree: cashFlowFree, cashFlowOperating: cashFlowOperating, cashFlowCapex: cashFlowCapex });
+    if (cashFlowOperating !== null && cashFlowCapex !== null) {
+        report.cashFlowFree = cashFlowOperating - cashFlowCapex;
+    }
+    switch (nullKey) {
+        case 'cashFlowFree':
+            report.cashFlowFree = cashFlowOperating - cashFlowCapex;
+            break;
+        case 'cashFlowCapex':
+            report.cashFlowCapex = cashFlowOperating - cashFlowFree;
+            break;
+        case 'cashFlowOperating':
+            report.cashFlowOperating = cashFlowFree + cashFlowCapex;
+            break;
+    }
+}
+exports.resolveCashFlowFree = resolveCashFlowFree;

package/build/services/ReportParser/resolvers/resolve-cash-flow-operating.d.ts

@@ -0,0 +1,2 @@
+import ReportWrapper from '../ReportWrapper';
+export declare function resolveCashFlowOperating(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-cash-flow-operating.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCashFlowOperating = void 0;
+var helpers_1 = require("./helpers");
+// TODO: make this more accurate.
+function resolveCashFlowOperating(report) {
+    if (report.cashFlowOperating !== null)
+        return;
+    var _a = report.getReportsFiscalYearByPeriod(), FY = _a.FY, Q1 = _a.Q1, Q2 = _a.Q2, Q3 = _a.Q3, Q4 = _a.Q4;
+    var cashFlowOperatingFY = FY ? FY.cashFlowOperating : null;
+    if (cashFlowOperatingFY !== null) {
+        var roundToPlaces = (0, helpers_1.getRoundToPlaces)(cashFlowOperatingFY);
+        // all reports that get estimated must be resolved to make sure the estimated values add up to the TTM value
+        for (var _i = 0, _b = [Q1, Q2, Q3, Q4]; _i < _b.length; _i++) {
+            var rep = _b[_i];
+            if (rep && rep.cashFlowOperating === null) {
+                var cashFlowOperating = getCashFlowOperating(rep);
+                if (cashFlowOperating === null)
+                    continue;
+                report.cashFlowOperating = (0, helpers_1.round)(cashFlowOperating, roundToPlaces);
+            }
+        }
+    }
+    else {
+        report.cashFlowOperating = getCashFlowOperating(report);
+    }
+}
+exports.resolveCashFlowOperating = resolveCashFlowOperating;
+function getCashFlowOperating(report) {
+    var reportPrev = report.getReportOffset(-1, report.isTTM ? 'ANNUAL' : 'QUARTERLY');
+    if (!reportPrev)
+        return null;
+    var _a = report, incomeNet = _a.incomeNet, expenseDepreciation = _a.expenseDepreciation, cashFlowWorkingCapitalNonCash = _a.cashFlowWorkingCapitalNonCash;
+    var cashFlowWorkingCapitalNonCashPrev = reportPrev.cashFlowWorkingCapitalNonCash;
+    if (cashFlowWorkingCapitalNonCash === null || cashFlowWorkingCapitalNonCashPrev === null)
+        return null;
+    var changeInWorkingCapitalNonCash = cashFlowWorkingCapitalNonCash - cashFlowWorkingCapitalNonCashPrev;
+    return incomeNet + expenseDepreciation - changeInWorkingCapitalNonCash;
+}

package/build/services/ReportParser/resolvers/resolve-cash-flow-working-capital-non-cash.d.ts

@@ -0,0 +1,2 @@
+import ReportWrapper from '../ReportWrapper';
+export declare function resolveCashFlowWorkingCapitalNonCash(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-cash-flow-working-capital-non-cash.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCashFlowWorkingCapitalNonCash = void 0;
+// TODO: See if this can be more accurate to improve the accuracy of cashFlowOperating
+function resolveCashFlowWorkingCapitalNonCash(report) {
+    if (report.cashFlowWorkingCapitalNonCash !== null)
+        return;
+    // the previous report is used to calculate the change in working capital in resolveCashFlowOperating
+    var reportWrapperPrev = report.getReportOffset(-1, report.isTTM ? 'ANNUAL' : 'QUARTERLY');
+    var _a = report.getReportsFiscalYearByPeriod(), FY = _a.FY, Q1 = _a.Q1, Q2 = _a.Q2, Q3 = _a.Q3, Q4 = _a.Q4;
+    for (var _i = 0, _b = [FY, Q1, Q2, Q3, Q4, reportWrapperPrev]; _i < _b.length; _i++) {
+        var report_1 = _b[_i];
+        var _c = report_1 !== null && report_1 !== void 0 ? report_1 : {}, assetCurrent = _c.assetCurrent, assetCurrentCashEquivalents = _c.assetCurrentCashEquivalents, liabilityCurrent = _c.liabilityCurrent, liabilityCurrentDebt = _c.liabilityCurrentDebt;
+        var isMissingProps = !report_1 || !assetCurrent || !assetCurrentCashEquivalents || !liabilityCurrent;
+        if (isMissingProps || report_1.cashFlowWorkingCapitalNonCash !== null)
+            continue;
+        var assetsCurrentLessCash = assetCurrent - assetCurrentCashEquivalents;
+        var liabilitiesCurrentLessDebt = liabilityCurrent - (liabilityCurrentDebt !== null && liabilityCurrentDebt !== void 0 ? liabilityCurrentDebt : 0);
+        report_1.cashFlowWorkingCapitalNonCash = assetsCurrentLessCash - liabilitiesCurrentLessDebt;
+    }
+}
+exports.resolveCashFlowWorkingCapitalNonCash = resolveCashFlowWorkingCapitalNonCash;

package/build/services/ReportParser/resolvers/resolve-ebit.d.ts

@@ -0,0 +1,2 @@
+import ReportWrapper from '../ReportWrapper';
+export declare function resolveEbit(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-ebit.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEbit = void 0;
+var helpers_1 = require("./helpers");
+function resolveEbit(report) {
+    if (report.incomeOperating) {
+        report.ebit = report.incomeOperating;
+        return;
+    }
+    var _a = report, ebit = _a.ebit, expenseDepreciation = _a.expenseDepreciation, ebitda = _a.ebitda;
+    var nullKey = (0, helpers_1.getSingleNullKey)({ ebit: ebit, expenseDepreciation: expenseDepreciation, ebitda: ebitda });
+    switch (nullKey) {
+        case 'ebit':
+            report.ebit = expenseDepreciation + ebitda;
+            break;
+        case 'ebitda':
+            report.ebitda = ebit - expenseDepreciation;
+            break;
+        case 'expenseDepreciation':
+            report.expenseDepreciation = ebit - ebitda;
+            break;
+    }
+    report.incomeOperating = report.ebit;
+}
+exports.resolveEbit = resolveEbit;

package/build/services/ReportParser/resolvers/resolve-expense-depreciation.d.ts

@@ -0,0 +1,2 @@
+import ReportWrapper from '../ReportWrapper';
+export declare function resolveExpenseDepreciation(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-expense-depreciation.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExpenseDepreciation = void 0;
+var helpers_1 = require("./helpers");
+function resolveExpenseDepreciation(report) {
+    var _a, _b, _c;
+    // return if both values are already set
+    if (report.expenseDepreciation !== null && report.assetNonCurrentPPEGross !== null)
+        return;
+    var reportTTMCurrentYear = report.getReportOffset(0, 'ANNUAL');
+    // get report to get value for, prioritizing TTM current year. Used to get percent of depreciation relative to PPE
+    var reportTTMOrPrev = (_a = reportTTMCurrentYear !== null && reportTTMCurrentYear !== void 0 ? reportTTMCurrentYear : report.getReportOffset(-1, 'ANNUAL')) !== null && _a !== void 0 ? _a : report.getReportOffset(-1, 'QUARTERLY');
+    var expenseDepreciationTTMOrPrev = (_b = reportTTMOrPrev === null || reportTTMOrPrev === void 0 ? void 0 : reportTTMOrPrev.expenseDepreciation) !== null && _b !== void 0 ? _b : null;
+    var assetNonCurrentPPEGrossTTMOrPrev = (_c = reportTTMOrPrev === null || reportTTMOrPrev === void 0 ? void 0 : reportTTMOrPrev.assetNonCurrentPPEGross) !== null && _c !== void 0 ? _c : null;
+    // both values must be set to resolve
+    if (expenseDepreciationTTMOrPrev === null || assetNonCurrentPPEGrossTTMOrPrev === null) {
+        return;
+    }
+    var percentOfPPE = getDepreciationPercentOfPPE(report);
+    if (percentOfPPE === null)
+        return;
+    var _d = report, expenseDepreciation = _d.expenseDepreciation, assetNonCurrentPPEGross = _d.assetNonCurrentPPEGross;
+    var nullKey = (0, helpers_1.getSingleNullKey)({ expenseDepreciation: expenseDepreciation, assetNonCurrentPPEGross: assetNonCurrentPPEGross });
+    if (!nullKey)
+        return;
+    var valueTTMOrPrev = nullKey === 'expenseDepreciation' ? expenseDepreciationTTMOrPrev : assetNonCurrentPPEGrossTTMOrPrev;
+    // follow the same rounding as the other report values
+    var roundToPlaces = (0, helpers_1.getRoundToPlaces)(valueTTMOrPrev);
+    var resolveReport = function (rep) {
+        var _a = rep, expenseDepreciation = _a.expenseDepreciation, assetNonCurrentPPEGross = _a.assetNonCurrentPPEGross;
+        var nullKeyRep = (0, helpers_1.getSingleNullKey)({ expenseDepreciation: expenseDepreciation, assetNonCurrentPPEGross: assetNonCurrentPPEGross });
+        if (nullKey !== nullKeyRep)
+            return false;
+        switch (nullKey) {
+            case 'expenseDepreciation':
+                rep.expenseDepreciation = (0, helpers_1.round)(assetNonCurrentPPEGross * percentOfPPE, roundToPlaces);
+                break;
+            case 'assetNonCurrentPPEGross':
+                rep.assetNonCurrentPPEGross = (0, helpers_1.round)(expenseDepreciation / percentOfPPE, roundToPlaces);
+                break;
+        }
+        return true;
+    };
+    // if we have all reports for the year and we know the value of TTM, need to make sure the estimated values add up to the TTM value
+    if (reportTTMCurrentYear) {
+        var _e = report.getReportsFiscalYearByPeriod(), Q1 = _e.Q1, Q2 = _e.Q2, Q3 = _e.Q3, Q4 = _e.Q4;
+        var reportsEstimated = [];
+        // all reports that get estimated must be resolved to make sure the estimated values add up to the TTM value
+        var didResolveAllEstimated = true;
+        for (var _i = 0, _f = [Q1, Q2, Q3, Q4]; _i < _f.length; _i++) {
+            var rep = _f[_i];
+            if (rep && (rep === null || rep === void 0 ? void 0 : rep[nullKey]) === null) {
+                didResolveAllEstimated = resolveReport(rep) && didResolveAllEstimated;
+                reportsEstimated.push(rep);
+            }
+        }
+        if (didResolveAllEstimated && reportsEstimated.length > 0 && Q1 && Q2 && Q3 && Q4) {
+            // const
+            var estimationDifference = [Q1, Q2, Q3, Q4].reduce(function (remainingDiff, rep) { var _a; return remainingDiff - Number((_a = rep[nullKey]) !== null && _a !== void 0 ? _a : 0); }, Number(reportTTMCurrentYear[nullKey]));
+            // divide as evenly as possible between the reports, and give the leftover to the last estimated report
+            (0, helpers_1.splitValueBetweenReports)({
+                key: nullKey,
+                reports: reportsEstimated,
+                roundToPlaces: roundToPlaces,
+                value: estimationDifference,
+            });
+        }
+    }
+    else {
+        resolveReport(report);
+    }
+}
+exports.resolveExpenseDepreciation = resolveExpenseDepreciation;
+function getDepreciationPercentOfPPE(report) {
+    var _a, _b, _c, _d;
+    var reportTTMOrPrev = (_b = (_a = report.getReportOffset(0, 'ANNUAL')) !== null && _a !== void 0 ? _a : report.getReportOffset(-1, 'ANNUAL')) !== null && _b !== void 0 ? _b : report.getReportOffset(-1, 'QUARTERLY');
+    var expenseDepreciationTTMOrPrev = (_c = reportTTMOrPrev === null || reportTTMOrPrev === void 0 ? void 0 : reportTTMOrPrev.expenseDepreciation) !== null && _c !== void 0 ? _c : null;
+    var assetNonCurrentPPEGrossTTMOrPrev = (_d = reportTTMOrPrev === null || reportTTMOrPrev === void 0 ? void 0 : reportTTMOrPrev.assetNonCurrentPPEGross) !== null && _d !== void 0 ? _d : null;
+    if (!reportTTMOrPrev || expenseDepreciationTTMOrPrev === null || assetNonCurrentPPEGrossTTMOrPrev === null) {
+        return null;
+    }
+    // if checking depreciation using an annual report, we need to get the sum of the quarters
+    var ppeDenominator = assetNonCurrentPPEGrossTTMOrPrev;
+    if (reportTTMOrPrev.isTTM && !report.isTTM) {
+        var _e = reportTTMOrPrev.getReportsFiscalYearByPeriod(), Q1 = _e.Q1, Q2 = _e.Q2, Q3 = _e.Q3, Q4 = _e.Q4;
+        ppeDenominator = 0;
+        for (var _i = 0, _f = [Q1, Q2, Q3, Q4]; _i < _f.length; _i++) {
+            var rep = _f[_i];
+            var assetNonCurrentPPEGross = rep === null || rep === void 0 ? void 0 : rep.assetNonCurrentPPEGross;
+            if (typeof assetNonCurrentPPEGross !== 'number')
+                return null;
+            ppeDenominator += assetNonCurrentPPEGross;
+        }
+    }
+    return expenseDepreciationTTMOrPrev / ppeDenominator;
+}

package/build/services/ReportParser/resolvers/resolve-expense-operating.d.ts

@@ -0,0 +1,2 @@
+import ReportWrapper from '../ReportWrapper';
+export declare function resolveExpenseOperating(report: ReportWrapper): void;