sec-edgar-api 0.2.1 → 0.2.3

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

@@ -0,0 +1,51 @@
+export interface SetReportDatesParams {
+    year: number;
+    quarter: number;
+    end: string;
+    filed: string;
+    isAnnual: boolean;
+    accn: string;
+}
+/**
+ * Gets the fiscal period for a given date. does this by checking when the FY end periods are,
+ * Then measures the offset from the end date to the next/previous fiscal year end.
+ */
+export default class FactFiscalCalculator {
+    private readonly endDateByYear;
+    private readonly fiscalsByEndDate;
+    private readonly datesByFiscals;
+    private readonly endDateCountMap;
+    private readonly filedDateCountByEndDate;
+    private didResolve;
+    add(fact: {
+        end: string;
+        filed: string;
+        frame?: string;
+    }): void;
+    private getDaysBefore;
+    setReportDates(params: SetReportDatesParams): void;
+    addAnnualReportDate(reportDate: string): void;
+    private isAnnualReportFact;
+    private resolve;
+    getDatesByYearQuarter(params: {
+        year: number;
+        quarter: number;
+    }): {
+        filed: string;
+        end: string;
+    } | null;
+    getFiscalYearQuarter(params: {
+        dateStr: string;
+        endDateByYear?: Map<number, Date>;
+    }): {
+        year: number;
+        quarter: number;
+    };
+    static getFiscalYearQuarter(params: {
+        dateStr: string;
+        endDateByYear: Map<number, Date>;
+    }): {
+        quarter: number;
+        year: number;
+    };
+}

package/build/services/ReportBuilder/FactFiscalCalculator.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Gets the fiscal period for a given date. does this by checking when the FY end periods are,
+ * Then measures the offset from the end date to the next/previous fiscal year end.
+ */
+var FactFiscalCalculator = /** @class */ (function () {
+    function FactFiscalCalculator() {
+        this.endDateByYear = new Map();
+        this.fiscalsByEndDate = new Map();
+        this.datesByFiscals = new Map();
+        /// these get cleared after resolve
+        this.endDateCountMap = new Map();
+        this.filedDateCountByEndDate = new Map();
+        this.didResolve = false;
+    }
+    FactFiscalCalculator.prototype.add = function (fact) {
+        var _a, _b, _c;
+        var end = fact.end, filed = fact.filed, frame = fact.frame;
+        if (this.didResolve) {
+            throw new Error('Cannot add fact after resolving');
+        }
+        if (this.isAnnualReportFact(fact)) {
+            this.addAnnualReportDate(fact.end);
+        }
+        this.endDateCountMap.set(end, ((_a = this.endDateCountMap.get(end)) !== null && _a !== void 0 ? _a : 0) + 1);
+        // don't record filed dates for restated facts
+        if (this.getDaysBefore(filed, end) < 60) {
+            var bucket = (_b = this.filedDateCountByEndDate.get(end)) !== null && _b !== void 0 ? _b : this.filedDateCountByEndDate.set(end, new Map()).get(end);
+            bucket.set(filed, ((_c = bucket.get(filed)) !== null && _c !== void 0 ? _c : 0) + 1);
+        }
+    };
+    FactFiscalCalculator.prototype.getDaysBefore = function (dateStrAfter, dateStrBefore) {
+        var dateAfter = new Date(dateStrAfter);
+        var dateBefore = new Date(dateStrBefore);
+        var dayMS = 86400000;
+        var differenceMS = dateAfter.getTime() - dateBefore.getTime();
+        return differenceMS / dayMS;
+    };
+    FactFiscalCalculator.prototype.setReportDates = function (params) {
+        var year = params.year, quarter = params.quarter, end = params.end, filed = params.filed, isAnnual = params.isAnnual;
+        var key = "".concat(year, "_").concat(quarter);
+        if (!this.datesByFiscals.has(key)) {
+            if (year.toString().length !== 4)
+                return;
+            this.datesByFiscals.set(key, { filed: filed, end: end });
+        }
+        var dates = this.datesByFiscals.get(key);
+        dates.filed = filed;
+        dates.end = end;
+        this.filedDateCountByEndDate.set(end, new Map([[filed, Infinity]]));
+        this.endDateCountMap.set(end, Infinity);
+        if (isAnnual) {
+            this.endDateByYear.set(Number(end.split('-', 1)[0]), new Date(end));
+        }
+    };
+    FactFiscalCalculator.prototype.addAnnualReportDate = function (reportDate) {
+        var year = Number(reportDate.split('-', 1)[0]);
+        var dateEnd = new Date(reportDate);
+        this.endDateByYear.set(year, dateEnd);
+    };
+    FactFiscalCalculator.prototype.isAnnualReportFact = function (params) {
+        var end = params.end, start = params.start, filed = params.filed, period = params.period, frame = params.frame;
+        if (frame) {
+            // FY frames will look like CY2023 vs CY2023Q2 or CY2023Q2I
+            return frame.length === 6;
+        }
+        if (period !== undefined)
+            return period === 12;
+        // TODO: This was breaking for TSM. they file reports way late.
+        if (!start || this.getDaysBefore(end, start) < 315)
+            return false;
+        return this.getDaysBefore(filed, end) < 60;
+        // return start && this.getDaysBefore(end, start) < 315
+    };
+    FactFiscalCalculator.prototype.resolve = function () {
+        var _this = this;
+        var _a;
+        this.endDateCountMap.forEach(function (count, date) {
+            var _a;
+            var _b = _this.getFiscalYearQuarter({ dateStr: date }), quarter = _b.quarter, year = _b.year;
+            if (year.toString().length !== 4)
+                return;
+            var key = "".concat(year, "_").concat(quarter);
+            if (!_this.datesByFiscals.has(key)) {
+                _this.datesByFiscals.set(key, { filed: '', end: '' });
+            }
+            var dateMap = _this.datesByFiscals.get(key);
+            var countPrevDate = (_a = _this.endDateCountMap.get(dateMap.end)) !== null && _a !== void 0 ? _a : 0;
+            if (count >= countPrevDate) {
+                dateMap.end = date;
+            }
+        });
+        // set to the most commonly used filed date for each end date
+        this.filedDateCountByEndDate.forEach(function (countByFiledDate, endDate) {
+            var maxCount = 0;
+            var filedDate = '';
+            countByFiledDate.forEach(function (count, filed) {
+                if (count > maxCount) {
+                    maxCount = count;
+                    filedDate = filed;
+                }
+            });
+            var _a = _this.getFiscalYearQuarter({ dateStr: endDate }), quarter = _a.quarter, year = _a.year;
+            var key = "".concat(year, "_").concat(quarter);
+            if (!_this.datesByFiscals.has(key)) {
+                if (year.toString().length !== 4)
+                    return;
+                _this.datesByFiscals.set(key, { filed: '', end: '' });
+            }
+            var dateMap = _this.datesByFiscals.get(key);
+            dateMap.filed = filedDate;
+        });
+        // some reports are missing filed dates, this guesses dates based on other years.
+        var monthDayByQuarter = new Map();
+        // find dates for each quarter to fill in missing.
+        var foundCount = 0;
+        for (var _i = 0, _b = Array.from(this.datesByFiscals.entries()); _i < _b.length; _i++) {
+            var _c = _b[_i], key = _c[0], dates = _c[1];
+            var quarter = Number(key.split('_')[1]);
+            var bucket = (_a = monthDayByQuarter.get(quarter)) !== null && _a !== void 0 ? _a : { filedMonthDay: '', endMonthDay: '' };
+            monthDayByQuarter.set(quarter, bucket);
+            if (dates.filed && !bucket.filedMonthDay) {
+                bucket.filedMonthDay = dates.filed.substring(5);
+                foundCount++;
+            }
+            if (dates.end && !bucket.endMonthDay) {
+                bucket.endMonthDay = dates.end.substring(5);
+                foundCount++;
+            }
+            if (foundCount === 8) {
+                break;
+            }
+        }
+        // if date falls on a weekend, move it to the nearest weekday
+        var ensureNoWeekends = function (dateStr) {
+            var date = new Date(dateStr);
+            if (date.getDay() === 6)
+                date.setDate(date.getDate() - 1);
+            if (date.getDay() === 0)
+                date.setDate(date.getDate() + 1);
+            return date.toISOString().split('T')[0];
+        };
+        // fill in missing dates
+        this.datesByFiscals.forEach(function (dates, key) {
+            var _a;
+            var quarter = Number(key.split('_')[1]);
+            var datesFound = (_a = monthDayByQuarter.get(quarter)) !== null && _a !== void 0 ? _a : { filedMonthDay: '', endMonthDay: '' };
+            // if filing month comes after report month, it's the same year, otherwise it's the next year
+            if (!dates.filed && dates.end && datesFound.filedMonthDay) {
+                var _b = dates.end.split('-'), yearEnd = _b[0], month = _b[1], day = _b[2];
+                var yearFiled = datesFound.filedMonthDay >= "".concat(month, "-").concat(day) ? yearEnd : Number(yearEnd) + 1;
+                dates.filed = ensureNoWeekends("".concat(yearFiled, "-").concat(datesFound.filedMonthDay));
+            }
+            if (dates.filed && !dates.end && datesFound.endMonthDay) {
+                var _c = dates.filed.split('-'), yearFiled = _c[0], month = _c[1], day = _c[2];
+                var yearEnd = "".concat(month, "-").concat(day) >= datesFound.endMonthDay ? yearFiled : Number(yearFiled) - 1;
+                dates.end = ensureNoWeekends("".concat(yearEnd, "-").concat(datesFound.endMonthDay));
+            }
+        });
+        this.endDateCountMap.clear();
+        this.filedDateCountByEndDate.clear();
+        this.didResolve = true;
+    };
+    FactFiscalCalculator.prototype.getDatesByYearQuarter = function (params) {
+        var _a;
+        if (!this.didResolve)
+            this.resolve();
+        this.didResolve = true;
+        return (_a = this.datesByFiscals.get("".concat(params.year, "_").concat(params.quarter))) !== null && _a !== void 0 ? _a : null;
+    };
+    FactFiscalCalculator.prototype.getFiscalYearQuarter = function (params) {
+        var dateStr = params.dateStr, _a = params.endDateByYear, endDateByYear = _a === void 0 ? this.endDateByYear : _a;
+        if (this.fiscalsByEndDate.has(dateStr)) {
+            return this.fiscalsByEndDate.get(dateStr);
+        }
+        var fiscals = FactFiscalCalculator.getFiscalYearQuarter({ dateStr: dateStr, endDateByYear: endDateByYear });
+        this.fiscalsByEndDate.set(dateStr, fiscals);
+        return fiscals;
+    };
+    FactFiscalCalculator.getFiscalYearQuarter = function (params) {
+        var dateStr = params.dateStr, endDateByYear = params.endDateByYear;
+        if (endDateByYear.size === 0) {
+            throw new Error('No annual report dates provided');
+        }
+        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 quarter = 1;
+            if (daysBeforeYearEnd < 45) {
+                quarter = 4;
+            }
+            else if (daysBeforeYearEnd < 135) {
+                quarter = 3;
+            }
+            else if (daysBeforeYearEnd < 225) {
+                quarter = 2;
+            }
+            return quarter;
+        };
+        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 FactFiscalCalculator;
+}());
+exports.default = FactFiscalCalculator;

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

@@ -0,0 +1,48 @@
+import { FiscalPeriod } from '../../types/report-raw.type';
+/**
+ * Resolves quarterly and annual values for a property. This is because filers provide total values for the
+ * current fiscal year, rather than values for the individual quarters
+ * ex: Net income for Q2 will give 6 months revenue, not 3 month.
+ */
+export default class FactPeriodResolver {
+    /** Values for each quarter [numQ1, numQ2, numQ3, numQ4] */
+    private readonly valueByQuarterByPropertyByYear;
+    /** Same as by quarter but string values */
+    private readonly valueByQuarterByPropertyByYearString;
+    /** Value sums (each includes sum of previous quarter). last el used for annual report. [sumQ1, sumQ2, sumQ3, sumFY] */
+    private readonly sumByQuarterByPropertyByYear;
+    /** Which properties have a range that need to be resolved to get quarterly value */
+    private readonly propertiesResolvableByYear;
+    /** all properties present for each year */
+    private readonly propertiesByYear;
+    /** prevent values from being added multiple times */
+    private readonly resolvedValues;
+    private readonly cik;
+    constructor(args: {
+        cik: number;
+    });
+    private getOrSetBucketArr;
+    private addPropertyByYear;
+    resolveValues(propertyName: string, year: number): void;
+    get(propertyName: string, year: number, fiscalPeriod: FiscalPeriod): number | undefined;
+    private getPropertyBuckets;
+    private getPeriod;
+    private getOrSetReport;
+    add(params: {
+        year: number;
+        quarter: number;
+        start?: string;
+        end: string;
+        value: number | string;
+        name: string;
+        filed: string;
+    }): void;
+    private readonly unresolvedReports;
+    private buildUnresolvedReports;
+    forEach(callback: (params: {
+        year: number;
+        fiscalPeriod: FiscalPeriod;
+        propertyName: string;
+        value: number | string;
+    }) => void): void;
+}

package/build/services/ReportBuilder/FactPeriodResolver.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ReportRawResolvable_1 = require("./ReportRawResolvable");
+/**
+ * Resolves quarterly and annual values for a property. This is because filers provide total values for the
+ * current fiscal year, rather than values for the individual quarters
+ * ex: Net income for Q2 will give 6 months revenue, not 3 month.
+ */
+var FactPeriodResolver = /** @class */ (function () {
+    function FactPeriodResolver(args) {
+        /** Values for each quarter [numQ1, numQ2, numQ3, numQ4] */
+        this.valueByQuarterByPropertyByYear = new Map();
+        /** Same as by quarter but string values */
+        this.valueByQuarterByPropertyByYearString = new Map();
+        /** Value sums (each includes sum of previous quarter). last el used for annual report. [sumQ1, sumQ2, sumQ3, sumFY] */
+        this.sumByQuarterByPropertyByYear = new Map();
+        /** Which properties have a range that need to be resolved to get quarterly value */
+        this.propertiesResolvableByYear = new Map();
+        /** all properties present for each year */
+        this.propertiesByYear = new Map();
+        /** prevent values from being added multiple times */
+        this.resolvedValues = new Set();
+        this.unresolvedReports = new Map();
+        var cik = args.cik;
+        this.cik = cik;
+    }
+    FactPeriodResolver.prototype.getOrSetBucketArr = function (map, year, propertyName) {
+        var _a, _b;
+        var propertyMap = (_a = map.get(year)) !== null && _a !== void 0 ? _a : map.set(year, new Map()).get(year);
+        return (_b = propertyMap.get(propertyName)) !== null && _b !== void 0 ? _b : propertyMap.set(propertyName, new Map()).get(propertyName);
+    };
+    FactPeriodResolver.prototype.addPropertyByYear = function (bucket, year, propertyName) {
+        var _a;
+        var properties = (_a = bucket.get(year)) !== null && _a !== void 0 ? _a : bucket.set(year, new Set()).get(year);
+        properties.add(propertyName);
+    };
+    FactPeriodResolver.prototype.resolveValues = function (propertyName, year) {
+        var _a, _b, _c;
+        var keyResolved = "".concat(year, "_").concat(propertyName);
+        var isResolved = this.resolvedValues.has(keyResolved);
+        var isResolvable = Boolean((_a = this.propertiesResolvableByYear.get(year)) === null || _a === void 0 ? void 0 : _a.has(propertyName));
+        if (!isResolvable || isResolved)
+            return;
+        var _d = this.getPropertyBuckets(year, propertyName), bucketQuarter = _d.bucketQuarter, bucketSum = _d.bucketSum;
+        if (bucketQuarter.size === 4 && bucketSum.has(3))
+            return;
+        for (var i = 0; i < 4; i++) {
+            var quarterValue = bucketQuarter.get(i);
+            var reportKey = "".concat(year, "_").concat(i + 1);
+            var unresolvedReport = this.unresolvedReports.get(reportKey);
+            var unresolvedReportPrev = this.unresolvedReports.get("".concat(year, "_").concat(i));
+            var sumValue = (_b = unresolvedReport === null || unresolvedReport === void 0 ? void 0 : unresolvedReport.getNumber(propertyName)) !== null && _b !== void 0 ? _b : 0;
+            var prevSum = (_c = unresolvedReportPrev === null || unresolvedReportPrev === void 0 ? void 0 : unresolvedReportPrev.getNumber(propertyName)) !== null && _c !== void 0 ? _c : 0;
+            if (quarterValue === undefined) {
+                var bucketQuarter_1 = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYear, year, propertyName);
+                bucketQuarter_1.set(i, (Number(sumValue) || 0) - (Number(prevSum) || 0));
+            }
+            if (quarterValue !== undefined && sumValue === undefined) {
+                var bucketSum_1 = this.getOrSetBucketArr(this.sumByQuarterByPropertyByYear, year, propertyName);
+                bucketSum_1.set(i, quarterValue + prevSum);
+            }
+        }
+        this.resolvedValues.add(keyResolved);
+    };
+    FactPeriodResolver.prototype.get = function (propertyName, year, fiscalPeriod) {
+        var _a, _b;
+        this.resolveValues(propertyName, year);
+        var index = (_a = { Q1: 0, Q2: 1, Q3: 2, Q4: 3, FY: 3 }[fiscalPeriod]) !== null && _a !== void 0 ? _a : 4;
+        var isAnnual = fiscalPeriod === 'FY';
+        var bucket = isAnnual
+            ? this.sumByQuarterByPropertyByYear.get(year)
+            : this.valueByQuarterByPropertyByYear.get(year);
+        return (_b = bucket === null || bucket === void 0 ? void 0 : bucket.get(propertyName)) === null || _b === void 0 ? void 0 : _b.get(index);
+    };
+    FactPeriodResolver.prototype.getPropertyBuckets = function (year, propertyName) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var isInstant = !((_a = this.propertiesResolvableByYear.get(year)) === null || _a === void 0 ? void 0 : _a.has(propertyName));
+        var bucketQuarter = (_c = (_b = this.valueByQuarterByPropertyByYear.get(year)) === null || _b === void 0 ? void 0 : _b.get(propertyName)) !== null && _c !== void 0 ? _c : new Map();
+        var bucketSum = isInstant
+            ? bucketQuarter
+            : (_e = (_d = this.sumByQuarterByPropertyByYear.get(year)) === null || _d === void 0 ? void 0 : _d.get(propertyName)) !== null && _e !== void 0 ? _e : new Map();
+        var bucketString = (_g = (_f = this.valueByQuarterByPropertyByYearString.get(year)) === null || _f === void 0 ? void 0 : _f.get(propertyName)) !== null && _g !== void 0 ? _g : new Map();
+        return { bucketQuarter: bucketQuarter, bucketSum: bucketSum, bucketString: bucketString };
+    };
+    FactPeriodResolver.prototype.getPeriod = function (params) {
+        var start = params.start, end = params.end;
+        if (!start || start === end)
+            return 0;
+        var differenceMS = new Date(end).getTime() - new Date(start).getTime();
+        var differenceDays = differenceMS / 86400000;
+        if (differenceDays < 135)
+            return 3;
+        if (differenceDays < 225)
+            return 6;
+        if (differenceDays < 315)
+            return 9;
+        return 12;
+    };
+    FactPeriodResolver.prototype.getOrSetReport = function (params) {
+        var _a;
+        var year = params.year, quarter = params.quarter;
+        var key = "".concat(year, "_").concat(quarter);
+        var report = (_a = this.unresolvedReports.get(key)) !== null && _a !== void 0 ? _a : new ReportRawResolvable_1.default({
+            cik: this.cik,
+            fiscalYear: year,
+            fiscalPeriod: quarter === 4 ? 'FY' : "Q".concat(quarter),
+            dateReport: '',
+            dateFiled: '',
+            url: null,
+            splitDate: null,
+            splitRatio: null,
+        });
+        if (!this.unresolvedReports.has(key)) {
+            this.unresolvedReports.set(key, report);
+        }
+        return report;
+    };
+    FactPeriodResolver.prototype.add = function (params) {
+        var year = params.year, value = params.value, propertyName = params.name, quarter = params.quarter, start = params.start, end = params.end, filed = params.filed;
+        var period = this.getPeriod({ start: start, end: end });
+        this.addPropertyByYear(this.propertiesByYear, year, propertyName);
+        if (typeof value === 'string') {
+            var bucket = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYearString, year, propertyName);
+            bucket.set(quarter - 1, value);
+            return;
+        }
+        if (period === 0) {
+            var bucket = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYear, year, propertyName);
+            var bucketSum = this.getOrSetBucketArr(this.sumByQuarterByPropertyByYear, year, propertyName);
+            bucket.set(quarter - 1, value);
+            bucketSum.set(quarter - 1, value);
+            return;
+        }
+        if (period === 3) {
+            var bucket = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYear, year, propertyName);
+            bucket.set(quarter - 1, value);
+        }
+        if (quarter === 1 || period > 3) {
+            var bucket = this.getOrSetBucketArr(this.sumByQuarterByPropertyByYear, year, propertyName);
+            bucket.set(quarter - 1, value);
+        }
+        this.addPropertyByYear(this.propertiesResolvableByYear, year, propertyName);
+    };
+    FactPeriodResolver.prototype.buildUnresolvedReports = function () {
+        var _this = this;
+        this.propertiesByYear.forEach(function (properties, year) {
+            properties.forEach(function (propertyName) {
+                var _a, _b;
+                for (var i = 0; i < 4; i++) {
+                    var bucketSum = (_a = _this.sumByQuarterByPropertyByYear.get(year)) === null || _a === void 0 ? void 0 : _a.get(propertyName);
+                    var bucketQuarter = _this.getOrSetBucketArr(_this.valueByQuarterByPropertyByYear, year, propertyName);
+                    if (bucketSum && !bucketSum.has(i)) {
+                        var prevSum = 0;
+                        var quarterSum = 0;
+                        for (var j = 0; j < i; j++) {
+                            prevSum = quarterSum;
+                            quarterSum = (_b = bucketSum.get(j)) !== null && _b !== void 0 ? _b : quarterSum;
+                        }
+                        bucketSum.set(i, quarterSum);
+                        bucketQuarter.set(i, quarterSum - prevSum);
+                    }
+                    var value = bucketSum === null || bucketSum === void 0 ? void 0 : bucketSum.get(i);
+                    if (value === undefined)
+                        continue;
+                    var report = _this.getOrSetReport({ year: year, quarter: i + 1 });
+                    report.report[propertyName] = value;
+                }
+            });
+        });
+    };
+    FactPeriodResolver.prototype.forEach = function (callback) {
+        var _this = this;
+        this.buildUnresolvedReports();
+        this.propertiesByYear.forEach(function (properties, year) {
+            properties.forEach(function (propertyName) {
+                var _a;
+                _this.resolveValues(propertyName, year);
+                for (var i = 0; i < 5; i++) {
+                    var isAnnual = i === 4;
+                    var _b = _this.getPropertyBuckets(year, propertyName), bucketQuarter = _b.bucketQuarter, bucketSum = _b.bucketSum, bucketString = _b.bucketString;
+                    var value = (_a = (isAnnual ? bucketSum.get(3) : bucketQuarter.get(i))) !== null && _a !== void 0 ? _a : bucketString.get(i);
+                    var fiscalPeriod = isAnnual ? 'FY' : "Q".concat(i + 1);
+                    callback({ year: year, fiscalPeriod: fiscalPeriod, propertyName: propertyName, value: value });
+                }
+            });
+        });
+    };
+    return FactPeriodResolver;
+}());
+exports.default = FactPeriodResolver;

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

@@ -0,0 +1,10 @@
+import { FactItem } from './ReportBuilder';
+import { CompanyFactListData } from '../../types';
+/**
+ * Builds an array of fact records.
+ */
+export default class FactRecordBuilder {
+    createFacts(data: CompanyFactListData, filterDuplicates?: boolean): {
+        facts: FactItem[];
+    };
+}

package/build/services/ReportBuilder/FactRecordBuilder.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Builds an array of fact records.
+ */
+var FactRecordBuilder = /** @class */ (function () {
+    function FactRecordBuilder() {
+    }
+    FactRecordBuilder.prototype.createFacts = function (data, filterDuplicates) {
+        if (filterDuplicates === void 0) { filterDuplicates = true; }
+        var facts = data.facts, cik = data.cik;
+        var factsByKey = new Map();
+        var keyIndex = 0;
+        var createKey = function (params) {
+            if (!filterDuplicates)
+                return keyIndex++;
+            var start = params.start, end = params.end, filed = params.filed, propertyName = params.propertyName;
+            return "".concat(start !== null && start !== void 0 ? start : '', "_").concat(end, "_").concat(filed, "_").concat(propertyName);
+        };
+        for (var prefix in facts) {
+            var factByPropertyName = facts[prefix];
+            for (var propertyName in factByPropertyName) {
+                var units = factByPropertyName[propertyName].units;
+                for (var unit in units) {
+                    var factValues = units[unit];
+                    for (var _i = 0, factValues_1 = factValues; _i < factValues_1.length; _i++) {
+                        var factValue = factValues_1[_i];
+                        var end = factValue.end, start = factValue.start, val = factValue.val, filed = factValue.filed, accn = factValue.accn, form = factValue.form, fp = factValue.fp, frame = factValue.frame, fy = factValue.fy;
+                        var mapKey = createKey({ propertyName: propertyName, end: end, filed: filed, start: start });
+                        var name_1 = "".concat(prefix, ":").concat(propertyName);
+                        var item = {
+                            cik: cik,
+                            end: end,
+                            filed: filed,
+                            name: name_1,
+                            unit: unit,
+                            value: val,
+                            accn: accn,
+                        };
+                        if (start)
+                            item.start = start;
+                        if (accn)
+                            item.accn = accn;
+                        if (form)
+                            item.form = form;
+                        if (fp)
+                            item.fp = fp;
+                        if (frame)
+                            item.frame = frame;
+                        if (fy)
+                            item.fy = fy;
+                        var prevFact = factsByKey.get(mapKey);
+                        if (!prevFact) {
+                            factsByKey.set(mapKey, item);
+                            continue;
+                        }
+                        // use whichever is closer to the report end date
+                        var shouldPush = new Date(item.filed).getTime() - new Date(item.end).getTime() <
+                            new Date(prevFact.filed).getTime() - new Date(prevFact.end).getTime();
+                        if (shouldPush) {
+                            factsByKey.set(mapKey, item);
+                        }
+                    }
+                }
+            }
+        }
+        return { facts: Array.from(factsByKey.values()) };
+    };
+    return FactRecordBuilder;
+}());
+exports.default = FactRecordBuilder;

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

@@ -0,0 +1,46 @@
+import { FiscalPeriod } from '../../types/report-raw.type';
+import { FactItemWithFiscals } from './ReportBuilder';
+interface SplitData {
+    end: string;
+    filed: string;
+    value: number;
+    firstFiled: string;
+    fiscalYear: number;
+}
+type FactItemWithFiscalsNumeric = Omit<FactItemWithFiscals, 'cik' | 'value'> & {
+    value: number;
+};
+/**
+ * Adjust share-based property values for splits. Checks where the split was applied,
+ * and adjusts all previously filed share facts accordingly.
+ */
+export default class FactSplitAdjuster {
+    private readonly splitKey;
+    private readonly splitByFiscalYearAmount;
+    private readonly factsByYearQuarterByPropertyName;
+    private readonly factsAnnaulByYearByPropertyName;
+    private readonly resolvedProperties;
+    private sortedSplits;
+    private getMap;
+    add(fact: FactItemWithFiscalsNumeric): void;
+    getSplitsAsc(): SplitData[];
+    isSplitProperty(propertyName: string): boolean;
+    addSplitData(data: Omit<SplitData, 'firstFiled'>): void;
+    /**
+     * TODO: Find a more reliable way of checking if the split has already been applied.
+     */
+    private didApplySplit;
+    isSplitAdjustableUnit(unit: string): boolean;
+    isShareRatioUnit(unit: string): boolean;
+    private getSortedFacts;
+    resolveProperty(propertyName: string): void;
+    get(propertyName: string, year: number, fiscalPeriod: FiscalPeriod): number | undefined;
+    forEach(callback: (params: {
+        propertyName: string;
+        year: number;
+        fiscalPeriod: FiscalPeriod;
+        value: number;
+    }) => void): void;
+    private adjustValuesForSplits;
+}
+export {};