sec-edgar-api 0.2.1 → 0.2.2

package/build/services/ReportBuilder/ReportBuilder.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FactFiscalCalculator_1 = require("./FactFiscalCalculator");
+var FactPeriodResolver_1 = require("./FactPeriodResolver");
+var FactRecordBuilder_1 = require("./FactRecordBuilder");
+var FactSplitAdjuster_1 = require("./FactSplitAdjuster");
+var ReportBuilder = /** @class */ (function () {
+    function ReportBuilder() {
+        this.factRecordBuilder = new FactRecordBuilder_1.default();
+    }
+    ReportBuilder.prototype.createFacts = function (companyFacts) {
+        return this.factRecordBuilder.createFacts(companyFacts);
+    };
+    ReportBuilder.prototype.buildReports = function (params) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var facts = params.facts, reportDates = params.reportDates;
+        if (facts.length === 0) {
+            return [];
+        }
+        var accessionByYearQuarter = new Map();
+        reportDates === null || reportDates === void 0 ? void 0 : reportDates.forEach(function (params) {
+            var year = params.year, quarter = params.quarter, accn = params.accn;
+            if (accn)
+                accessionByYearQuarter.set("".concat(year, "_").concat(quarter), accn);
+        });
+        var reportsCik = Number(facts[0].cik);
+        var factFiscalCalculator = new FactFiscalCalculator_1.default();
+        var factPeriodResolver = new FactPeriodResolver_1.default({ cik: reportsCik });
+        var factSplitAdjuster = new FactSplitAdjuster_1.default();
+        facts.forEach(function (fact) { return factFiscalCalculator.add(fact); });
+        reportDates === null || reportDates === void 0 ? void 0 : reportDates.forEach(function (params) { return factFiscalCalculator.setReportDates(params); });
+        var unitByPropertyName = new Map();
+        var splitDateDataByKey = new Map();
+        var minYear = Infinity;
+        var maxYear = -Infinity;
+        var countByAccnByYearQuarter = new Map();
+        for (var _i = 0, facts_1 = facts; _i < facts_1.length; _i++) {
+            var fact = facts_1[_i];
+            var end = fact.end, name_1 = fact.name, unit = fact.unit, segments = fact.segments, start = fact.start, value = fact.value, cik = fact.cik, form = fact.form, filed = fact.filed, accn = fact.accn;
+            if (Number(fact.cik) !== Number(reportsCik)) {
+                throw new Error("All facts must have the same cik ".concat(reportsCik, " !== ").concat(Number(cik)));
+            }
+            var segmentValue = segments === null || segments === void 0 ? void 0 : segments.map(function (seg) { return "".concat(seg.dimension, "_").concat(seg.value); }).join('&');
+            var propertyName = (_a = name_1.split(':').pop()) !== null && _a !== void 0 ? _a : '';
+            var propertyNameWithSegment = propertyName + (segmentValue ? "_".concat(segmentValue) : '');
+            var _h = factFiscalCalculator.getFiscalYearQuarter({ dateStr: end }), quarter = _h.quarter, year = _h.year;
+            if (year < minYear)
+                minYear = year;
+            if (year > maxYear)
+                maxYear = year;
+            var splitKey = "".concat(year, "_").concat(value);
+            var isSplit = factSplitAdjuster.isSplitProperty(propertyName);
+            unitByPropertyName.set(propertyNameWithSegment, unit);
+            if (isSplit && new Date(end) > new Date((_c = (_b = splitDateDataByKey.get(splitKey)) === null || _b === void 0 ? void 0 : _b.end) !== null && _c !== void 0 ? _c : 0)) {
+                splitDateDataByKey.set(splitKey, { end: end, quarter: quarter });
+            }
+            var accnKey = "".concat(year, "_").concat(quarter);
+            var accnGiven = accessionByYearQuarter.get(accnKey);
+            var filedDistance = Math.abs(new Date(filed).getTime() - new Date(end !== null && end !== void 0 ? end : 0).getTime()) / 86400000;
+            var isFiledRecent = filedDistance < 60;
+            if (!accnGiven && isFiledRecent && accn && (!form || form === '10-K' || form === '10-Q')) {
+                var countByAccn = (_d = countByAccnByYearQuarter.get(accnKey)) !== null && _d !== void 0 ? _d : new Map();
+                countByAccn.set(accn, ((_e = countByAccn.get(accn)) !== null && _e !== void 0 ? _e : 0) + 1);
+                countByAccnByYearQuarter.set(accnKey, countByAccn);
+            }
+            var dates = factFiscalCalculator.getDatesByYearQuarter({ quarter: quarter, year: year });
+            factPeriodResolver.add({
+                year: year,
+                start: start,
+                end: end,
+                name: propertyNameWithSegment,
+                quarter: quarter,
+                value: value,
+                dateFiled: (_f = dates === null || dates === void 0 ? void 0 : dates.filed) !== null && _f !== void 0 ? _f : '',
+                dateReport: (_g = dates === null || dates === void 0 ? void 0 : dates.end) !== null && _g !== void 0 ? _g : '',
+            });
+        }
+        countByAccnByYearQuarter.forEach(function (countByAccn, yearQuarter) {
+            if (accessionByYearQuarter.has(yearQuarter))
+                return;
+            var maxCount = 0;
+            var accessionNumber = '';
+            countByAccn.forEach(function (count, accn) {
+                if (count > maxCount) {
+                    maxCount = count;
+                    accessionNumber = accn;
+                }
+            });
+            accessionByYearQuarter.set(yearQuarter, accessionNumber);
+        });
+        minYear = Number.isFinite(minYear) ? minYear : new Date().getFullYear();
+        maxYear = Number.isFinite(maxYear) ? maxYear : new Date().getFullYear();
+        var reportsByKey = new Map();
+        // resolves quarterly and annual properties and creates reports
+        factPeriodResolver.forEach(function (data) {
+            var _a;
+            var fiscalPeriod = data.fiscalPeriod, propertyName = data.propertyName, value = data.value, year = data.year;
+            var key = "".concat(year, "_").concat(fiscalPeriod);
+            var quarter = fiscalPeriod === 'FY' ? 4 : Number(fiscalPeriod[1]);
+            var dates = factFiscalCalculator.getDatesByYearQuarter({ quarter: quarter, year: year });
+            var _b = dates !== null && dates !== void 0 ? dates : { filed: '', end: '' }, filed = _b.filed, end = _b.end;
+            var accessionNumber = accessionByYearQuarter.get("".concat(year, "_").concat(quarter));
+            var accessionNoHyphen = accessionNumber === null || accessionNumber === void 0 ? void 0 : accessionNumber.replace(/-/g, '');
+            var url = accessionNumber
+                ? "https://www.sec.gov/Archives/edgar/data/".concat(reportsCik, "/").concat(accessionNoHyphen, "/").concat(accessionNumber, ".txt")
+                : null;
+            if (!reportsByKey.has(key)) {
+                reportsByKey.set(key, {
+                    cik: reportsCik,
+                    url: url,
+                    dateFiled: filed,
+                    dateReport: end,
+                    fiscalPeriod: fiscalPeriod,
+                    fiscalYear: year,
+                    splitDate: null,
+                    splitRatio: null,
+                });
+            }
+            // add facts to adjust for splits
+            factSplitAdjuster.add({
+                end: end,
+                filed: filed,
+                fiscalPeriod: fiscalPeriod,
+                name: propertyName,
+                unit: (_a = unitByPropertyName.get(propertyName)) !== null && _a !== void 0 ? _a : '',
+                year: year,
+                value: Number(value),
+                accn: accessionNumber !== null && accessionNumber !== void 0 ? accessionNumber : '',
+            });
+            var report = reportsByKey.get(key);
+            report[propertyName] = value;
+        });
+        // iterate through facts adjustable for splits and assign values to reports
+        factSplitAdjuster.forEach(function (data) {
+            var year = data.year, fiscalPeriod = data.fiscalPeriod, propertyName = data.propertyName, value = data.value;
+            var key = "".concat(year, "_").concat(fiscalPeriod);
+            var report = reportsByKey.get(key);
+            if (!report)
+                return;
+            report[propertyName] = Math.round(value * 10000) / 10000;
+        });
+        // add split dates and values to reports
+        factSplitAdjuster.getSplitsAsc().forEach(function (split) {
+            var _a, _b, _c, _d;
+            var _e = factFiscalCalculator.getFiscalYearQuarter({ dateStr: split.end }), quarter = _e.quarter, year = _e.year;
+            var keySplit = "".concat(year, "_").concat(split.value);
+            var splitDateData = (_a = splitDateDataByKey.get(keySplit)) !== null && _a !== void 0 ? _a : { end: null, quarter: null };
+            var splitDate = (_b = splitDateData.end) !== null && _b !== void 0 ? _b : split.filed;
+            var splitQuarter = (_c = splitDateData.quarter) !== null && _c !== void 0 ? _c : quarter;
+            var fiscalPeriod = "Q".concat(splitQuarter);
+            var keyReport = "".concat(year, "_").concat(fiscalPeriod);
+            var report = reportsByKey.get(keyReport);
+            var reportAnnual = splitQuarter === 4 ? (_d = reportsByKey.get("".concat(year, "_FY"))) !== null && _d !== void 0 ? _d : null : null;
+            if (report) {
+                report.splitRatio = split.value;
+                report.splitDate = splitDate;
+            }
+            // also assign to annual for Q4
+            if (reportAnnual) {
+                reportAnnual.splitRatio = split.value;
+                reportAnnual.splitDate = splitDate;
+            }
+        });
+        // sort reports ASC by year and quarter
+        var reportsSorted = [];
+        for (var year = minYear; year <= maxYear; year++) {
+            for (var i = 0; i < 5; i++) {
+                var fiscalPeriod = i === 4 ? 'FY' : "Q".concat(i + 1);
+                var key = "".concat(year, "_").concat(fiscalPeriod);
+                var report = reportsByKey.get(key);
+                if (report && report.dateReport) {
+                    reportsSorted.push(report);
+                }
+            }
+        }
+        return reportsSorted;
+    };
+    return ReportBuilder;
+}());
+exports.default = ReportBuilder;

package/build/services/ReportBuilder/ReportRawResolvable.d.ts

@@ -0,0 +1,17 @@
+import { ReportRaw } from '../../types';
+export type TemplateCode = 'I' | 'T' | 'B' | 'M' | 'N' | 'U';
+export default class ReportRawResolvable {
+    readonly report: ReportRaw;
+    private readonly emptyKeys;
+    private readonly addedProps;
+    private readonly calcMap;
+    private readonly templateCode;
+    private readonly keyStack;
+    constructor(report: ReportRaw, templateCode?: TemplateCode | null, calcMap?: Record<string, Record<string, string[]>>);
+    get(key: string): string | number | boolean | undefined;
+    getNumber(key: string): number;
+    isAdded(key: string): boolean;
+    private getChildKeysArr;
+    private calculateNumericKey;
+    toJSON(): ReportRaw;
+}

package/build/services/ReportBuilder/ReportRawResolvable.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var calculation_map_by_ns_1 = require("../../util/calculation-map-by-ns");
+var ReportRawResolvable = /** @class */ (function () {
+    function ReportRawResolvable(report, templateCode, calcMap) {
+        if (templateCode === void 0) { templateCode = null; }
+        if (calcMap === void 0) { calcMap = calculation_map_by_ns_1.calculationMapByNs; }
+        this.emptyKeys = new Set();
+        this.addedProps = new Set();
+        this.keyStack = new Set();
+        this.templateCode = templateCode !== null && templateCode !== void 0 ? templateCode : 'N';
+        this.report = report;
+        this.calcMap = calcMap;
+    }
+    ReportRawResolvable.prototype.get = function (key) {
+        var _a;
+        return (_a = this.report[key]) !== null && _a !== void 0 ? _a : this.calculateNumericKey(key, key);
+    };
+    ReportRawResolvable.prototype.getNumber = function (key) {
+        return Number(this.get(key)) || 0;
+    };
+    ReportRawResolvable.prototype.isAdded = function (key) {
+        return this.addedProps.has(key);
+    };
+    ReportRawResolvable.prototype.getChildKeysArr = function (key) {
+        var calcsByRole = this.calcMap[key];
+        if (calcsByRole === undefined) {
+            return [];
+        }
+        if (calcsByRole._) {
+            return [calcsByRole._];
+        }
+        var preferredKeys = [];
+        switch (this.templateCode) {
+            case 'I':
+                preferredKeys = [
+                    'StatementOfCashFlowsIndirectInvestmentBasedOperations',
+                    'StatementOfFinancialPositionUnclassified-InvestmentBasedOperations',
+                    'StatementOfCashFlowsIndirectDepositBasedOperations',
+                    'StatementOfFinancialPositionUnclassified-DepositBasedOperationsFirstAlternate',
+                    'StatementOfFinancialPositionUnclassified-DepositBasedOperations',
+                ];
+                break;
+            case 'B':
+                preferredKeys = [
+                    'StatementOfFinancialPositionUnclassified-DepositBasedOperationsFirstAlternate',
+                    'StatementOfFinancialPositionUnclassified-DepositBasedOperations',
+                ];
+                break;
+        }
+        var k = preferredKeys.find(function (k) { return calcsByRole[k]; });
+        if (!k) {
+            k = Object.keys(calcsByRole)[0];
+        }
+        return Object.keys(calcsByRole)
+            .sort(function (a, b) {
+            var indexA = preferredKeys.indexOf(a);
+            var indexB = preferredKeys.indexOf(b);
+            if (indexB === -1)
+                return -1;
+            if (indexA === -1)
+                return 1;
+            return indexA - indexB;
+        })
+            .map(function (k) { return calcsByRole[k]; });
+    };
+    ReportRawResolvable.prototype.calculateNumericKey = function (key, topLevelKey) {
+        var _a;
+        if (this.keyStack.has(key)) {
+            return undefined;
+        }
+        this.keyStack.add(key);
+        if (this.emptyKeys.has(key)) {
+            return undefined;
+        }
+        var childKeysArr = this.getChildKeysArr(key);
+        if (childKeysArr.length === 0) {
+            return undefined;
+        }
+        var didAdd = false;
+        var finalSum = 0;
+        for (var _i = 0, childKeysArr_1 = childKeysArr; _i < childKeysArr_1.length; _i++) {
+            var childKeys = childKeysArr_1[_i];
+            var sum = 0;
+            for (var _b = 0, childKeys_1 = childKeys; _b < childKeys_1.length; _b++) {
+                var k = childKeys_1[_b];
+                var _c = k.split('|'), childKey = _c[0], weightStr = _c[1];
+                var value = (_a = this.report[childKey]) !== null && _a !== void 0 ? _a : this.calculateNumericKey(childKey, topLevelKey);
+                if (typeof value !== 'number') {
+                    continue;
+                }
+                didAdd = true;
+                sum += value * Number(weightStr);
+            }
+            if (sum === 0) {
+                continue;
+            }
+            finalSum = sum;
+            break;
+        }
+        if (!didAdd) {
+            this.emptyKeys.add(key);
+            return undefined;
+        }
+        this.report[key] = finalSum;
+        this.addedProps.add(key);
+        return finalSum;
+    };
+    ReportRawResolvable.prototype.toJSON = function () {
+        return this.report;
+    };
+    return ReportRawResolvable;
+}());
+exports.default = ReportRawResolvable;

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

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

package/build/services/ReportBuilder/index.js

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

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

@@ -0,0 +1,66 @@
+import { FactValue, FiscalPeriod } from '../../types';
+interface FactItemArgs {
+    factValue: FactValue;
+    propertyName: string;
+    description: string;
+    label: string;
+    unit: string;
+    taxonomy: string;
+    fiscalYear: number;
+    fiscalPeriod: FiscalPeriod;
+    fiscalYearEnd: string;
+    fiscalPeriodEnd: string;
+    fiscalPeriodFiled: string;
+    fiscalYearFiled: string;
+    quarter: number;
+    factsByYearPeriod: Map<string, FactItem[]>;
+    factsByPropertyYearPeriod: Map<string, FactItem[]>;
+}
+export default class FactItem {
+    readonly description: string;
+    readonly factValue: FactValue;
+    readonly label: string;
+    readonly propertyName: string;
+    readonly taxonomy: string;
+    readonly unit: string;
+    readonly fiscalYear: number;
+    readonly fiscalPeriod: FiscalPeriod;
+    /** ex: 2023-09-29 */
+    readonly fiscalPeriodEnd: string;
+    /** ex: 2023-09-29 */
+    readonly fiscalYearEnd: string;
+    /** ex: 2023-09-29 */
+    readonly fiscalPeriodFiled: string;
+    /** ex: 2023-09-29 */
+    readonly fiscalYearFiled: string;
+    /** number  1 - 4 */
+    readonly quarter: number;
+    private readonly factsByYearPeriod;
+    private readonly factsByPropertyYearPeriod;
+    constructor(data: FactItemArgs);
+    toJSON(): {
+        description: string;
+        factValue: FactValue;
+        label: string;
+        propertyName: string;
+        taxonomy: string;
+        unit: string;
+        fiscalYear: number;
+        fiscalPeriod: FiscalPeriod;
+        fiscalYearEnd: string;
+        fiscalPeriodEnd: string;
+        fiscalPeriodFiled: string;
+        fiscalYearFiled: string;
+        quarter: number;
+    };
+    getFactsInPeriod(params?: {
+        fiscalYear?: number;
+        fiscalPeriod?: FiscalPeriod;
+    }): FactItem[];
+    getFactsInPeriodProperty(params?: {
+        fiscalYear?: number;
+        fiscalPeriod?: FiscalPeriod;
+        propertyName?: string;
+    }): FactItem[];
+}
+export {};

package/build/services/ReportParser/FactItem.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FactItem = /** @class */ (function () {
+    function FactItem(data) {
+        this.description = data.description;
+        this.factValue = data.factValue;
+        this.label = data.label;
+        this.propertyName = data.propertyName;
+        this.taxonomy = data.taxonomy;
+        this.unit = data.unit;
+        this.fiscalYear = data.fiscalYear;
+        this.fiscalPeriod = data.fiscalPeriod;
+        this.quarter = data.quarter;
+        this.fiscalYearEnd = data.fiscalYearEnd;
+        this.fiscalPeriodEnd = data.fiscalPeriodEnd;
+        this.fiscalPeriodFiled = data.fiscalPeriodFiled;
+        this.fiscalYearFiled = data.fiscalYearFiled;
+        this.factsByYearPeriod = data.factsByYearPeriod;
+        this.factsByPropertyYearPeriod = data.factsByPropertyYearPeriod;
+    }
+    FactItem.prototype.toJSON = function () {
+        return {
+            description: this.description,
+            factValue: this.factValue,
+            label: this.label,
+            propertyName: this.propertyName,
+            taxonomy: this.taxonomy,
+            unit: this.unit,
+            fiscalYear: this.fiscalYear,
+            fiscalPeriod: this.fiscalPeriod,
+            fiscalYearEnd: this.fiscalYearEnd,
+            fiscalPeriodEnd: this.fiscalPeriodEnd,
+            fiscalPeriodFiled: this.fiscalPeriodFiled,
+            fiscalYearFiled: this.fiscalYearFiled,
+            quarter: this.quarter,
+        };
+    };
+    FactItem.prototype.getFactsInPeriod = function (params) {
+        var _a;
+        var _b = params !== null && params !== void 0 ? params : {}, _c = _b.fiscalPeriod, fiscalPeriod = _c === void 0 ? this.fiscalPeriod : _c, _d = _b.fiscalYear, fiscalYear = _d === void 0 ? this.fiscalYear : _d;
+        return (_a = this.factsByYearPeriod.get("".concat(fiscalYear, "-").concat(fiscalPeriod))) !== null && _a !== void 0 ? _a : [];
+    };
+    FactItem.prototype.getFactsInPeriodProperty = function (params) {
+        var _a;
+        var _b = params !== null && params !== void 0 ? params : {}, _c = _b.fiscalPeriod, fiscalPeriod = _c === void 0 ? this.fiscalPeriod : _c, _d = _b.fiscalYear, fiscalYear = _d === void 0 ? this.fiscalYear : _d, _e = _b.propertyName, propertyName = _e === void 0 ? this.propertyName : _e;
+        return (_a = this.factsByPropertyYearPeriod.get("".concat(propertyName, "-").concat(fiscalYear, "-").concat(fiscalPeriod))) !== null && _a !== void 0 ? _a : [];
+    };
+    return FactItem;
+}());
+exports.default = FactItem;

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

@@ -0,0 +1,22 @@
+import { CompanyFactListData } from '../../types';
+import FactItem from './FactItem';
+import FactIterator from './FactIterator';
+import { default as FactSplitMap, default as FactSplitMapper } from './FactSplitMap';
+interface ReportRawParserArgs {
+    factIterator?: FactIterator;
+    factSplitMapper?: FactSplitMapper;
+}
+export default class FactItemFactory {
+    private readonly factIterator;
+    constructor(args?: ReportRawParserArgs);
+    /**
+     * Creates FactItem instances from sorted by end date ascending
+     */
+    createFactItems(companyFactListData: Pick<CompanyFactListData, 'facts'>): {
+        factSplitMap: FactSplitMap;
+        factItems: FactItem[];
+    };
+    private getFiscalPeriod;
+    private getFiscalYearQuarter;
+}
+export {};

package/build/services/ReportParser/FactItemFactory.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FactItem_1 = require("./FactItem");
+var FactIterator_1 = require("./FactIterator");
+var FactSplitMap_1 = require("./FactSplitMap");
+var FactItemFactory = /** @class */ (function () {
+    function FactItemFactory(args) {
+        var _a = (args !== null && args !== void 0 ? args : {}).factIterator, factIterator = _a === void 0 ? new FactIterator_1.default() : _a;
+        this.factIterator = factIterator;
+    }
+    /**
+     * Creates FactItem instances from sorted by end date ascending
+     */
+    FactItemFactory.prototype.createFactItems = function (companyFactListData) {
+        var _this = this;
+        var dateStrsQuarter = new Set();
+        var endDateByYear = new Map();
+        var factsFlat = [];
+        var filedByEndDate = new Map();
+        var factSplitMap = new FactSplitMap_1.default();
+        this.factIterator.iterateCompanyFacts(companyFactListData, function (data) {
+            var _a, _b;
+            factsFlat.push(data);
+            var filedProp = data.factValue.filed;
+            var earliestFiled = (_a = filedByEndDate.get(data.factValue.end)) !== null && _a !== void 0 ? _a : filedProp;
+            // all report filed dates matter, even if not included because missing frame.
+            if (filedProp <= earliestFiled && filedProp > data.factValue.end && data.factValue.form !== '8-K') {
+                filedByEndDate.set(data.factValue.end, filedProp);
+            }
+            if (!data.factValue.frame || data.factValue.frame.endsWith('I')) {
+                return;
+            }
+            dateStrsQuarter.add(data.factValue.end);
+            if (((_b = data.factValue.frame) === null || _b === void 0 ? void 0 : _b.length) === 6) {
+                var calendarYear = data.factValue.end.split('-')[0];
+                endDateByYear.set(Number(calendarYear), new Date(data.factValue.end));
+            }
+        });
+        var fiscalsByDates = new Map();
+        var endDateByYearQuarter = new Map();
+        dateStrsQuarter.forEach(function (dateStr) {
+            var fiscals = _this.getFiscalYearQuarter({ dateStr: dateStr, endDateByYear: endDateByYear });
+            var quarter = fiscals.quarter, year = fiscals.year;
+            var key = "".concat(year, "-").concat(quarter);
+            fiscalsByDates.set(dateStr, fiscals);
+            endDateByYearQuarter.set(key, dateStr);
+        });
+        // factsFlat.sort((a, b) => (a.factValue.end > b.factValue.end ? 1 : -1))
+        var factsByYearPeriod = new Map();
+        var factsByPropertyYearPeriod = new Map();
+        var factItems = factsFlat.map(function (data) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            var factValue = data.factValue, description = data.description, label = data.label, propertyName = data.propertyName, taxonomy = data.taxonomy, unit = data.unit;
+            var dateStr = factValue.end;
+            var fiscals = (_a = fiscalsByDates.get(dateStr)) !== null && _a !== void 0 ? _a : _this.getFiscalYearQuarter({ dateStr: dateStr, endDateByYear: endDateByYear });
+            fiscalsByDates.set(dateStr, fiscals);
+            var fiscalPeriod = _this.getFiscalPeriod({ factValue: factValue, quarter: fiscals.quarter });
+            var fiscalPeriodEnd = (_b = endDateByYearQuarter.get("".concat(fiscals.year, "-").concat(fiscals.quarter))) !== null && _b !== void 0 ? _b : factValue.end;
+            var fiscalYearEnd = (_c = endDateByYearQuarter.get("".concat(fiscals.year, "-4"))) !== null && _c !== void 0 ? _c : factValue.end;
+            var factItem = new FactItem_1.default({
+                description: description,
+                factValue: factValue,
+                label: label,
+                propertyName: propertyName,
+                taxonomy: taxonomy,
+                unit: unit,
+                fiscalYear: fiscals.year,
+                fiscalPeriod: fiscalPeriod,
+                fiscalYearEnd: fiscalYearEnd,
+                fiscalPeriodEnd: fiscalPeriodEnd,
+                factsByYearPeriod: factsByYearPeriod,
+                factsByPropertyYearPeriod: factsByPropertyYearPeriod,
+                fiscalPeriodFiled: (_d = filedByEndDate.get(fiscalPeriodEnd)) !== null && _d !== void 0 ? _d : factValue.filed,
+                fiscalYearFiled: (_e = filedByEndDate.get(fiscalYearEnd)) !== null && _e !== void 0 ? _e : factValue.filed,
+                quarter: fiscals.quarter,
+            });
+            var keyFiscal = "".concat(fiscals.year, "-").concat(fiscalPeriod);
+            var keyProperty = "".concat(data.propertyName, "-").concat(keyFiscal);
+            var bucket = (_f = factsByYearPeriod.get(keyFiscal)) !== null && _f !== void 0 ? _f : [];
+            bucket.push(factItem);
+            factsByYearPeriod.set(keyFiscal, bucket);
+            var bucketProperty = (_g = factsByPropertyYearPeriod.get(keyProperty)) !== null && _g !== void 0 ? _g : [];
+            bucketProperty.push(factItem);
+            factsByPropertyYearPeriod.set(keyProperty, bucketProperty);
+            factSplitMap.addFact(factItem);
+            return factItem;
+        });
+        factItems.sort(function (a, b) { return (a.factValue.filed > b.factValue.filed ? 1 : -1); });
+        return { factSplitMap: factSplitMap, factItems: factItems };
+    };
+    FactItemFactory.prototype.getFiscalPeriod = function (params) {
+        var _a;
+        var factValue = params.factValue, quarter = params.quarter;
+        if (factValue.frame) {
+            return factValue.frame.length === 6 ? 'FY' : "Q".concat(quarter);
+        }
+        var startDate = new Date((_a = factValue.start) !== null && _a !== void 0 ? _a : factValue.end);
+        var endDate = new Date(factValue.end);
+        var isYearDuration = (endDate.getTime() - startDate.getTime()) / 86400000 > 245;
+        return isYearDuration ? 'FY' : "Q".concat(quarter);
+    };
+    FactItemFactory.prototype.getFiscalYearQuarter = function (params) {
+        var dateStr = params.dateStr, endDateByYear = params.endDateByYear;
+        var getYearEndDate = function (year) {
+            var _a;
+            var YEAR_MS = 31536000000;
+            var date = endDateByYear.get(year);
+            var datePrev = endDateByYear.get(year - 1);
+            var dateNext = endDateByYear.get(year + 1);
+            if (date)
+                return date;
+            if (datePrev)
+                return new Date(datePrev.getTime() + YEAR_MS);
+            if (dateNext)
+                return new Date(dateNext.getTime() - YEAR_MS);
+            var prevKnownYear = Math.max.apply(Math, Array.from(endDateByYear.keys()));
+            var prevKnownDate = endDateByYear.get(prevKnownYear);
+            var years = (year - prevKnownYear) * YEAR_MS;
+            return new Date(((_a = prevKnownDate === null || prevKnownDate === void 0 ? void 0 : prevKnownDate.getTime()) !== null && _a !== void 0 ? _a : 0) + years);
+        };
+        var getDaysBefore = function (dateA, dateB) {
+            return (dateB.getTime() - dateA.getTime()) / 86400000;
+        };
+        var getFiscalQuarter = function (daysBeforeYearEnd) {
+            var fiscalPeriod = 1;
+            if (daysBeforeYearEnd < 45) {
+                fiscalPeriod = 4;
+            }
+            else if (daysBeforeYearEnd < 135) {
+                fiscalPeriod = 3;
+            }
+            else if (daysBeforeYearEnd < 225) {
+                fiscalPeriod = 2;
+            }
+            return fiscalPeriod;
+        };
+        var yearQuarter = Number(dateStr.split('-')[0]);
+        var dateQuarter = new Date(dateStr);
+        var yearEndDate = getYearEndDate(yearQuarter);
+        var daysBefore = getDaysBefore(dateQuarter, yearEndDate);
+        var isCurFiscalYear = daysBefore > -30;
+        var fiscalYear = isCurFiscalYear ? yearQuarter : yearQuarter + 1;
+        var fiscalYearEndDate = isCurFiscalYear ? yearEndDate : getYearEndDate(fiscalYear);
+        var daysFromYearEnd = (fiscalYearEndDate.getTime() - dateQuarter.getTime()) / 86400000;
+        var quarter = getFiscalQuarter(daysFromYearEnd);
+        return { quarter: quarter, year: fiscalYear };
+    };
+    return FactItemFactory;
+}());
+exports.default = FactItemFactory;

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

@@ -0,0 +1,16 @@
+import FactItem from './FactItem';
+interface SplitData {
+    factItem: FactItem;
+    firstFiled: string;
+}
+export default class FactSplitMap {
+    private readonly splitKey;
+    private readonly splitByFiscalYearAmount;
+    constructor();
+    addFact(factItem: FactItem): void;
+    getSplits(): SplitData[];
+    isSplitFact(factItem: FactItem): boolean;
+    private didApplySplit;
+    getSplitAdjustedValue(factItem: FactItem): number;
+}
+export {};