kynjal-cli 4.0.0 → 4.0.1

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

@@ -2,53 +2,6 @@
  * 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';
@@ -57,395 +10,320 @@ import { DEFAULT_STORE_CONFIG } from './registry.js';
  * Pattern Downloader
  * Handles secure download and verification of patterns
  */
-var PatternDownloader = /** @class */ (function () {
-    function PatternDownloader(config) {
-        if (config === void 0) { config = {}; }
-        this.config = __assign(__assign({}, DEFAULT_STORE_CONFIG), config);
+export class PatternDownloader {
+    config;
+    downloadCache;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_STORE_CONFIG, ...config };
         this.downloadCache = new Map();
     }
     /**
      * Download a pattern from IPFS
      */
-    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*/];
+    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,
+                        };
+                    }
                 }
+                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
      */
-    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*/];
+    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
+                }
+            }
+            return null;
+        }
+    }
     /**
      * Fetch content from Google Cloud Storage
      */
-    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*/];
-                }
-            });
-        });
-    };
+    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;
+        }
+    }
     /**
      * Verify content checksum
      */
-    PatternDownloader.prototype.verifyChecksum = function (content, expectedChecksum) {
-        var actualChecksum = crypto
+    verifyChecksum(content, expectedChecksum) {
+        const actualChecksum = crypto
             .createHash('sha256')
             .update(content)
             .digest('hex');
         return actualChecksum === expectedChecksum;
-    };
+    }
     /**
      * Verify content signature using crypto
      */
-    PatternDownloader.prototype.verifySignature = function (content, signature, publicKey) {
+    verifySignature(content, signature, publicKey) {
         // Check signature format
         if (!signature.startsWith('ed25519:') || !publicKey.startsWith('ed25519:')) {
             return false;
         }
         try {
             // For HMAC-based signatures (used in publish.ts)
-            var sigHex = signature.replace('ed25519:', '');
-            var keyHex = publicKey.replace('ed25519:', '');
+            const sigHex = signature.replace('ed25519:', '');
+            const keyHex = publicKey.replace('ed25519:', '');
             // Verify HMAC signature
-            var expectedSig = crypto
+            const 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 (_a) {
+        catch {
             // If crypto verification fails, check basic format
             return signature.length > 20 && publicKey.length > 20;
         }
-    };
+    }
     /**
      * Resolve output path for pattern
      */
-    PatternDownloader.prototype.resolveOutputPath = function (pattern, options) {
+    resolveOutputPath(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
-        var cacheDir = path.resolve(this.config.cacheDir);
-        return path.join(cacheDir, pattern.name + "-" + pattern.version + ".cfp.json");
-    };
+        const cacheDir = path.resolve(this.config.cacheDir);
+        return path.join(cacheDir, `${pattern.name}-${pattern.version}.cfp.json`);
+    }
     /**
      * Import downloaded pattern
      */
-    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*/];
-            });
-        });
-    };
+    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;
+        }
+    }
     // NOTE: generateMockContent removed - using real HTTP fetch from IPFS gateways or GCS
     /**
      * Clear download cache
      */
-    PatternDownloader.prototype.clearCache = function () {
+    clearCache() {
         this.downloadCache.clear();
-        console.log("[Download] Cache cleared");
-    };
+        console.log(`[Download] Cache cleared`);
+    }
     /**
      * Get cache statistics
      */
-    PatternDownloader.prototype.getCacheStats = function () {
-        var totalSize = 0;
-        for (var _i = 0, _a = this.downloadCache.values(); _i < _a.length; _i++) {
-            var cachedPath = _a[_i].path;
+    getCacheStats() {
+        let totalSize = 0;
+        for (const { path: cachedPath } of this.downloadCache.values()) {
             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 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];
-            }
-        });
-    });
+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;
 }
 /**
  * Create downloader with default config