sec-edgar-api 0.0.1

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExpenseOperating = void 0;
+var helpers_1 = require("./helpers");
+function resolveExpenseOperating(report) {
+    var _a = report, expenseOperating = _a.expenseOperating, revenueTotal = _a.revenueTotal, revenueCost = _a.revenueCost, incomeOperating = _a.incomeOperating;
+    var nullKey = (0, helpers_1.getSingleNullKey)({ expenseOperating: expenseOperating, revenueTotal: revenueTotal, revenueCost: revenueCost, incomeOperating: incomeOperating });
+    switch (nullKey) {
+        case 'expenseOperating':
+            report.expenseOperating = revenueTotal - incomeOperating - revenueCost;
+            break;
+        case 'incomeOperating':
+            report.incomeOperating = revenueTotal - revenueCost - expenseOperating;
+            break;
+        case 'revenueCost':
+            report.revenueCost = revenueTotal - incomeOperating - expenseOperating;
+            break;
+        case 'revenueTotal':
+            report.revenueTotal = incomeOperating + expenseOperating + revenueCost;
+    }
+}
+exports.resolveExpenseOperating = resolveExpenseOperating;

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

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

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

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

package/build/services/ReportParser/resolvers/resolve-fiscal-year-cumulative-properties.d.ts

@@ -0,0 +1,5 @@
+import ReportWrapper from '../ReportWrapper';
+/**
+ * Properties where the quarters add up to FY resolved if 1 of the 5 reports is missing.
+ */
+export declare function resolveFiscalYearCumulativeProperties(report: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-fiscal-year-cumulative-properties.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFiscalYearCumulativeProperties = void 0;
+/**
+ * Properties where the quarters add up to FY resolved if 1 of the 5 reports is missing.
+ */
+function resolveFiscalYearCumulativeProperties(report) {
+    var _a = report.getReportsFiscalYearByPeriod(), FY = _a.FY, Q1 = _a.Q1, Q2 = _a.Q2, Q3 = _a.Q3, Q4 = _a.Q4;
+    if (!FY || !Q1 || !Q2 || !Q3 || !Q4)
+        return;
+    // these properties should be the same for Q4 and FY
+    matchProperty('assetNonCurrentPPEGross', Q4, FY);
+    matchProperty('assetNonCurrentPPENet', Q4, FY);
+    matchProperty('expenseDepreciationAccumulated', Q4, FY);
+    // keys that should not add up to the FY value
+    var keysToSkip = new Set([
+        'expenseDepreciationAccumulated',
+        'assetNonCurrentPPEGross',
+        'assetNonCurrentPPENet',
+        'dateFiled',
+        'dateReport',
+        'fiscalPeriod',
+        'fiscalYear',
+        'isTTM',
+        'form',
+        'sharesOutstanding',
+        'sharesOutstandingDiluted',
+    ]);
+    var reportKeys = Object.keys(Q1);
+    var keysToResolve = reportKeys.filter(function (key) {
+        var reportsWithVal = [FY, Q1, Q2, Q3, Q4].filter(function (report) {
+            return typeof report[key] === 'number' && !keysToSkip.has(key);
+        });
+        // we want to get the keys that are in 4 of the 5 reports
+        return reportsWithVal.length === 4;
+    });
+    var _loop_1 = function (key) {
+        var valueFY = FY[key];
+        // this will be the sum of the 3 quarters if a quarter is missing, and sum of 4 quarters if FY is missing
+        var sumQuarters = [Q1, Q2, Q3, Q4].reduce(function (acc, rep) { var _a; return acc + ((_a = rep === null || rep === void 0 ? void 0 : rep[key]) !== null && _a !== void 0 ? _a : 0); }, 0);
+        // if FY is missing use the sum of the 4 quarters, otherwise use FY - sum of 3 other quarters
+        if (typeof FY[key] !== 'number') {
+            ;
+            FY[key] = sumQuarters;
+        }
+        else {
+            for (var _b = 0, _c = [Q1, Q2, Q3, Q4]; _b < _c.length; _b++) {
+                var rep = _c[_b];
+                if (rep && typeof rep[key] !== 'number') {
+                    ;
+                    rep[key] = valueFY - sumQuarters;
+                    break;
+                }
+            }
+        }
+    };
+    for (var _i = 0, keysToResolve_1 = keysToResolve; _i < keysToResolve_1.length; _i++) {
+        var key = keysToResolve_1[_i];
+        _loop_1(key);
+    }
+}
+exports.resolveFiscalYearCumulativeProperties = resolveFiscalYearCumulativeProperties;
+function matchProperty(propertyName, reportA, reportB) {
+    var isReportANull = reportA[propertyName] === null;
+    var value = isReportANull ? reportB[propertyName] : reportA[propertyName];
+    if (typeof value !== 'number')
+        return;
+    reportA[propertyName] = value;
+    reportB[propertyName] = value;
+}

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

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

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

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

package/build/services/ReportParser/resolvers/resolve-q4-fiscal-year-matching-properties.d.ts

@@ -0,0 +1,5 @@
+import ReportWrapper from '../ReportWrapper';
+/**
+ * Properties that should be the same for Q4 and FY
+ */
+export declare function resolveQ4FiscalYearMatchingProperties(reportWrapper: ReportWrapper): void;

package/build/services/ReportParser/resolvers/resolve-q4-fiscal-year-matching-properties.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveQ4FiscalYearMatchingProperties = void 0;
+/**
+ * Properties that should be the same for Q4 and FY
+ */
+function resolveQ4FiscalYearMatchingProperties(reportWrapper) {
+    var _a = reportWrapper.getReportsFiscalYearByPeriod(), FY = _a.FY, Q1 = _a.Q1, Q2 = _a.Q2, Q3 = _a.Q3, Q4 = _a.Q4;
+    if (!FY || !Q1 || !Q2 || !Q3 || !Q4)
+        return;
+    // these properties should be the same for Q4 and FY
+    matchProperty('assetNonCurrentPPEGross', Q4, FY);
+    matchProperty('assetNonCurrentPPENet', Q4, FY);
+    matchProperty('expenseDepreciationAccumulated', Q4, FY);
+}
+exports.resolveQ4FiscalYearMatchingProperties = resolveQ4FiscalYearMatchingProperties;
+function matchProperty(propertyName, reportA, reportB) {
+    var isReportANull = reportA[propertyName] === null;
+    var value = isReportANull ? reportB[propertyName] : reportA[propertyName];
+    if (typeof value !== 'number')
+        return;
+    reportA[propertyName] = value;
+    reportB[propertyName] = value;
+}

package/build/services/ReportParser/resolvers/resolve-revenue-total.d.ts

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

package/build/services/ReportParser/resolvers/resolve-revenue-total.js

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

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

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ClientRequest, IncomingMessage, RequestOptions } from 'http';
+type Primitive = string | number | boolean | null | undefined;
+interface HttpClient {
+    request: (options: string | URL | RequestOptions, callback?: (res: IncomingMessage) => void) => ClientRequest;
+}
+export interface OnChunkData {
+    percentComplete: number;
+    chunk: Buffer;
+}
+export interface ClientResponse {
+    statusCode: number;
+    message: string;
+    data: Buffer | null;
+}
+export interface RequestParams {
+    url: string;
+    headers?: Record<string, string>;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    data?: string | Record<string, Primitive | object>;
+    timeout?: number;
+    onError?: (err: Error) => void;
+    onChunk?: (data: OnChunkData) => void;
+    onResponse?: (response: IncomingMessage) => void;
+    onSuccess?: (response: ClientResponse) => void;
+    resolveData?: boolean;
+}
+export interface ClientArgs {
+    httpClient: HttpClient;
+    defaultHeaders?: Record<string, string>;
+}
+export interface IClient {
+    request(params: RequestParams): Promise<ClientResponse>;
+    setDefaultHeaders?(headers: Record<string, string>): void;
+}
+export default class Client implements IClient {
+    private readonly httpClient;
+    private defaultHeaders;
+    constructor(args?: ClientArgs);
+    setDefaultHeaders(headers: Record<string, string>): void;
+    request(params: RequestParams): Promise<ClientResponse>;
+}
+export {};

package/build/services/SecEdgarApi/Client.js

@@ -0,0 +1,104 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var https = require("https");
+var Client = /** @class */ (function () {
+    function Client(args) {
+        if (args === void 0) { args = {
+            httpClient: https,
+            defaultHeaders: {
+                // this can be any user agent, just not empty
+                'User-Agent': 'Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.93 Safari/537.36 RuxitSynthetic/1.0 v1060014908909962014 t8797611264074608560 ath259cea6f altpriv cvcv=2 smf=0',
+            },
+        }; }
+        var httpClient = args.httpClient, defaultHeaders = args.defaultHeaders;
+        this.httpClient = httpClient;
+        this.defaultHeaders = defaultHeaders !== null && defaultHeaders !== void 0 ? defaultHeaders : {};
+    }
+    Client.prototype.setDefaultHeaders = function (headers) {
+        this.defaultHeaders = headers;
+    };
+    Client.prototype.request = function (params) {
+        var _this = this;
+        var url = params.url, data = params.data, headers = params.headers, onChunk = params.onChunk, onResponse = params.onResponse, onError = params.onError, onSuccess = params.onSuccess, _a = params.resolveData, resolveData = _a === void 0 ? true : _a, _b = params.method, method = _b === void 0 ? 'GET' : _b, _c = params.timeout, timeout = _c === void 0 ? 86400000 : _c;
+        var allHeaders = __assign(__assign({}, this.defaultHeaders), headers);
+        return new Promise(function (resolve, reject) {
+            var responseData = '';
+            var request = _this.httpClient.request(url, function (res) {
+                var _a, _b, _c;
+                var lengthTotal = parseInt((_a = res.headers['content-length']) !== null && _a !== void 0 ? _a : '0');
+                var lengthCurrent = 0;
+                onResponse === null || onResponse === void 0 ? void 0 : onResponse(res);
+                if (res.statusCode !== 200) {
+                    reject({
+                        statusCode: (_b = res.statusCode) !== null && _b !== void 0 ? _b : 400,
+                        message: (_c = res.statusMessage) !== null && _c !== void 0 ? _c : 'Bad Request',
+                        data: null,
+                    });
+                }
+                res.on('data', function (chunk) {
+                    lengthCurrent += chunk.length;
+                    if (resolveData) {
+                        responseData += chunk;
+                    }
+                    onChunk === null || onChunk === void 0 ? void 0 : onChunk({
+                        percentComplete: lengthCurrent / lengthTotal,
+                        chunk: Buffer.from(chunk),
+                    });
+                });
+                res.on('error', function (err) {
+                    var _a, _b;
+                    onError === null || onError === void 0 ? void 0 : onError(err);
+                    reject({
+                        statusCode: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 400,
+                        message: (_b = res.statusMessage) !== null && _b !== void 0 ? _b : 'Bad Request',
+                        data: null,
+                    });
+                });
+                res.on('end', function () {
+                    var _a, _b;
+                    var buffer = Buffer.from(responseData);
+                    var clientResponse = {
+                        statusCode: (_a = res.statusCode) !== null && _a !== void 0 ? _a : 200,
+                        message: (_b = res.statusMessage) !== null && _b !== void 0 ? _b : 'OK',
+                        data: buffer,
+                    };
+                    onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(clientResponse);
+                    resolve(clientResponse);
+                });
+            });
+            request.on('timeout', function () {
+                request.destroy();
+                reject({
+                    statusCode: null,
+                    message: 'Connection Timeout',
+                    data: null,
+                });
+            });
+            request.setTimeout(timeout, function () { return reject("timeout after ".concat(timeout, "ms")); });
+            for (var key in allHeaders) {
+                request.setHeader(key, allHeaders[key]);
+            }
+            if (data) {
+                if (typeof data === 'string')
+                    request.write(data);
+                else
+                    request.write(JSON.stringify(data));
+            }
+            request.method = method;
+            request.end();
+        });
+    };
+    return Client;
+}());
+exports.default = Client;

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

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { WriteStream } from 'fs';
+import { IClient, RequestParams } from './Client';
+export interface DownloadParams extends RequestParams {
+    filename: string;
+    createDirIfNotExists?: boolean;
+}
+export interface IDownloader {
+    download(params: DownloadParams): Promise<boolean>;
+}
+interface FileManager {
+    createWriteStream(path: string): WriteStream;
+    existsSync(path: string): boolean;
+    mkdirSync(path: string): void;
+}
+interface DownloaderArgs {
+    client: IClient;
+    fileManager: FileManager;
+}
+export default class Downlaoder implements IDownloader {
+    private readonly client;
+    private readonly fileManager;
+    constructor(args?: DownloaderArgs);
+    download(params: DownloadParams): Promise<boolean>;
+}
+export {};

package/build/services/SecEdgarApi/Downloader.js

@@ -0,0 +1,102 @@
+"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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = require("fs");
+var Client_1 = require("./Client");
+var Downlaoder = /** @class */ (function () {
+    function Downlaoder(args) {
+        if (args === void 0) { args = { client: new Client_1.default(), fileManager: fs }; }
+        var client = args.client, fileManager = args.fileManager;
+        this.client = client;
+        this.fileManager = fileManager;
+    }
+    Downlaoder.prototype.download = function (params) {
+        var _this = this;
+        var filename = params.filename, onSuccess = params.onSuccess, onError = params.onError, _a = params.createDirIfNotExists, createDirIfNotExists = _a === void 0 ? false : _a, rest = __rest(params, ["filename", "onSuccess", "onError", "createDirIfNotExists"]);
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var dir, file;
+            return __generator(this, function (_a) {
+                dir = filename.substring(0, filename.lastIndexOf('/'));
+                if (dir.length > 0 && createDirIfNotExists && !this.fileManager.existsSync(dir)) {
+                    this.fileManager.mkdirSync(dir);
+                }
+                file = this.fileManager.createWriteStream(filename);
+                file.on('close', function () { return resolve(true); });
+                file.on('finish', function () { return file.close(); });
+                file.on('error', function (err) {
+                    file.destroy();
+                    onError === null || onError === void 0 ? void 0 : onError(err);
+                    reject(false);
+                });
+                this.client
+                    .request(__assign(__assign({ onError: onError }, rest), { onResponse: function (res) {
+                        var _a;
+                        res.pipe(file);
+                        (_a = rest.onResponse) === null || _a === void 0 ? void 0 : _a.call(rest, res);
+                    } }))
+                    .then(function (res) { return onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(res); })
+                    .catch(function () { return reject(false); });
+                return [2 /*return*/];
+            });
+        }); });
+    };
+    return Downlaoder;
+}());
+exports.default = Downlaoder;

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

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { IDownloader } from './Downloader';
+import Unzipper from './Unzipper';
+interface FactsDownloaderArgs {
+    downloader: IDownloader;
+    unzipper: Unzipper;
+}
+interface OnChunkData {
+    percentComplete: number;
+    chunk: Buffer;
+    stage: 'download' | 'unzip';
+}
+export interface DownloadCompanyFactsDirectoryParams {
+    outputDirname: string;
+    unzip?: boolean;
+    onChunk?: (data: OnChunkData) => void;
+    onDownloadComplete?: () => void;
+    onComplete?: () => void;
+    onError?: (err: Error) => void;
+}
+export interface IFactsDownloader {
+    downloadCompanyFactsDirectory(params: DownloadCompanyFactsDirectoryParams): Promise<boolean>;
+}
+export default class FactsDownloader implements IFactsDownloader {
+    private readonly unzipper;
+    private readonly downloader;
+    constructor(args?: FactsDownloaderArgs);
+    downloadCompanyFactsDirectory(params: DownloadCompanyFactsDirectoryParams): Promise<boolean>;
+}
+export {};

package/build/services/SecEdgarApi/FactsDownloader.js

@@ -0,0 +1,125 @@
+"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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Downloader_1 = require("./Downloader");
+var Unzipper_1 = require("./Unzipper");
+var FactsDownloader = /** @class */ (function () {
+    function FactsDownloader(args) {
+        if (args === void 0) { args = {
+            downloader: new Downloader_1.default(),
+            unzipper: new Unzipper_1.default(),
+        }; }
+        var unzipper = args.unzipper, downloader = args.downloader;
+        this.unzipper = unzipper;
+        this.downloader = downloader;
+    }
+    FactsDownloader.prototype.downloadCompanyFactsDirectory = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var outputDirname, onChunk, onDownloadComplete, onError, onComplete, _a, unzip;
+            var _this = this;
+            return __generator(this, function (_b) {
+                outputDirname = params.outputDirname, onChunk = params.onChunk, onDownloadComplete = params.onDownloadComplete, onError = params.onError, onComplete = params.onComplete, _a = params.unzip, unzip = _a === void 0 ? true : _a;
+                // writes download and unzip progress with percentage in terminal if useWriteProgressBar is true
+                return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                        var filename, e_1;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    filename = "".concat(outputDirname, ".zip");
+                                    _a.label = 1;
+                                case 1:
+                                    _a.trys.push([1, 5, , 6]);
+                                    // download from sec
+                                    return [4 /*yield*/, this.downloader.download({
+                                            url: 'https://www.sec.gov/Archives/edgar/daily-index/xbrl/companyfacts.zip',
+                                            filename: filename,
+                                            createDirIfNotExists: true,
+                                            resolveData: false,
+                                            headers: {
+                                                'Accept-Encoding': 'gzip, deflate',
+                                            },
+                                            onError: function (err) { return reject(err); },
+                                            onChunk: onChunk ? function (data) { return onChunk === null || onChunk === void 0 ? void 0 : onChunk(__assign(__assign({}, data), { stage: 'download' })); } : undefined,
+                                        })];
+                                case 2:
+                                    // download from sec
+                                    _a.sent();
+                                    onDownloadComplete === null || onDownloadComplete === void 0 ? void 0 : onDownloadComplete();
+                                    if (!unzip) return [3 /*break*/, 4];
+                                    // unzip companyfacts.zip
+                                    return [4 /*yield*/, this.unzipper.unzip({
+                                            inputFilename: filename,
+                                            outputDirname: outputDirname,
+                                            deleteOriginal: true,
+                                            onError: function (err) { return reject(err); },
+                                            onChunk: onChunk ? function (data) { return onChunk === null || onChunk === void 0 ? void 0 : onChunk(__assign(__assign({}, data), { stage: 'unzip' })); } : undefined,
+                                        })];
+                                case 3:
+                                    // unzip companyfacts.zip
+                                    _a.sent();
+                                    _a.label = 4;
+                                case 4:
+                                    onComplete === null || onComplete === void 0 ? void 0 : onComplete();
+                                    resolve(true);
+                                    return [3 /*break*/, 6];
+                                case 5:
+                                    e_1 = _a.sent();
+                                    onError === null || onError === void 0 ? void 0 : onError(e_1);
+                                    reject(e_1);
+                                    return [3 /*break*/, 6];
+                                case 6: return [2 /*return*/];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    return FactsDownloader;
+}());
+exports.default = FactsDownloader;