sec-edgar-api 0.2.4 → 0.3.1

package/build/services/{ReportBuilder → ReportRawBuilder}/FactPeriodResolver.js

@@ -1,6 +1,5 @@
 "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
@@ -21,9 +20,34 @@ var FactPeriodResolver = /** @class */ (function () {
         /** prevent values from being added multiple times */
         this.resolvedValues = new Set();
         this.unresolvedReports = new Map();
-        var cik = args.cik;
+        var cik = args.cik, _a = args.preferOriginalFilingValues, preferOriginalFilingValues = _a === void 0 ? false : _a;
         this.cik = cik;
+        this.preferOriginalFilingValues = preferOriginalFilingValues;
     }
+    /**
+     * Some properties have a start and end that represent a period average, rather than a period total.
+     * These properties should be treated as instantaneous properties, meaning
+     * the value for Q4 and FY should be the same.
+     *
+     * I believe the only properties like this are share related:
+     * us-gaap:WeightedAverageNumberOfDilutedSharesOutstanding and us-gaap:WeightedAverageNumberOfSharesOutstandingBasic.
+     * May need to update this in the future if there are more
+     */
+    FactPeriodResolver.isAverageShares = function (params) {
+        var propertyName = params.propertyName;
+        return (propertyName.includes('Average') &&
+            (propertyName.includes('SharesOutstanding') || propertyName.includes('SharesIssued')));
+    };
+    FactPeriodResolver.prototype.isAverageShares = function (params) {
+        return FactPeriodResolver.isAverageShares(params);
+    };
+    /**
+     * Used to check if this should potentially overwrite a value that has already been set.
+     */
+    FactPeriodResolver.prototype.isPreferredValue = function (params) {
+        var bucket = params.bucket, end = params.end, filed = params.filed, bucketIndex = params.bucketIndex;
+        return !bucket.has(bucketIndex) || this.preferOriginalFilingValues || !this.isOriginalFiling({ end: end, filed: filed });
+    };
     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);
@@ -49,8 +73,8 @@ var FactPeriodResolver = /** @class */ (function () {
             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;
+            var sumValue = (_b = unresolvedReport === null || unresolvedReport === void 0 ? void 0 : unresolvedReport[propertyName]) !== null && _b !== void 0 ? _b : 0;
+            var prevSum = (_c = unresolvedReportPrev === null || unresolvedReportPrev === void 0 ? void 0 : unresolvedReportPrev[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));
@@ -82,7 +106,13 @@ var FactPeriodResolver = /** @class */ (function () {
         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) {
+    /**
+     * 0, 3, 6, 9, or 12 month period. 0 is instantaneous data that doesn't have a time period, (ex: assets)
+     * other facts have values that are for a period of time. (like revenue over the last 6 months).
+     *
+     * Use periods 0 and 3 for quarterly reports and 0 and 12 for annual reports.
+     */
+    FactPeriodResolver.getPeriod = function (params) {
         var start = params.start, end = params.end;
         if (!start || start === end)
             return 0;
@@ -96,11 +126,14 @@ var FactPeriodResolver = /** @class */ (function () {
             return 9;
         return 12;
     };
+    FactPeriodResolver.prototype.getPeriod = function (params) {
+        return FactPeriodResolver.getPeriod(params);
+    };
     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({
+        var report = (_a = this.unresolvedReports.get(key)) !== null && _a !== void 0 ? _a : {
             cik: this.cik,
             fiscalYear: year,
             fiscalPeriod: quarter === 4 ? 'FY' : "Q".concat(quarter),
@@ -109,35 +142,54 @@ var FactPeriodResolver = /** @class */ (function () {
             url: null,
             splitDate: null,
             splitRatio: null,
-        });
+        };
         if (!this.unresolvedReports.has(key)) {
             this.unresolvedReports.set(key, report);
         }
         return report;
     };
+    /**
+     * True if the filed date is within 60 days of the end date. This indicates that it is likely
+     * the original filing of the fact because filers are required to submit within 45 days of the
+     * period end, and subsequent reports are filed 90 days apart.
+     */
+    FactPeriodResolver.prototype.isOriginalFiling = function (params) {
+        var end = params.end, filed = params.filed;
+        var DAY_60_MS = 5184000000;
+        return new Date(filed).getTime() - new Date(end).getTime() < DAY_60_MS;
+    };
     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 });
+        var bucketIndex = quarter - 1;
+        var period = this.isAverageShares({ propertyName: propertyName }) ? 0 : 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);
+            if (this.isPreferredValue({ bucket: bucket, bucketIndex: bucketIndex, end: end, filed: filed })) {
+                bucket.set(bucketIndex, 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);
+            if (this.isPreferredValue({ bucket: bucket, bucketIndex: bucketIndex, end: end, filed: filed })) {
+                bucket.set(bucketIndex, value);
+                bucketSum.set(bucketIndex, value);
+            }
             return;
         }
         if (period === 3) {
             var bucket = this.getOrSetBucketArr(this.valueByQuarterByPropertyByYear, year, propertyName);
-            bucket.set(quarter - 1, value);
+            if (this.isPreferredValue({ bucket: bucket, bucketIndex: bucketIndex, end: end, filed: filed })) {
+                bucket.set(bucketIndex, value);
+            }
         }
         if (quarter === 1 || period > 3) {
             var bucket = this.getOrSetBucketArr(this.sumByQuarterByPropertyByYear, year, propertyName);
-            bucket.set(quarter - 1, value);
+            if (this.isPreferredValue({ bucket: bucket, bucketIndex: bucketIndex, end: end, filed: filed })) {
+                bucket.set(bucketIndex, value);
+            }
         }
         this.addPropertyByYear(this.propertiesResolvableByYear, year, propertyName);
     };
@@ -163,7 +215,7 @@ var FactPeriodResolver = /** @class */ (function () {
                     if (value === undefined)
                         continue;
                     var report = _this.getOrSetReport({ year: year, quarter: i + 1 });
-                    report.report[propertyName] = value;
+                    report[propertyName] = value;
                 }
             });
         });
@@ -173,14 +225,24 @@ var FactPeriodResolver = /** @class */ (function () {
         this.buildUnresolvedReports();
         this.propertiesByYear.forEach(function (properties, year) {
             properties.forEach(function (propertyName) {
-                var _a;
+                var _a, _b;
                 _this.resolveValues(propertyName, year);
-                for (var i = 0; i < 5; i++) {
+                for (var i = 0; i < 4; 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 });
+                    var _c = _this.getPropertyBuckets(year, propertyName), bucketQuarter = _c.bucketQuarter, bucketSum = _c.bucketSum, bucketString = _c.bucketString;
+                    var valueQuarter = (_a = bucketQuarter.get(i)) !== null && _a !== void 0 ? _a : bucketString.get(i);
+                    var valueTrailing = bucketSum.get(i);
+                    var value = (_b = (isAnnual ? bucketSum.get(3) : bucketQuarter.get(i))) !== null && _b !== void 0 ? _b : bucketString.get(i);
+                    var quarter = i + 1;
+                    callback({
+                        year: year,
+                        fiscalPeriod: "Q".concat(quarter),
+                        propertyName: propertyName,
+                        value: value,
+                        quarter: quarter,
+                        valueQuarter: valueQuarter,
+                        valueTrailing: valueTrailing,
+                    });
                 }
             });
         });

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

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

package/build/services/{ReportBuilder → ReportRawBuilder}/FactRecordBuilder.js

@@ -6,17 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var FactRecordBuilder = /** @class */ (function () {
     function FactRecordBuilder() {
     }
-    FactRecordBuilder.prototype.createFacts = function (data, filterDuplicates) {
-        if (filterDuplicates === void 0) { filterDuplicates = false; }
+    FactRecordBuilder.prototype.createFacts = function (data, includeNamePrefix) {
+        if (includeNamePrefix === void 0) { includeNamePrefix = 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);
-        };
+        var factItems = [];
         for (var prefix in facts) {
             var factByPropertyName = facts[prefix];
             for (var propertyName in factByPropertyName) {
@@ -26,8 +19,7 @@ var FactRecordBuilder = /** @class */ (function () {
                     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 name_1 = includeNamePrefix ? "".concat(prefix, ":").concat(propertyName) : propertyName;
                         var item = {
                             cik: cik,
                             end: end,
@@ -49,22 +41,12 @@ var FactRecordBuilder = /** @class */ (function () {
                             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);
-                        }
+                        factItems.push(item);
                     }
                 }
             }
         }
-        return { facts: Array.from(factsByKey.values()) };
+        return { facts: factItems };
     };
     return FactRecordBuilder;
 }());

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

@@ -0,0 +1,43 @@
+import { CompanyFactListData, FactGroup, FactItem, FactValue, SplitData } from '../../types';
+/**
+ * Splits can be filed multiple times throughout different reports. There is no clear
+ * indication on when the split is executed or what facts the split has been applied to. This
+ * class tries to determine which splits have been applied and which need to be adjusted for
+ * each fact.
+ */
+export default class FactSplitAdjuster {
+    private readonly keySplit;
+    private preferFirstValue;
+    private getGroupValue;
+    getSplits(params: {
+        splitFacts: FactValue[] | FactItem[];
+    }): SplitData[];
+    filterSplitFacts(params: {
+        facts: FactItem[];
+    }): FactItem[];
+    extractSplitsFromCompanyFacts(params: {
+        companyFactList: Pick<CompanyFactListData, 'facts'>;
+    }): FactValue[];
+    getSplitsFromCompanyFacts(params: {
+        companyFactList: Pick<CompanyFactListData, 'facts'>;
+    }): SplitData[];
+    /**
+     * Returns true if the fact value was adjusted, false if it was not,
+     * and null if the comparison does not match the split
+     */
+    private isAdjustedFromComparedFact;
+    /**
+     * Splits can be filed multiple times throughout different reports.
+     */
+    didApplySplit(params: {
+        isShareRatio: boolean;
+        split: SplitData;
+        factGroup: FactGroup;
+        isTrailing: boolean;
+        useOppositePeriodFallback?: boolean;
+    }): boolean;
+    adjustForSplits(params: {
+        factGroups: FactGroup[];
+        splits: SplitData[];
+    }): void;
+}

package/build/services/ReportRawBuilder/FactSplitAdjuster.js

@@ -0,0 +1,242 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var FactPeriodResolver_1 = require("./FactPeriodResolver");
+/**
+ * Splits can be filed multiple times throughout different reports. There is no clear
+ * indication on when the split is executed or what facts the split has been applied to. This
+ * class tries to determine which splits have been applied and which need to be adjusted for
+ * each fact.
+ */
+var FactSplitAdjuster = /** @class */ (function () {
+    function FactSplitAdjuster() {
+        this.keySplit = 'StockholdersEquityNoteStockSplitConversionRatio1';
+        this.preferFirstValue = true;
+    }
+    FactSplitAdjuster.prototype.getGroupValue = function (factGroup, isTrailing) {
+        if (isTrailing) {
+            return Number(this.preferFirstValue ? factGroup.valueTrailingFirst : factGroup.valueTrailingLast);
+        }
+        else {
+            return Number(this.preferFirstValue ? factGroup.valuePeriodFirst : factGroup.valuePeriodLast);
+        }
+    };
+    FactSplitAdjuster.prototype.getSplits = function (params) {
+        var _a, _b;
+        var splitFacts = __spreadArray([], params.splitFacts, true).sort(function (a, b) { return (a.end < b.end ? -1 : 1); });
+        var YEAR_MS = 31536000000;
+        var splits = [];
+        var currentSplit = null;
+        for (var i = 0; i < splitFacts.length; i++) {
+            var prevFact = splitFacts[i - 1];
+            var fact = splitFacts[i];
+            var factValue = Number((_a = fact.value) !== null && _a !== void 0 ? _a : fact.val);
+            var factValuePrev = Number((_b = prevFact === null || prevFact === void 0 ? void 0 : prevFact.value) !== null && _b !== void 0 ? _b : prevFact === null || prevFact === void 0 ? void 0 : prevFact.val);
+            var isSameSplitLaterFiling = factValue === factValuePrev && new Date(fact.end).getTime() - new Date(prevFact.end).getTime() < YEAR_MS;
+            if (!isSameSplitLaterFiling && currentSplit) {
+                splits.push(currentSplit);
+                currentSplit = null;
+            }
+            if (!currentSplit) {
+                currentSplit = {
+                    endFirst: fact.end,
+                    endLast: fact.end,
+                    filedFirst: fact.filed,
+                    filedLast: fact.filed,
+                    splitRatio: factValue,
+                };
+            }
+            else {
+                currentSplit.endFirst = fact.end < currentSplit.endFirst ? fact.end : currentSplit.endFirst;
+                currentSplit.endLast = fact.end > currentSplit.endLast ? fact.end : currentSplit.endLast;
+                currentSplit.filedFirst = fact.filed < currentSplit.filedFirst ? fact.filed : currentSplit.filedFirst;
+                currentSplit.filedLast = fact.filed > currentSplit.filedLast ? fact.filed : currentSplit.filedLast;
+            }
+        }
+        if (currentSplit) {
+            splits.push(currentSplit);
+        }
+        return splits;
+    };
+    FactSplitAdjuster.prototype.filterSplitFacts = function (params) {
+        var _this = this;
+        var facts = params.facts;
+        return facts.filter(function (f) { return f.name.endsWith(_this.keySplit); });
+    };
+    FactSplitAdjuster.prototype.extractSplitsFromCompanyFacts = function (params) {
+        var _a, _b, _c;
+        var companyFactList = params.companyFactList;
+        var factsByName = (_a = companyFactList.facts['us-gaap']) !== null && _a !== void 0 ? _a : {};
+        return (_c = (_b = factsByName[this.keySplit]) === null || _b === void 0 ? void 0 : _b.units.pure) !== null && _c !== void 0 ? _c : [];
+    };
+    FactSplitAdjuster.prototype.getSplitsFromCompanyFacts = function (params) {
+        var _a, _b, _c;
+        var companyFactList = params.companyFactList;
+        var factsByName = (_a = companyFactList.facts['us-gaap']) !== null && _a !== void 0 ? _a : {};
+        var splitFacts = __spreadArray([], ((_c = (_b = factsByName[this.keySplit]) === null || _b === void 0 ? void 0 : _b.units.pure) !== null && _c !== void 0 ? _c : []), true).sort(function (a, b) { return (a.end < b.end ? -1 : 1); });
+        var YEAR_MS = 31536000000;
+        var splits = [];
+        var currentSplit = null;
+        for (var i = 0; i < splitFacts.length; i++) {
+            var prevFact = splitFacts[i - 1];
+            var fact = splitFacts[i];
+            // Assume the split is executed within the first year of the first filing...
+            // sometimes a company will file the split fact mentioning that they plan on executing it later in the fiscal year
+            // (ex: when Google did their 20:1 split in July of 2020)
+            var isSameSplitLaterFiling = fact.val === (prevFact === null || prevFact === void 0 ? void 0 : prevFact.val) && new Date(fact.end).getTime() - new Date(prevFact.end).getTime() < YEAR_MS;
+            if (!isSameSplitLaterFiling && currentSplit) {
+                splits.push(currentSplit);
+                currentSplit = null;
+            }
+            if (!currentSplit) {
+                currentSplit = {
+                    endFirst: fact.end,
+                    endLast: fact.end,
+                    filedFirst: fact.filed,
+                    filedLast: fact.filed,
+                    splitRatio: Number(fact.val),
+                };
+            }
+            else {
+                currentSplit.endFirst = fact.end < currentSplit.endFirst ? fact.end : currentSplit.endFirst;
+                currentSplit.endLast = fact.end > currentSplit.endLast ? fact.end : currentSplit.endLast;
+                currentSplit.filedFirst = fact.filed < currentSplit.filedFirst ? fact.filed : currentSplit.filedFirst;
+                currentSplit.filedLast = fact.filed > currentSplit.filedLast ? fact.filed : currentSplit.filedLast;
+            }
+        }
+        if (currentSplit) {
+            splits.push(currentSplit);
+        }
+        return splits;
+    };
+    /**
+     * Returns true if the fact value was adjusted, false if it was not,
+     * and null if the comparison does not match the split
+     */
+    FactSplitAdjuster.prototype.isAdjustedFromComparedFact = function (params) {
+        var _a, _b;
+        var factCompare = params.factCompare, factValue = params.factValue, isShareRatio = params.isShareRatio, splitVal = params.splitVal;
+        var minValue = Math.min(factValue, Number((_a = factCompare === null || factCompare === void 0 ? void 0 : factCompare.value) !== null && _a !== void 0 ? _a : factValue));
+        var maxValue = Math.max(factValue, Number((_b = factCompare === null || factCompare === void 0 ? void 0 : factCompare.value) !== null && _b !== void 0 ? _b : factValue));
+        var possiblePreSplitValue = isShareRatio ? maxValue : minValue;
+        var possiblePostSplitValue = isShareRatio ? minValue : maxValue;
+        var expectedPostSplitValue = isShareRatio
+            ? possiblePreSplitValue / splitVal
+            : possiblePreSplitValue * splitVal;
+        var nearnessThreshold = 0.01;
+        var isSplitAdjustment = Math.abs(expectedPostSplitValue - possiblePostSplitValue) < nearnessThreshold;
+        return isSplitAdjustment ? possiblePostSplitValue === factValue : null;
+    };
+    /**
+     * Splits can be filed multiple times throughout different reports.
+     */
+    FactSplitAdjuster.prototype.didApplySplit = function (params) {
+        var isShareRatio = params.isShareRatio, factGroup = params.factGroup, split = params.split, isTrailing = params.isTrailing, _a = params.useOppositePeriodFallback, useOppositePeriodFallback = _a === void 0 ? true : _a;
+        var splitVal = split.splitRatio;
+        if (!splitVal)
+            return true;
+        // these first two criteria will take care of the majority of cases...
+        if (factGroup.filedFirst > split.filedLast) {
+            return true;
+        }
+        if (factGroup.filedLast < split.filedFirst) {
+            return false;
+        }
+        var resolvedFact = factGroup.facts.find(function (f) {
+            return isTrailing ? f.value === factGroup.valueTrailingFirst : f.value === factGroup.valuePeriodFirst;
+        });
+        if (!resolvedFact && useOppositePeriodFallback) {
+            return this.didApplySplit(__assign(__assign({}, params), { isTrailing: !isTrailing, useOppositePeriodFallback: false }));
+        }
+        var refiledFacts = factGroup.facts.filter(function (f) {
+            var period = FactPeriodResolver_1.default.getPeriod(f);
+            var isSamePeriod = isTrailing ? period === 0 || period > 3 : period <= 3;
+            return f !== resolvedFact && isSamePeriod;
+        });
+        // check if one of the filed facts is the split adjustment
+        for (var _i = 0, refiledFacts_1 = refiledFacts; _i < refiledFacts_1.length; _i++) {
+            var fact = refiledFacts_1[_i];
+            var isAdjusted = this.isAdjustedFromComparedFact({
+                factCompare: fact,
+                factValue: Number(resolvedFact === null || resolvedFact === void 0 ? void 0 : resolvedFact.value),
+                isShareRatio: isShareRatio,
+                splitVal: splitVal,
+            });
+            if (isAdjusted !== null) {
+                return isAdjusted;
+            }
+        }
+        if ((resolvedFact === null || resolvedFact === void 0 ? void 0 : resolvedFact.filed) > split.filedLast) {
+            return true;
+        }
+        if ((resolvedFact === null || resolvedFact === void 0 ? void 0 : resolvedFact.filed) < split.filedFirst) {
+            return false;
+        }
+        // // if the filed date of the fact overlaps with the filed date of the split, try comparing the end dates
+        if (factGroup.endLast < split.endFirst && factGroup.values.length === 1) {
+            return false;
+        }
+        // if we still don't know, see if the split value puts us closer to the last known value or further
+        if (factGroup.valuePeriodLast !== null) {
+            var val = this.getGroupValue(factGroup, isTrailing);
+            var valueWithSplit = isShareRatio ? val / splitVal : val * splitVal;
+            return Math.abs(factGroup.valuePeriodLast - val) < Math.abs(factGroup.valuePeriodLast - valueWithSplit);
+        }
+        if (factGroup.valueTrailingLast !== null) {
+            var val = this.getGroupValue(factGroup, isTrailing);
+            var valueWithSplit = isShareRatio ? val / splitVal : val * splitVal;
+            return Math.abs(factGroup.valueTrailingLast - val) < Math.abs(factGroup.valueTrailingLast - valueWithSplit);
+        }
+        return true;
+    };
+    FactSplitAdjuster.prototype.adjustForSplits = function (params) {
+        var factGroups = params.factGroups, splits = params.splits;
+        for (var _i = 0, factGroups_1 = factGroups; _i < factGroups_1.length; _i++) {
+            var factGroup = factGroups_1[_i];
+            var unitLower = factGroup.unit.toLowerCase();
+            if (!unitLower.includes('share'))
+                continue;
+            var isShareRatio = unitLower !== 'shares';
+            for (var _a = 0, splits_1 = splits; _a < splits_1.length; _a++) {
+                var split = splits_1[_a];
+                var factValuePeriod = this.getGroupValue(factGroup, false);
+                var factValueTrailing = this.getGroupValue(factGroup, true);
+                var splitValue = split.splitRatio;
+                if (!splitValue)
+                    continue;
+                // ratios (like EPS) get divided by splits, share counts get multiplied (like shares outstanding).
+                if (!this.didApplySplit({ factGroup: factGroup, split: split, isShareRatio: isShareRatio, isTrailing: false })) {
+                    factGroup.valueSplitAdjustedPeriod = isShareRatio
+                        ? factValuePeriod / splitValue
+                        : factValuePeriod * splitValue;
+                }
+                if (!this.didApplySplit({ factGroup: factGroup, split: split, isShareRatio: isShareRatio, isTrailing: true })) {
+                    factGroup.valueSplitAdjustedTrailing = isShareRatio
+                        ? factValueTrailing / splitValue
+                        : factValueTrailing * splitValue;
+                }
+            }
+        }
+    };
+    return FactSplitAdjuster;
+}());
+exports.default = FactSplitAdjuster;

package/build/services/ReportRawBuilder/ReportRawBuilder.d.ts

@@ -0,0 +1,39 @@
+import { CompanyFactListData, FactGroup, FactItem, ReportRaw, SplitData } from '../../types';
+import FactFiscalCalculator, { SetReportDatesParams } from './FactFiscalCalculator';
+interface BuildReportsParams {
+    facts: FactItem[];
+    /**
+     * for more accurate dates, add this. Otherwise, dates will be inferred
+     * using the fact periods. The filing and report dates can be found in the SubmissionList (segEdgarApi.getSubmissions)
+     */
+    reportDates?: SetReportDatesParams[];
+    /**
+     * Splits will be extracted from facts if not provided.
+     */
+    splits?: SplitData[];
+    resolvePeriodValues?: boolean;
+    adjustForSplits?: boolean;
+}
+/**
+ * Builds ReportRaw objects from company facts. Adjusts for splits and resolves period values.
+ */
+export default class ReportRawBuilder {
+    private readonly factRecordBuilder;
+    createFacts(companyFacts: CompanyFactListData, includeNamePrefix?: boolean): {
+        facts: FactItem[];
+    };
+    private createFiscalCalculator;
+    buildReports(params: BuildReportsParams): ReportRaw[];
+    private createReportKey;
+    private createReport;
+    private round;
+    buildReportsFromGroups(params: {
+        factGroupsByReportKey: Map<string, FactGroup[]>;
+        fiscalCalculator: FactFiscalCalculator;
+        splits?: SplitData[];
+        minYear: number;
+        maxYear: number;
+        cik: number;
+    }): ReportRaw[];
+}
+export {};