kynjal-cli 3.1.3 → 4.0.0

package/dist/src/transfer/store/download.js

@@ -2,6 +2,53 @@
  * Pattern Download Service
  * Secure download and verification of patterns from IPFS
  */
+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 (_) 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 };
+    }
+};
 import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'crypto';
@@ -10,320 +57,395 @@ import { DEFAULT_STORE_CONFIG } from './registry.js';
  * Pattern Downloader
  * Handles secure download and verification of patterns
  */
-export class PatternDownloader {
-    config;
-    downloadCache;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_STORE_CONFIG, ...config };
+var PatternDownloader = /** @class */ (function () {
+    function PatternDownloader(config) {
+        if (config === void 0) { config = {}; }
+        this.config = __assign(__assign({}, DEFAULT_STORE_CONFIG), config);
         this.downloadCache = new Map();
     }
     /**
      * Download a pattern from IPFS
      */
-    async downloadPattern(pattern, options = {}, onProgress) {
-        console.log(`[Download] Starting download: ${pattern.displayName}`);
-        console.log(`[Download] CID: ${pattern.cid}`);
-        console.log(`[Download] Size: ${pattern.size} bytes`);
-        // Check cache
-        const cached = this.downloadCache.get(pattern.cid);
-        if (cached && fs.existsSync(cached.path)) {
-            console.log(`[Download] Found in cache: ${cached.path}`);
-            return {
-                success: true,
-                pattern,
-                outputPath: cached.path,
-                imported: false,
-                verified: true,
-                size: pattern.size,
-            };
-        }
-        try {
-            // Determine output path
-            const outputPath = this.resolveOutputPath(pattern, options);
-            console.log(`[Download] Output path: ${outputPath}`);
-            // Ensure directory exists
-            const outputDir = path.dirname(outputPath);
-            if (!fs.existsSync(outputDir)) {
-                fs.mkdirSync(outputDir, { recursive: true });
-            }
-            // Fetch from IPFS
-            const content = await this.fetchFromIPFS(pattern.cid, onProgress);
-            if (!content) {
-                return {
-                    success: false,
-                    pattern,
-                    verified: false,
-                    size: 0,
-                };
-            }
-            // Verify checksum
-            let verified = false;
-            if (options.verify !== false) {
-                verified = this.verifyChecksum(content, pattern.checksum);
-                if (!verified) {
-                    console.warn(`[Download] Warning: Checksum verification failed!`);
-                    if (this.config.requireVerification) {
-                        return {
-                            success: false,
-                            pattern,
-                            verified: false,
-                            size: content.length,
-                        };
-                    }
+    PatternDownloader.prototype.downloadPattern = function (pattern, options, onProgress) {
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, Promise, function () {
+            var cached, outputPath, outputDir, content, verified, sigVerified, imported, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log("[Download] Starting download: " + pattern.displayName);
+                        console.log("[Download] CID: " + pattern.cid);
+                        console.log("[Download] Size: " + pattern.size + " bytes");
+                        cached = this.downloadCache.get(pattern.cid);
+                        if (cached && fs.existsSync(cached.path)) {
+                            console.log("[Download] Found in cache: " + cached.path);
+                            return [2 /*return*/, {
+                                    success: true,
+                                    pattern: pattern,
+                                    outputPath: cached.path,
+                                    imported: false,
+                                    verified: true,
+                                    size: pattern.size
+                                }];
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 5, , 6]);
+                        outputPath = this.resolveOutputPath(pattern, options);
+                        console.log("[Download] Output path: " + outputPath);
+                        outputDir = path.dirname(outputPath);
+                        if (!fs.existsSync(outputDir)) {
+                            fs.mkdirSync(outputDir, { recursive: true });
+                        }
+                        return [4 /*yield*/, this.fetchFromIPFS(pattern.cid, onProgress)];
+                    case 2:
+                        content = _a.sent();
+                        if (!content) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    pattern: pattern,
+                                    verified: false,
+                                    size: 0
+                                }];
+                        }
+                        verified = false;
+                        if (options.verify !== false) {
+                            verified = this.verifyChecksum(content, pattern.checksum);
+                            if (!verified) {
+                                console.warn("[Download] Warning: Checksum verification failed!");
+                                if (this.config.requireVerification) {
+                                    return [2 /*return*/, {
+                                            success: false,
+                                            pattern: pattern,
+                                            verified: false,
+                                            size: content.length
+                                        }];
+                                }
+                            }
+                            else {
+                                console.log("[Download] Checksum verified!");
+                            }
+                        }
+                        // Verify signature if available
+                        if (pattern.signature && pattern.publicKey) {
+                            sigVerified = this.verifySignature(content, pattern.signature, pattern.publicKey);
+                            if (!sigVerified) {
+                                console.warn("[Download] Warning: Signature verification failed!");
+                            }
+                            else {
+                                console.log("[Download] Signature verified!");
+                            }
+                        }
+                        // Write to file
+                        fs.writeFileSync(outputPath, content);
+                        console.log("[Download] Written to: " + outputPath);
+                        // Update cache
+                        this.downloadCache.set(pattern.cid, {
+                            path: outputPath,
+                            downloadedAt: Date.now()
+                        });
+                        imported = false;
+                        if (!options["import"]) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.importPattern(outputPath, options.importStrategy)];
+                    case 3:
+                        imported = _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/, {
+                            success: true,
+                            pattern: pattern,
+                            outputPath: outputPath,
+                            imported: imported,
+                            verified: verified,
+                            size: content.length
+                        }];
+                    case 5:
+                        error_1 = _a.sent();
+                        console.error("[Download] Failed:", error_1);
+                        return [2 /*return*/, {
+                                success: false,
+                                pattern: pattern,
+                                verified: false,
+                                size: 0
+                            }];
+                    case 6: return [2 /*return*/];
                 }
-                else {
-                    console.log(`[Download] Checksum verified!`);
-                }
-            }
-            // Verify signature if available
-            if (pattern.signature && pattern.publicKey) {
-                const sigVerified = this.verifySignature(content, pattern.signature, pattern.publicKey);
-                if (!sigVerified) {
-                    console.warn(`[Download] Warning: Signature verification failed!`);
-                }
-                else {
-                    console.log(`[Download] Signature verified!`);
-                }
-            }
-            // Write to file
-            fs.writeFileSync(outputPath, content);
-            console.log(`[Download] Written to: ${outputPath}`);
-            // Update cache
-            this.downloadCache.set(pattern.cid, {
-                path: outputPath,
-                downloadedAt: Date.now(),
             });
-            // Import if requested
-            let imported = false;
-            if (options.import) {
-                imported = await this.importPattern(outputPath, options.importStrategy);
-            }
-            return {
-                success: true,
-                pattern,
-                outputPath,
-                imported,
-                verified,
-                size: content.length,
-            };
-        }
-        catch (error) {
-            console.error(`[Download] Failed:`, error);
-            return {
-                success: false,
-                pattern,
-                verified: false,
-                size: 0,
-            };
-        }
-    }
+        });
+    };
     /**
      * Fetch content from IPFS gateway or GCS
      */
-    async fetchFromIPFS(cid, onProgress) {
-        // Check if this is a GCS URI
-        if (cid.startsWith('gs://')) {
-            return this.fetchFromGCS(cid, onProgress);
-        }
-        const url = `${this.config.gateway}/ipfs/${cid}`;
-        console.log(`[Download] Fetching: ${url}`);
-        try {
-            // Real HTTP fetch with progress
-            const response = await fetch(url);
-            if (!response.ok) {
-                console.error(`[Download] HTTP ${response.status}: ${response.statusText}`);
-                return null;
-            }
-            const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
-            // Stream the response for progress tracking
-            if (response.body && onProgress && contentLength > 0) {
-                const reader = response.body.getReader();
-                const chunks = [];
-                let downloaded = 0;
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    chunks.push(value);
-                    downloaded += value.length;
-                    onProgress({
-                        bytesDownloaded: downloaded,
-                        totalBytes: contentLength,
-                        percentage: Math.round((downloaded / contentLength) * 100),
-                    });
-                }
-                const buffer = Buffer.concat(chunks.map(c => Buffer.from(c)));
-                console.log(`[Download] Downloaded ${buffer.length} bytes from IPFS gateway`);
-                return buffer;
-            }
-            // Fallback for responses without content-length or progress
-            const arrayBuffer = await response.arrayBuffer();
-            const buffer = Buffer.from(arrayBuffer);
-            console.log(`[Download] Downloaded ${buffer.length} bytes from IPFS gateway`);
-            return buffer;
-        }
-        catch (error) {
-            console.error(`[Download] Fetch failed:`, error);
-            // Try alternative gateways
-            const alternativeGateways = [
-                'https://ipfs.io',
-                'https://cloudflare-ipfs.com',
-                'https://dweb.link',
-                'https://gateway.pinata.cloud',
-            ];
-            for (const gateway of alternativeGateways) {
-                if (gateway === this.config.gateway)
-                    continue;
-                try {
-                    console.log(`[Download] Trying alternative gateway: ${gateway}`);
-                    const altResponse = await fetch(`${gateway}/ipfs/${cid}`);
-                    if (altResponse.ok) {
-                        const arrayBuffer = await altResponse.arrayBuffer();
-                        const buffer = Buffer.from(arrayBuffer);
-                        console.log(`[Download] Downloaded ${buffer.length} bytes from ${gateway}`);
-                        return buffer;
-                    }
-                }
-                catch {
-                    // Continue to next gateway
+    PatternDownloader.prototype.fetchFromIPFS = function (cid, onProgress) {
+        return __awaiter(this, void 0, Promise, function () {
+            var url, response, contentLength, reader, chunks, downloaded, _a, done, value, buffer_1, arrayBuffer, buffer, error_2, alternativeGateways, _i, alternativeGateways_1, gateway, altResponse, arrayBuffer, buffer, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // Check if this is a GCS URI
+                        if (cid.startsWith('gs://')) {
+                            return [2 /*return*/, this.fetchFromGCS(cid, onProgress)];
+                        }
+                        url = this.config.gateway + "/ipfs/" + cid;
+                        console.log("[Download] Fetching: " + url);
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 8, , 17]);
+                        return [4 /*yield*/, fetch(url)];
+                    case 2:
+                        response = _c.sent();
+                        if (!response.ok) {
+                            console.error("[Download] HTTP " + response.status + ": " + response.statusText);
+                            return [2 /*return*/, null];
+                        }
+                        contentLength = parseInt(response.headers.get('content-length') || '0', 10);
+                        if (!(response.body && onProgress && contentLength > 0)) return [3 /*break*/, 6];
+                        reader = response.body.getReader();
+                        chunks = [];
+                        downloaded = 0;
+                        _c.label = 3;
+                    case 3:
+                        if (!true) return [3 /*break*/, 5];
+                        return [4 /*yield*/, reader.read()];
+                    case 4:
+                        _a = _c.sent(), done = _a.done, value = _a.value;
+                        if (done)
+                            return [3 /*break*/, 5];
+                        chunks.push(value);
+                        downloaded += value.length;
+                        onProgress({
+                            bytesDownloaded: downloaded,
+                            totalBytes: contentLength,
+                            percentage: Math.round((downloaded / contentLength) * 100)
+                        });
+                        return [3 /*break*/, 3];
+                    case 5:
+                        buffer_1 = Buffer.concat(chunks.map(function (c) { return Buffer.from(c); }));
+                        console.log("[Download] Downloaded " + buffer_1.length + " bytes from IPFS gateway");
+                        return [2 /*return*/, buffer_1];
+                    case 6: return [4 /*yield*/, response.arrayBuffer()];
+                    case 7:
+                        arrayBuffer = _c.sent();
+                        buffer = Buffer.from(arrayBuffer);
+                        console.log("[Download] Downloaded " + buffer.length + " bytes from IPFS gateway");
+                        return [2 /*return*/, buffer];
+                    case 8:
+                        error_2 = _c.sent();
+                        console.error("[Download] Fetch failed:", error_2);
+                        alternativeGateways = [
+                            'https://ipfs.io',
+                            'https://cloudflare-ipfs.com',
+                            'https://dweb.link',
+                            'https://gateway.pinata.cloud',
+                        ];
+                        _i = 0, alternativeGateways_1 = alternativeGateways;
+                        _c.label = 9;
+                    case 9:
+                        if (!(_i < alternativeGateways_1.length)) return [3 /*break*/, 16];
+                        gateway = alternativeGateways_1[_i];
+                        if (gateway === this.config.gateway)
+                            return [3 /*break*/, 15];
+                        _c.label = 10;
+                    case 10:
+                        _c.trys.push([10, 14, , 15]);
+                        console.log("[Download] Trying alternative gateway: " + gateway);
+                        return [4 /*yield*/, fetch(gateway + "/ipfs/" + cid)];
+                    case 11:
+                        altResponse = _c.sent();
+                        if (!altResponse.ok) return [3 /*break*/, 13];
+                        return [4 /*yield*/, altResponse.arrayBuffer()];
+                    case 12:
+                        arrayBuffer = _c.sent();
+                        buffer = Buffer.from(arrayBuffer);
+                        console.log("[Download] Downloaded " + buffer.length + " bytes from " + gateway);
+                        return [2 /*return*/, buffer];
+                    case 13: return [3 /*break*/, 15];
+                    case 14:
+                        _b = _c.sent();
+                        return [3 /*break*/, 15];
+                    case 15:
+                        _i++;
+                        return [3 /*break*/, 9];
+                    case 16: return [2 /*return*/, null];
+                    case 17: return [2 /*return*/];
                 }
-            }
-            return null;
-        }
-    }
+            });
+        });
+    };
     /**
      * Fetch content from Google Cloud Storage
      */
-    async fetchFromGCS(uri, onProgress) {
-        console.log(`[Download] Fetching from GCS: ${uri}`);
-        try {
-            const { downloadFromGCS, hasGCSCredentials } = await import('../storage/gcs.js');
-            if (!hasGCSCredentials()) {
-                console.error(`[Download] GCS not configured`);
-                return null;
-            }
-            const buffer = await downloadFromGCS(uri);
-            if (buffer && onProgress) {
-                onProgress({
-                    bytesDownloaded: buffer.length,
-                    totalBytes: buffer.length,
-                    percentage: 100,
-                });
-            }
-            return buffer;
-        }
-        catch (error) {
-            console.error(`[Download] GCS fetch failed:`, error);
-            return null;
-        }
-    }
+    PatternDownloader.prototype.fetchFromGCS = function (uri, onProgress) {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a, downloadFromGCS, hasGCSCredentials, buffer, error_3;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("[Download] Fetching from GCS: " + uri);
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, import('../storage/gcs.js')];
+                    case 2:
+                        _a = _b.sent(), downloadFromGCS = _a.downloadFromGCS, hasGCSCredentials = _a.hasGCSCredentials;
+                        if (!hasGCSCredentials()) {
+                            console.error("[Download] GCS not configured");
+                            return [2 /*return*/, null];
+                        }
+                        return [4 /*yield*/, downloadFromGCS(uri)];
+                    case 3:
+                        buffer = _b.sent();
+                        if (buffer && onProgress) {
+                            onProgress({
+                                bytesDownloaded: buffer.length,
+                                totalBytes: buffer.length,
+                                percentage: 100
+                            });
+                        }
+                        return [2 /*return*/, buffer];
+                    case 4:
+                        error_3 = _b.sent();
+                        console.error("[Download] GCS fetch failed:", error_3);
+                        return [2 /*return*/, null];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Verify content checksum
      */
-    verifyChecksum(content, expectedChecksum) {
-        const actualChecksum = crypto
+    PatternDownloader.prototype.verifyChecksum = function (content, expectedChecksum) {
+        var actualChecksum = crypto
             .createHash('sha256')
             .update(content)
             .digest('hex');
         return actualChecksum === expectedChecksum;
-    }
+    };
     /**
      * Verify content signature using crypto
      */
-    verifySignature(content, signature, publicKey) {
+    PatternDownloader.prototype.verifySignature = function (content, signature, publicKey) {
         // Check signature format
         if (!signature.startsWith('ed25519:') || !publicKey.startsWith('ed25519:')) {
             return false;
         }
         try {
             // For HMAC-based signatures (used in publish.ts)
-            const sigHex = signature.replace('ed25519:', '');
-            const keyHex = publicKey.replace('ed25519:', '');
+            var sigHex = signature.replace('ed25519:', '');
+            var keyHex = publicKey.replace('ed25519:', '');
             // Verify HMAC signature
-            const expectedSig = crypto
+            var expectedSig = crypto
                 .createHmac('sha256', keyHex)
                 .update(content)
                 .digest('hex');
             // Constant-time comparison to prevent timing attacks
             return crypto.timingSafeEqual(Buffer.from(sigHex, 'hex'), Buffer.from(expectedSig, 'hex'));
         }
-        catch {
+        catch (_a) {
             // If crypto verification fails, check basic format
             return signature.length > 20 && publicKey.length > 20;
         }
-    }
+    };
     /**
      * Resolve output path for pattern
      */
-    resolveOutputPath(pattern, options) {
+    PatternDownloader.prototype.resolveOutputPath = function (pattern, options) {
         if (options.output) {
             // If output is a directory, append filename
             if (fs.existsSync(options.output) && fs.statSync(options.output).isDirectory()) {
-                return path.join(options.output, `${pattern.name}.cfp.json`);
+                return path.join(options.output, pattern.name + ".cfp.json");
             }
             return options.output;
         }
         // Default: cache directory
-        const cacheDir = path.resolve(this.config.cacheDir);
-        return path.join(cacheDir, `${pattern.name}-${pattern.version}.cfp.json`);
-    }
+        var cacheDir = path.resolve(this.config.cacheDir);
+        return path.join(cacheDir, pattern.name + "-" + pattern.version + ".cfp.json");
+    };
     /**
      * Import downloaded pattern
      */
-    async importPattern(filePath, strategy = 'merge') {
-        console.log(`[Download] Importing pattern with strategy: ${strategy}`);
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const cfp = JSON.parse(content);
-            // In production: Import to local pattern store
-            // For demo: Just validate
-            if (cfp.magic !== 'CFP1') {
-                console.error(`[Download] Invalid CFP format`);
-                return false;
-            }
-            console.log(`[Download] Pattern imported: ${cfp.metadata.name}`);
-            return true;
-        }
-        catch (error) {
-            console.error(`[Download] Import failed:`, error);
-            return false;
-        }
-    }
+    PatternDownloader.prototype.importPattern = function (filePath, strategy) {
+        if (strategy === void 0) { strategy = 'merge'; }
+        return __awaiter(this, void 0, Promise, function () {
+            var content, cfp;
+            return __generator(this, function (_a) {
+                console.log("[Download] Importing pattern with strategy: " + strategy);
+                try {
+                    content = fs.readFileSync(filePath, 'utf-8');
+                    cfp = JSON.parse(content);
+                    // In production: Import to local pattern store
+                    // For demo: Just validate
+                    if (cfp.magic !== 'CFP1') {
+                        console.error("[Download] Invalid CFP format");
+                        return [2 /*return*/, false];
+                    }
+                    console.log("[Download] Pattern imported: " + cfp.metadata.name);
+                    return [2 /*return*/, true];
+                }
+                catch (error) {
+                    console.error("[Download] Import failed:", error);
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
     // NOTE: generateMockContent removed - using real HTTP fetch from IPFS gateways or GCS
     /**
      * Clear download cache
      */
-    clearCache() {
+    PatternDownloader.prototype.clearCache = function () {
         this.downloadCache.clear();
-        console.log(`[Download] Cache cleared`);
-    }
+        console.log("[Download] Cache cleared");
+    };
     /**
      * Get cache statistics
      */
-    getCacheStats() {
-        let totalSize = 0;
-        for (const { path: cachedPath } of this.downloadCache.values()) {
+    PatternDownloader.prototype.getCacheStats = function () {
+        var totalSize = 0;
+        for (var _i = 0, _a = this.downloadCache.values(); _i < _a.length; _i++) {
+            var cachedPath = _a[_i].path;
             if (fs.existsSync(cachedPath)) {
                 totalSize += fs.statSync(cachedPath).size;
             }
         }
         return {
             count: this.downloadCache.size,
-            totalSize,
+            totalSize: totalSize
         };
-    }
-}
+    };
+    return PatternDownloader;
+}());
+export { PatternDownloader };
 /**
  * Batch download multiple patterns
  */
-export async function batchDownload(patterns, options = {}, config) {
-    const downloader = new PatternDownloader(config);
-    const results = [];
-    for (const pattern of patterns) {
-        const result = await downloader.downloadPattern(pattern, options);
-        results.push(result);
-    }
-    return results;
+export function batchDownload(patterns, options, config) {
+    if (options === void 0) { options = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var downloader, results, _i, patterns_1, pattern, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    downloader = new PatternDownloader(config);
+                    results = [];
+                    _i = 0, patterns_1 = patterns;
+                    _a.label = 1;
+                case 1:
+                    if (!(_i < patterns_1.length)) return [3 /*break*/, 4];
+                    pattern = patterns_1[_i];
+                    return [4 /*yield*/, downloader.downloadPattern(pattern, options)];
+                case 2:
+                    result = _a.sent();
+                    results.push(result);
+                    _a.label = 3;
+                case 3:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 4: return [2 /*return*/, results];
+            }
+        });
+    });
 }
 /**
  * Create downloader with default config