sec-edgar-api 0.2.3 → 0.3.0

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 = true; }
+    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 {};

package/build/services/ReportRawBuilder/ReportRawBuilder.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FactFiscalCalculator_1 = require("./FactFiscalCalculator");
+var FactGrouper_1 = require("./FactGrouper");
+var FactRecordBuilder_1 = require("./FactRecordBuilder");
+var FactSplitAdjuster_1 = require("./FactSplitAdjuster");
+/**
+ * Builds ReportRaw objects from company facts. Adjusts for splits and resolves period values.
+ */
+var ReportRawBuilder = /** @class */ (function () {
+    function ReportRawBuilder() {
+        this.factRecordBuilder = new FactRecordBuilder_1.default();
+    }
+    ReportRawBuilder.prototype.createFacts = function (companyFacts, includeNamePrefix) {
+        if (includeNamePrefix === void 0) { includeNamePrefix = false; }
+        return this.factRecordBuilder.createFacts(companyFacts, includeNamePrefix);
+    };
+    ReportRawBuilder.prototype.createFiscalCalculator = function (params) {
+        var facts = params.facts;
+        var fiscalCalculator = new FactFiscalCalculator_1.default();
+        for (var _i = 0, facts_1 = facts; _i < facts_1.length; _i++) {
+            var fact = facts_1[_i];
+            fiscalCalculator.add(fact);
+        }
+        return fiscalCalculator;
+    };
+    ReportRawBuilder.prototype.buildReports = function (params) {
+        var facts = params.facts, reportDates = params.reportDates, splitsProp = params.splits, _a = params.resolvePeriodValues, resolvePeriodValues = _a === void 0 ? true : _a, _b = params.adjustForSplits, adjustForSplits = _b === void 0 ? true : _b;
+        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 fiscalCalculator = this.createFiscalCalculator({ facts: facts });
+        var factGrouper = new FactGrouper_1.default();
+        var factSplitAdjuster = new FactSplitAdjuster_1.default();
+        // if splits not included in params and need to adjust, extract from facts
+        var splits = adjustForSplits
+            ? splitsProp !== null && splitsProp !== void 0 ? splitsProp : factSplitAdjuster.getSplits({ splitFacts: factSplitAdjuster.filterSplitFacts({ facts: facts }) })
+            : splitsProp;
+        var _c = factGrouper.buildFactGroupsByReportKey({
+            facts: facts,
+            cik: reportsCik,
+            fiscalCalculator: fiscalCalculator,
+            resolvePeriodValues: resolvePeriodValues,
+            generateMissingGroups: false,
+            splits: splits,
+        }), factGroupsByReportKey = _c.factGroupsByReportKey, maxYear = _c.maxYear, minYear = _c.minYear;
+        return this.buildReportsFromGroups({
+            factGroupsByReportKey: factGroupsByReportKey,
+            fiscalCalculator: fiscalCalculator,
+            splits: splits,
+            minYear: minYear,
+            maxYear: maxYear,
+            cik: reportsCik,
+        });
+    };
+    ReportRawBuilder.prototype.createReportKey = function (params) {
+        var year = params.year, quarter = params.quarter, isAnnual = params.isAnnual;
+        return "".concat(year, "_").concat(isAnnual ? 'FY' : "Q".concat(quarter));
+    };
+    ReportRawBuilder.prototype.createReport = function (params) {
+        var _a;
+        var group = params.group, isAnnual = params.isAnnual, splitDate = params.splitDate, splitRatio = params.splitRatio, cik = params.cik;
+        var fiscalPeriod = isAnnual ? 'FY' : "Q".concat(group.quarter);
+        var accessionNoHyphen = (_a = group.accn) === null || _a === void 0 ? void 0 : _a.replace(/-/g, '');
+        var url = group.accn
+            ? "https://www.sec.gov/Archives/edgar/data/".concat(cik, "/").concat(accessionNoHyphen, "/").concat(group.accn, ".txt")
+            : null;
+        return {
+            cik: cik,
+            url: url,
+            dateFiled: group.reportFiled,
+            dateReport: group.reportEnd,
+            fiscalPeriod: fiscalPeriod,
+            fiscalYear: group.fiscalYear,
+            splitDate: splitDate !== null && splitDate !== void 0 ? splitDate : null,
+            splitRatio: splitRatio !== null && splitRatio !== void 0 ? splitRatio : null,
+        };
+    };
+    ReportRawBuilder.prototype.round = function (value) {
+        var multiplier = 1000000;
+        return typeof value === 'number' ? Math.round(value * multiplier) / multiplier : value;
+    };
+    ReportRawBuilder.prototype.buildReportsFromGroups = function (params) {
+        var _this = this;
+        var factGroupsByReportKey = params.factGroupsByReportKey, minYear = params.minYear, maxYear = params.maxYear, cik = params.cik, splits = params.splits, fiscalCalculator = params.fiscalCalculator;
+        var splitByFiscals = new Map();
+        var reportByKey = new Map();
+        splits === null || splits === void 0 ? void 0 : splits.forEach(function (split) {
+            var _a = fiscalCalculator.getFiscalYearQuarter({ dateStr: split.endLast }), quarter = _a.quarter, year = _a.year;
+            splitByFiscals.set("".concat(year, "_").concat(quarter), split);
+        });
+        factGroupsByReportKey.forEach(function (groups) {
+            var _a, _b, _c, _d, _e, _f;
+            var groupWithDates = groups.find(function (g) { return g.reportEnd; });
+            if (!groupWithDates)
+                return;
+            var split = splitByFiscals.get("".concat(groupWithDates.fiscalYear, "_").concat(groupWithDates.quarter));
+            var splitDate = (_a = split === null || split === void 0 ? void 0 : split.endLast) !== null && _a !== void 0 ? _a : null;
+            var splitRatio = (_b = split === null || split === void 0 ? void 0 : split.splitRatio) !== null && _b !== void 0 ? _b : null;
+            var quarter = groupWithDates.quarter;
+            var reportPeriod = _this.createReport({
+                group: groupWithDates,
+                cik: cik,
+                isAnnual: false,
+                splitDate: splitDate,
+                splitRatio: splitRatio,
+            });
+            var reportKeyPeriod = _this.createReportKey({
+                year: reportPeriod.fiscalYear,
+                quarter: quarter,
+                isAnnual: false,
+            });
+            for (var _i = 0, groups_1 = groups; _i < groups_1.length; _i++) {
+                var group = groups_1[_i];
+                var value = (_d = (_c = group.valuePeriodResolved) !== null && _c !== void 0 ? _c : group.valuePeriodFirst) !== null && _d !== void 0 ? _d : 0;
+                reportPeriod[group.name] = _this.round(value);
+            }
+            reportByKey.set(reportKeyPeriod, reportPeriod);
+            if (quarter !== 4)
+                return;
+            var reportAnnual = _this.createReport({
+                group: groupWithDates,
+                cik: cik,
+                isAnnual: true,
+                splitDate: splitDate,
+                splitRatio: splitRatio,
+            });
+            var reportKeyAnnual = "".concat(reportAnnual.fiscalYear, "_").concat(reportAnnual.fiscalPeriod);
+            for (var _g = 0, groups_2 = groups; _g < groups_2.length; _g++) {
+                var group = groups_2[_g];
+                var value = (_f = (_e = group.valueTrailingResolved) !== null && _e !== void 0 ? _e : group.valueTrailingFirst) !== null && _f !== void 0 ? _f : 0;
+                reportAnnual[group.name] = _this.round(value);
+            }
+            reportByKey.set(reportKeyAnnual, reportAnnual);
+        });
+        var reports = [];
+        for (var year = minYear; year <= maxYear; year++) {
+            for (var quarter = 1; quarter <= 5; quarter++) {
+                var isAnnual = quarter === 5;
+                var reportKey = this.createReportKey({ year: year, quarter: isAnnual ? 4 : quarter, isAnnual: isAnnual });
+                var report = reportByKey.get(reportKey);
+                if (report) {
+                    reports.push(report);
+                }
+            }
+        }
+        return reports;
+    };
+    return ReportRawBuilder;
+}());
+exports.default = ReportRawBuilder;

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

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

package/build/services/ReportRawBuilder/index.js

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

package/build/services/SecEdgarApi/SecEdgarApi.d.ts

@@ -25,11 +25,19 @@ export interface GetSymbolParams {
     /** symbol or cik */
     symbol: string | number;
 }
-export interface GetReportsParams {
+export interface GetReportsRawParams {
+    symbol: string | number;
+    includeNamePrefix?: boolean;
+    adjustForSplits?: boolean;
+    resolvePeriodValues?: boolean;
+}
+export interface GetReportsParams extends Omit<GetReportsRawParams, 'includeNamePrefix'> {
     /** symbol or cik */
     symbol: string | number;
     withWrapper?: boolean;
     usePropertyResolver?: boolean;
+    adjustForSplits?: boolean;
+    resolvePeriodValues?: boolean;
 }
 export interface GetFactParams {
     /** symbol or cik */
@@ -138,7 +146,7 @@ export default class SecEdgarApi {
      * Parses reports from company facts. Calculates missing properties and uses a single interface
      * for all reports.
      */
-    getReportsRaw(params: GetSymbolParams): Promise<ReportRaw[]>;
+    getReportsRaw(params: GetReportsRawParams): Promise<ReportRaw[]>;
     /**
      * Gets a list of all tickers and CIKs from `https://www.sec.gov/files/company_tickers.json`
      *

package/build/services/SecEdgarApi/SecEdgarApi.js

@@ -1,4 +1,15 @@
 "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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -251,15 +262,15 @@ var SecEdgarApi = /** @class */ (function () {
      */
     SecEdgarApi.prototype.getReports = function (params) {
         return __awaiter(this, void 0, void 0, function () {
-            var symbol, _a, withWrapper, _b, usePropertyResolver, facts, reports;
+            var _a, withWrapper, _b, usePropertyResolver, reportsRaw, reports;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        symbol = params.symbol, _a = params.withWrapper, withWrapper = _a === void 0 ? false : _a, _b = params.usePropertyResolver, usePropertyResolver = _b === void 0 ? true : _b;
-                        return [4 /*yield*/, this.getFacts({ symbol: symbol })];
+                        _a = params.withWrapper, withWrapper = _a === void 0 ? false : _a, _b = params.usePropertyResolver, usePropertyResolver = _b === void 0 ? true : _b;
+                        return [4 /*yield*/, this.getReportsRaw(__assign(__assign({}, params), { includeNamePrefix: false }))];
                     case 1:
-                        facts = _c.sent();
-                        reports = this.reportParser.parseReports(facts, usePropertyResolver);
+                        reportsRaw = _c.sent();
+                        reports = this.reportParser.parseReportsFromRaw(reportsRaw, usePropertyResolver);
                         return [2 /*return*/, withWrapper ? reports : reports.map(function (report) { return report.getReport(); })];
                 }
             });
@@ -271,13 +282,20 @@ var SecEdgarApi = /** @class */ (function () {
      */
     SecEdgarApi.prototype.getReportsRaw = function (params) {
         return __awaiter(this, void 0, void 0, function () {
-            var facts;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getFacts(params)];
+            var symbol, _a, includeNamePrefix, _b, adjustForSplits, _c, resolvePeriodValues, companyFacts, reports;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        symbol = params.symbol, _a = params.includeNamePrefix, includeNamePrefix = _a === void 0 ? false : _a, _b = params.adjustForSplits, adjustForSplits = _b === void 0 ? true : _b, _c = params.resolvePeriodValues, resolvePeriodValues = _c === void 0 ? true : _c;
+                        return [4 /*yield*/, this.getFacts({ symbol: symbol })];
                     case 1:
-                        facts = _a.sent();
-                        return [2 /*return*/, this.reportParser.parseReportsRaw(facts)];
+                        companyFacts = _d.sent();
+                        reports = this.reportParser.parseReportsRaw(companyFacts, {
+                            adjustForSplits: adjustForSplits,
+                            resolvePeriodValues: resolvePeriodValues,
+                            includeNamePrefix: includeNamePrefix,
+                        });
+                        return [2 /*return*/, reports];
                 }
             });
         });