@dignetwork/dig-sdk 0.0.1-alpha.17 → 0.0.1-alpha.170

package/dist/utils/FileTransfer.d.ts

@@ -0,0 +1,47 @@
+import { Readable } from "stream";
+export declare class FileTransfer {
+    private static certPath;
+    private static keyPath;
+    constructor();
+    /** ------------------------ UPLOAD FUNCTIONALITY ------------------------ **/
+    /**
+     * Upload a file to the server using a stream.
+     * @param filePath - Local path of the file.
+     * @param uploadUrl - Server URL to upload the file.
+     * @param headers - Additional headers for the request.
+     * @returns Promise<void>
+     */
+    uploadFile(filePath: string, uploadUrl: string, headers: Record<string, string>): Promise<void>;
+    /**
+     * Perform a POST request.
+     * @param url - The URL to POST to.
+     * @param data - Data to send.
+     * @param headers - Headers for the POST request.
+     * @returns Promise<void>
+     */
+    postRequest(url: string, data: string, headers: Record<string, string>): Promise<void>;
+    /** ------------------------ DOWNLOAD FUNCTIONALITY ------------------------ **/
+    /**
+     * Download data from a URL.
+     * @param url - The URL to download data from.
+     * @returns Promise<string>
+     */
+    downloadData(url: string): Promise<string>;
+    /**
+     * Stream data from a URL.
+     * @param url - The URL to stream data from.
+     * @returns Promise<Readable>
+     */
+    streamData(url: string): Promise<Readable>;
+    /** ------------------------ HEAD REQUEST FUNCTIONALITY ------------------------ **/
+    /**
+     * Perform a HEAD request to check if a resource exists on the server.
+     * @param url - The URL to check.
+     * @returns Promise<{ success: boolean; headers?: Record<string, string> }>
+     */
+    headRequest(url: string): Promise<{
+        success: boolean;
+        headers?: Record<string, string>;
+    }>;
+}
+//# sourceMappingURL=FileTransfer.d.ts.map

package/dist/utils/FileTransfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileTransfer.d.ts","sourceRoot":"","sources":["../../src/utils/FileTransfer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAElC,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;;IAU/B,8EAA8E;IAE9E;;;;;;OAMG;IACU,UAAU,CACrB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC;IA0ChB;;;;;;OAMG;IACU,WAAW,CACtB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC;IAsChB,gFAAgF;IAEhF;;;;OAIG;IACU,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA0CvD;;;;OAIG;IACU,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAuCvD,oFAAoF;IAEpF;;;;OAIG;IACU,WAAW,CACtB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;CA8BnE"}

package/dist/utils/FileTransfer.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTransfer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const url_1 = require("url");
+const ssl_1 = require("../utils/ssl");
+class FileTransfer {
+    constructor() {
+        if (!FileTransfer.certPath || !FileTransfer.keyPath) {
+            const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+            FileTransfer.certPath = certPath;
+            FileTransfer.keyPath = keyPath;
+        }
+    }
+    /** ------------------------ UPLOAD FUNCTIONALITY ------------------------ **/
+    /**
+     * Upload a file to the server using a stream.
+     * @param filePath - Local path of the file.
+     * @param uploadUrl - Server URL to upload the file.
+     * @param headers - Additional headers for the request.
+     * @returns Promise<void>
+     */
+    async uploadFile(filePath, uploadUrl, headers) {
+        const fileStream = fs_1.default.createReadStream(filePath);
+        const fileSize = fs_1.default.statSync(filePath).size;
+        return new Promise((resolve, reject) => {
+            const url = new url_1.URL(uploadUrl);
+            const options = {
+                hostname: url.hostname,
+                port: url.port || 443,
+                path: url.pathname,
+                method: "PUT",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/octet-stream",
+                    "Content-Length": fileSize,
+                },
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Upload failed with status ${res.statusCode}: ${res.statusMessage}`));
+                }
+            });
+            req.on("error", (err) => reject(err));
+            fileStream.pipe(req);
+            fileStream.on("error", (err) => reject(err));
+        });
+    }
+    /**
+     * Perform a POST request.
+     * @param url - The URL to POST to.
+     * @param data - Data to send.
+     * @param headers - Headers for the POST request.
+     * @returns Promise<void>
+     */
+    async postRequest(url, data, headers) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 443,
+                path: urlObj.pathname,
+                method: "POST",
+                headers: {
+                    ...headers,
+                    "Content-Type": "application/json",
+                    "Content-Length": Buffer.byteLength(data),
+                },
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`POST request failed with status ${res.statusCode}: ${res.statusMessage}`));
+                }
+            });
+            req.on("error", (err) => reject(err));
+            req.write(data);
+            req.end();
+        });
+    }
+    /** ------------------------ DOWNLOAD FUNCTIONALITY ------------------------ **/
+    /**
+     * Download data from a URL.
+     * @param url - The URL to download data from.
+     * @returns Promise<string>
+     */
+    async downloadData(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 443,
+                path: urlObj.pathname + urlObj.search,
+                method: "GET",
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                let data = "";
+                if (res.statusCode === 200) {
+                    res.on("data", (chunk) => (data += chunk));
+                    res.on("end", () => resolve(data));
+                }
+                else if (res.statusCode === 301 || res.statusCode === 302) {
+                    const redirectUrl = res.headers.location;
+                    if (redirectUrl) {
+                        this.downloadData(redirectUrl).then(resolve).catch(reject);
+                    }
+                    else {
+                        reject(new Error("Redirected without a location header"));
+                    }
+                }
+                else {
+                    reject(new Error(`Failed to retrieve data from ${url}. Status code: ${res.statusCode}`));
+                }
+            });
+            req.on("error", (error) => reject(error));
+            req.end();
+        });
+    }
+    /**
+     * Stream data from a URL.
+     * @param url - The URL to stream data from.
+     * @returns Promise<Readable>
+     */
+    async streamData(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 443,
+                path: urlObj.pathname + urlObj.search,
+                method: "GET",
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve(res); // Return the readable stream
+                }
+                else if (res.statusCode === 301 || res.statusCode === 302) {
+                    const redirectUrl = res.headers.location;
+                    if (redirectUrl) {
+                        this.streamData(redirectUrl).then(resolve).catch(reject);
+                    }
+                    else {
+                        reject(new Error("Redirected without a location header"));
+                    }
+                }
+                else {
+                    reject(new Error(`Failed to retrieve stream from ${url}. Status code: ${res.statusCode}`));
+                }
+            });
+            req.on("error", (error) => reject(error));
+            req.end();
+        });
+    }
+    /** ------------------------ HEAD REQUEST FUNCTIONALITY ------------------------ **/
+    /**
+     * Perform a HEAD request to check if a resource exists on the server.
+     * @param url - The URL to check.
+     * @returns Promise<{ success: boolean; headers?: Record<string, string> }>
+     */
+    async headRequest(url) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new url_1.URL(url);
+            const options = {
+                hostname: urlObj.hostname,
+                port: urlObj.port || 443,
+                path: urlObj.pathname,
+                method: "HEAD",
+                key: fs_1.default.readFileSync(FileTransfer.keyPath),
+                cert: fs_1.default.readFileSync(FileTransfer.certPath),
+                rejectUnauthorized: false,
+            };
+            const req = https_1.default.request(options, (res) => {
+                if (res.statusCode === 200) {
+                    resolve({
+                        success: true,
+                        headers: res.headers,
+                    });
+                }
+                else {
+                    resolve({ success: false });
+                }
+            });
+            req.on("error", (err) => reject(err));
+            req.end();
+        });
+    }
+}
+exports.FileTransfer = FileTransfer;

package/dist/utils/NconfManager.js

@@ -8,7 +8,8 @@ const nconf_1 = __importDefault(require("nconf"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("./config");
-const CONF_FOLDER_PATH = process.env.DIG_FOLDER_PATH || config_1.USER_DIR_PATH;
+const Environment_1 = require("./Environment");
+const CONF_FOLDER_PATH = Environment_1.Environment.DIG_FOLDER_PATH || config_1.USER_DIR_PATH;
 class NconfManager {
     constructor(relativePath) {
         this.configFilePath = path_1.default.join(CONF_FOLDER_PATH, relativePath);

package/dist/utils/PeerRanker.d.ts

@@ -0,0 +1,55 @@
+export interface PeerMetrics {
+    ip: string;
+    latency: number;
+    bandwidth: number;
+}
+/**
+ * Utility class to rank peers based on latency and upload bandwidth using HTTPS with mTLS.
+ */
+export declare class PeerRanker {
+    private ipAddresses;
+    private static certPath;
+    private static keyPath;
+    private timeout;
+    private uploadTestSize;
+    private sortedPeers;
+    private currentIndex;
+    /**
+     * Constructs a PeerRanker instance.
+     * @param ipAddresses - Array of IP addresses to rank.
+     */
+    constructor(ipAddresses: string[], timeout?: number, uploadTestSize?: number);
+    /**
+     * Measures the latency of a given IP address using an HTTPS request.
+     * Tries HEAD first, then falls back to GET if HEAD is not supported.
+     * If the latency is cached, returns the cached value.
+     * @param ip - The IP address of the peer.
+     * @returns Promise resolving to the latency in milliseconds or rejecting if the peer fails.
+     */
+    private measureLatency;
+    /**
+     * Measures the upload bandwidth of a given IP address by sending random data.
+     * If the bandwidth is cached, returns the cached value.
+     * @param ip - The IP address of the peer.
+     * @returns Promise resolving to the upload bandwidth in bytes per second or rejecting if the peer fails.
+     */
+    private measureBandwidth;
+    /**
+     * Ranks the peers based on measured latency and upload bandwidth.
+     * Unresponsive peers are excluded from the final ranking.
+     * @param cooldown - Cooldown time in milliseconds between batches.
+     * @returns Promise resolving to an array of PeerMetrics sorted by latency and bandwidth.
+     */
+    rankPeers(cooldown?: number): Promise<PeerMetrics[]>;
+    /**
+     * Returns the next best peer based on the ranking.
+     * Cycles through the list, resetting to the beginning once the end is reached.
+     * @returns The next PeerMetrics object or null if no peers are available.
+     */
+    GetNextBestPeer(): PeerMetrics | null;
+    /**
+     * Resets the internal iterator to start from the beginning of the sorted list.
+     */
+    resetIterator(): void;
+}
+//# sourceMappingURL=PeerRanker.d.ts.map

package/dist/utils/PeerRanker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PeerRanker.d.ts","sourceRoot":"","sources":["../../src/utils/PeerRanker.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAS;IAG/B,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,YAAY,CAAa;IAEjC;;;OAGG;gBACS,WAAW,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAa,EAAE,cAAc,GAAE,MAAoB;IAW/F;;;;;;OAMG;YACW,cAAc;IAkD5B;;;;;OAKG;YACW,gBAAgB;IA2C9B;;;;;OAKG;IACU,SAAS,CAAC,QAAQ,GAAE,MAAY,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAmCtE;;;;OAIG;IACI,eAAe,IAAI,WAAW,GAAG,IAAI;IAW5C;;OAEG;IACI,aAAa,IAAI,IAAI;CAG7B"}

package/dist/utils/PeerRanker.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerRanker = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const https_1 = __importDefault(require("https"));
+const node_cache_1 = __importDefault(require("node-cache")); // Import node-cache
+const ssl_1 = require("./ssl");
+const promiseUtils_1 = require("./promiseUtils");
+// Cache with TTL of 1 day (86400 seconds)
+const peerCache = new node_cache_1.default({ stdTTL: 86400 });
+/**
+ * Utility class to rank peers based on latency and upload bandwidth using HTTPS with mTLS.
+ */
+class PeerRanker {
+    /**
+     * Constructs a PeerRanker instance.
+     * @param ipAddresses - Array of IP addresses to rank.
+     */
+    constructor(ipAddresses, timeout = 5000, uploadTestSize = 1024 * 1024) {
+        // Internal properties for iteration
+        this.sortedPeers = [];
+        this.currentIndex = 0;
+        this.ipAddresses = ipAddresses;
+        this.timeout = timeout; // Allow customizable timeout
+        this.uploadTestSize = uploadTestSize; // Default upload size: 1MB
+        // Fetch the SSL certificates used for mTLS.
+        const { certPath, keyPath } = (0, ssl_1.getOrCreateSSLCerts)();
+        PeerRanker.certPath = certPath;
+        PeerRanker.keyPath = keyPath;
+    }
+    /**
+     * Measures the latency of a given IP address using an HTTPS request.
+     * Tries HEAD first, then falls back to GET if HEAD is not supported.
+     * If the latency is cached, returns the cached value.
+     * @param ip - The IP address of the peer.
+     * @returns Promise resolving to the latency in milliseconds or rejecting if the peer fails.
+     */
+    async measureLatency(ip) {
+        const cachedMetrics = peerCache.get(ip);
+        if (cachedMetrics && cachedMetrics.latency) {
+            return cachedMetrics.latency;
+        }
+        const url = `https://${ip}:4159/diagnostics/ping`;
+        const configHead = {
+            url: url,
+            method: 'HEAD',
+            httpsAgent: new https_1.default.Agent({
+                cert: fs_1.default.readFileSync(PeerRanker.certPath),
+                key: fs_1.default.readFileSync(PeerRanker.keyPath),
+                rejectUnauthorized: false,
+            }),
+            timeout: this.timeout,
+            validateStatus: (status) => status < 500,
+        };
+        const startTime = Date.now();
+        try {
+            const response = await (0, axios_1.default)(configHead);
+            if (response.status === 405) {
+                const configGet = {
+                    url: url,
+                    method: 'GET',
+                    httpsAgent: new https_1.default.Agent({
+                        cert: fs_1.default.readFileSync(PeerRanker.certPath),
+                        key: fs_1.default.readFileSync(PeerRanker.keyPath),
+                        rejectUnauthorized: false,
+                    }),
+                    timeout: this.timeout,
+                    headers: {
+                        'Range': 'bytes=0-0',
+                    },
+                    validateStatus: (status) => status < 500,
+                };
+                await (0, axios_1.default)(configGet);
+            }
+            const latency = Date.now() - startTime;
+            // Cache the latency for the IP
+            peerCache.set(ip, { ...cachedMetrics, latency });
+            return latency;
+        }
+        catch (error) {
+            throw new Error(`Latency measurement failed for IP ${ip}`);
+        }
+    }
+    /**
+     * Measures the upload bandwidth of a given IP address by sending random data.
+     * If the bandwidth is cached, returns the cached value.
+     * @param ip - The IP address of the peer.
+     * @returns Promise resolving to the upload bandwidth in bytes per second or rejecting if the peer fails.
+     */
+    async measureBandwidth(ip) {
+        const cachedMetrics = peerCache.get(ip);
+        if (cachedMetrics && cachedMetrics.bandwidth) {
+            return cachedMetrics.bandwidth;
+        }
+        const url = `https://${ip}:4159/diagnostics/bandwidth`;
+        const randomData = Buffer.alloc(this.uploadTestSize, 'a');
+        const config = {
+            url: url,
+            method: 'POST',
+            data: randomData,
+            headers: {
+                'Content-Type': 'application/octet-stream',
+                'Content-Length': this.uploadTestSize,
+            },
+            httpsAgent: new https_1.default.Agent({
+                cert: fs_1.default.readFileSync(PeerRanker.certPath),
+                key: fs_1.default.readFileSync(PeerRanker.keyPath),
+                rejectUnauthorized: false,
+            }),
+            timeout: this.timeout,
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity,
+        };
+        const startTime = Date.now();
+        try {
+            await (0, axios_1.default)(config);
+            const timeElapsed = (Date.now() - startTime) / 1000;
+            const bandwidth = this.uploadTestSize / timeElapsed;
+            // Cache the bandwidth for the IP
+            peerCache.set(ip, { ...cachedMetrics, bandwidth });
+            return bandwidth;
+        }
+        catch (error) {
+            throw new Error(`Bandwidth measurement failed for IP ${ip}`);
+        }
+    }
+    /**
+     * Ranks the peers based on measured latency and upload bandwidth.
+     * Unresponsive peers are excluded from the final ranking.
+     * @param cooldown - Cooldown time in milliseconds between batches.
+     * @returns Promise resolving to an array of PeerMetrics sorted by latency and bandwidth.
+     */
+    async rankPeers(cooldown = 500) {
+        const limit = 5; // Limit to 5 parallel requests at a time
+        const iteratorFn = async (ip) => {
+            try {
+                const [latency, bandwidth] = await Promise.all([
+                    this.measureLatency(ip),
+                    this.measureBandwidth(ip),
+                ]);
+                return { ip, latency, bandwidth };
+            }
+            catch (error) {
+                // Peer failed, skip it by returning null
+                return null;
+            }
+        };
+        // Process all peers with a concurrency limit and cooldown between batches
+        const peerMetrics = (await (0, promiseUtils_1.asyncPool)(limit, this.ipAddresses, iteratorFn, cooldown)).filter((metrics) => metrics !== null); // Use a type guard
+        // Sort by lowest latency first, then by highest bandwidth
+        peerMetrics.sort((a, b) => {
+            if (a.latency === b.latency) {
+                return b.bandwidth - a.bandwidth; // Higher bandwidth is better
+            }
+            return a.latency - b.latency; // Lower latency is better
+        });
+        this.sortedPeers = peerMetrics;
+        this.currentIndex = 0;
+        return peerMetrics;
+    }
+    /**
+     * Returns the next best peer based on the ranking.
+     * Cycles through the list, resetting to the beginning once the end is reached.
+     * @returns The next PeerMetrics object or null if no peers are available.
+     */
+    GetNextBestPeer() {
+        if (this.sortedPeers.length === 0) {
+            console.warn('Peer list is empty. Please run rankPeers() first.');
+            return null;
+        }
+        const peer = this.sortedPeers[this.currentIndex];
+        this.currentIndex = (this.currentIndex + 1) % this.sortedPeers.length;
+        return peer;
+    }
+    /**
+     * Resets the internal iterator to start from the beginning of the sorted list.
+     */
+    resetIterator() {
+        this.currentIndex = 0;
+    }
+}
+exports.PeerRanker = PeerRanker;

package/dist/utils/StoreArchiveManager.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Class for managing file archiving, extraction, and working with the 'data' folder.
+ */
+declare class StoreArchiveManager {
+    private archivePath;
+    private outputStream;
+    /**
+     * Constructor that initializes the FileArchiveManager with a given path.
+     * @param archivePath - The path where the archive will be created.
+     */
+    constructor(archivePath: string);
+    /**
+     * Creates the archive at the specified path.
+     * @returns Promise<void>
+     */
+    createArchive(): Promise<void>;
+    /**
+     * Streams a file into the archive.
+     * @param filePath - The file to add to the archive.
+     * @param fileNameInArchive - The name the file should have inside the archive.
+     * @returns Promise<void>
+     */
+    addFileToArchive(filePath: string, fileNameInArchive: string): Promise<void>;
+    /**
+     * Extracts a file from the archive to a specified directory.
+     * @param extractToPath - The path where the file should be extracted.
+     * @returns Promise<void>
+     */
+    extractArchive(extractToPath: string): Promise<void>;
+    /**
+     * Merges another archive into the current one.
+     * Extracts files from the given archive and adds them into the current archive.
+     * @param archiveToMergePath - The path of the archive to be merged.
+     * @returns Promise<void>
+     */
+    mergeArchive(archiveToMergePath: string): Promise<void>;
+    /**
+     * Adds extracted files to the current archive.
+     * @param extractedFolderPath - The path of the folder containing extracted files.
+     * @returns Promise<void>
+     */
+    private addExtractedFilesToArchive;
+}
+export default StoreArchiveManager;
+//# sourceMappingURL=StoreArchiveManager.d.ts.map

package/dist/utils/StoreArchiveManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StoreArchiveManager.d.ts","sourceRoot":"","sources":["../../src/utils/StoreArchiveManager.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,cAAM,mBAAmB;IACrB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAwB;IAE5C;;;OAGG;gBACS,WAAW,EAAE,MAAM;IAK/B;;;OAGG;IACU,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB3C;;;;;OAKG;IACU,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBzF;;;;OAIG;IACU,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASjE;;;;;OAKG;IACU,YAAY,CAAC,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCpE;;;;OAIG;YACW,0BAA0B;CAkB3C;AAED,eAAe,mBAAmB,CAAC"}