@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-7LCYLPW2.cjs

@@ -1,663 +0,0 @@
-'use strict';
-
-// src/storage/IPFSTypes.ts
-var IPFSUploadError = class extends Error {
-  constructor(message, provider, originalError) {
-    super(message);
-    this.provider = provider;
-    this.originalError = originalError;
-    this.name = "IPFSUploadError";
-  }
-};
-var IPFSPinError = class extends Error {
-  constructor(message, cid, originalError) {
-    super(message);
-    this.cid = cid;
-    this.originalError = originalError;
-    this.name = "IPFSPinError";
-  }
-};
-var FileSizeExceededError = class extends Error {
-  constructor(fileSize, maxSize) {
-    super(`File size ${fileSize} bytes exceeds maximum ${maxSize} bytes`);
-    this.fileSize = fileSize;
-    this.maxSize = maxSize;
-    this.name = "FileSizeExceededError";
-  }
-};
-
-// src/storage/IPFSProviders.ts
-var PinataProvider = class {
-  constructor(apiKey, apiSecret) {
-    this.baseUrl = "https://api.pinata.cloud";
-    this.apiKey = apiKey;
-    this.apiSecret = apiSecret || "";
-  }
-  async upload(files, options) {
-    const formData = new FormData();
-    for (const file of files) {
-      const blob = new Blob([file.content]);
-      formData.append("file", blob, file.path);
-    }
-    const metadata = {
-      name: options.metadata?.name || options.name,
-      keyvalues: options.metadata?.keyvalues || {}
-    };
-    formData.append("pinataMetadata", JSON.stringify(metadata));
-    const pinataOptions = {
-      cidVersion: 1
-    };
-    formData.append("pinataOptions", JSON.stringify(pinataOptions));
-    const response = await fetch(`${this.baseUrl}/pinning/pinFileToIPFS`, {
-      method: "POST",
-      headers: {
-        pinata_api_key: this.apiKey,
-        pinata_secret_api_key: this.apiSecret
-      },
-      body: formData
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Pinata upload failed: ${error}`);
-    }
-    const data = await response.json();
-    return {
-      cid: data.IpfsHash,
-      size: data.PinSize
-    };
-  }
-  async pin(cid, name) {
-    const response = await fetch(`${this.baseUrl}/pinning/pinByHash`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        pinata_api_key: this.apiKey,
-        pinata_secret_api_key: this.apiSecret
-      },
-      body: JSON.stringify({
-        hashToPin: cid,
-        pinataMetadata: {
-          name: name || cid
-        }
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Pinata pin failed: ${error}`);
-    }
-  }
-  async unpin(cid) {
-    const response = await fetch(`${this.baseUrl}/pinning/unpin/${cid}`, {
-      method: "DELETE",
-      headers: {
-        pinata_api_key: this.apiKey,
-        pinata_secret_api_key: this.apiSecret
-      }
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Pinata unpin failed: ${error}`);
-    }
-  }
-  async getPinStatus(cid) {
-    const response = await fetch(
-      `${this.baseUrl}/data/pinList?hashContains=${cid}&status=pinned,pinning`,
-      {
-        headers: {
-          pinata_api_key: this.apiKey,
-          pinata_secret_api_key: this.apiSecret
-        }
-      }
-    );
-    if (!response.ok) {
-      return "unpinned";
-    }
-    const data = await response.json();
-    if (data.count === 0) {
-      return "unpinned";
-    }
-    const pin = data.rows[0];
-    return pin.status === "pinned" ? "pinned" : "pinning";
-  }
-  async listPins() {
-    const response = await fetch(`${this.baseUrl}/data/pinList?status=pinned`, {
-      headers: {
-        pinata_api_key: this.apiKey,
-        pinata_secret_api_key: this.apiSecret
-      }
-    });
-    if (!response.ok) {
-      throw new Error("Failed to list pins");
-    }
-    const data = await response.json();
-    return data.rows.map((pin) => ({
-      // @ts-expect-error
-      cid: pin.ipfs_pin_hash,
-      // @ts-expect-error
-      name: pin.metadata?.name || pin.ipfs_pin_hash,
-      // @ts-expect-error
-      size: pin.size,
-      // @ts-expect-error
-      status: pin.status,
-      // @ts-expect-error
-      created: new Date(pin.date_pinned)
-    }));
-  }
-  async verifyCID(cid) {
-    try {
-      const status = await this.getPinStatus(cid);
-      return status === "pinned" || status === "pinning";
-    } catch {
-      return false;
-    }
-  }
-};
-var NFTStorageProvider = class {
-  constructor(apiKey) {
-    this.baseUrl = "https://api.nft.storage";
-    this.apiKey = apiKey;
-  }
-  async upload(files, options) {
-    const formData = new FormData();
-    for (const file of files) {
-      const blob = new Blob([file.content]);
-      formData.append("file", blob, file.path);
-    }
-    const response = await fetch(`${this.baseUrl}/upload`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`
-      },
-      body: formData
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`NFT.Storage upload failed: ${error}`);
-    }
-    const data = await response.json();
-    return {
-      cid: data.value.cid,
-      size: data.value.size
-    };
-  }
-  async pin(cid, name) {
-  }
-  async unpin(cid) {
-    const response = await fetch(`${this.baseUrl}/${cid}`, {
-      method: "DELETE",
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`NFT.Storage unpin failed: ${error}`);
-    }
-  }
-  async getPinStatus(cid) {
-    const response = await fetch(`${this.baseUrl}/${cid}`, {
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      return "unpinned";
-    }
-    const data = await response.json();
-    return data.pin?.status === "pinned" ? "pinned" : "pinning";
-  }
-  async listPins() {
-    const response = await fetch(`${this.baseUrl}`, {
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      throw new Error("Failed to list pins");
-    }
-    const data = await response.json();
-    return data.value.map((item) => ({
-      // @ts-expect-error
-      cid: item.cid,
-      // @ts-expect-error
-      name: item.name || item.cid,
-      // @ts-expect-error
-      size: item.size,
-      // @ts-expect-error
-      status: item.pin?.status || "pinned",
-      // @ts-expect-error
-      created: new Date(item.created)
-    }));
-  }
-  async verifyCID(cid) {
-    try {
-      const status = await this.getPinStatus(cid);
-      return status === "pinned" || status === "pinning";
-    } catch {
-      return false;
-    }
-  }
-};
-var InfuraProvider = class {
-  constructor(projectId, projectSecret) {
-    this.baseUrl = "https://ipfs.infura.io:5001/api/v0";
-    this.projectId = projectId;
-    this.projectSecret = projectSecret || "";
-  }
-  getAuthHeader() {
-    const auth = Buffer.from(`${this.projectId}:${this.projectSecret}`).toString("base64");
-    return `Basic ${auth}`;
-  }
-  async upload(files, options) {
-    const formData = new FormData();
-    for (const file of files) {
-      const blob = new Blob([file.content]);
-      formData.append("file", blob, file.path);
-    }
-    const response = await fetch(`${this.baseUrl}/add?wrap-with-directory=true`, {
-      method: "POST",
-      headers: {
-        Authorization: this.getAuthHeader()
-      },
-      body: formData
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Infura upload failed: ${error}`);
-    }
-    const text = await response.text();
-    const lines = text.trim().split("\n");
-    const lastLine = JSON.parse(lines[lines.length - 1]);
-    let totalSize = 0;
-    for (const line of lines) {
-      const data = JSON.parse(line);
-      totalSize += data.Size || 0;
-    }
-    return {
-      cid: lastLine.Hash,
-      size: totalSize
-    };
-  }
-  async pin(cid, name) {
-    const response = await fetch(`${this.baseUrl}/pin/add?arg=${cid}`, {
-      method: "POST",
-      headers: {
-        Authorization: this.getAuthHeader()
-      }
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Infura pin failed: ${error}`);
-    }
-  }
-  async unpin(cid) {
-    const response = await fetch(`${this.baseUrl}/pin/rm?arg=${cid}`, {
-      method: "POST",
-      headers: {
-        Authorization: this.getAuthHeader()
-      }
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Infura unpin failed: ${error}`);
-    }
-  }
-  async getPinStatus(cid) {
-    const response = await fetch(`${this.baseUrl}/pin/ls?arg=${cid}`, {
-      headers: {
-        Authorization: this.getAuthHeader()
-      }
-    });
-    if (!response.ok) {
-      return "unpinned";
-    }
-    const data = await response.json();
-    return data.Keys && data.Keys[cid] ? "pinned" : "unpinned";
-  }
-  async listPins() {
-    const response = await fetch(`${this.baseUrl}/pin/ls`, {
-      headers: {
-        Authorization: this.getAuthHeader()
-      }
-    });
-    if (!response.ok) {
-      throw new Error("Failed to list pins");
-    }
-    const data = await response.json();
-    return Object.entries(data.Keys || {}).map(([cid, info]) => ({
-      cid,
-      name: cid,
-      size: 0,
-      // Infura doesn't provide size in pin list
-      status: "pinned"
-    }));
-  }
-  async verifyCID(cid) {
-    try {
-      const response = await fetch(`${this.baseUrl}/cat?arg=${cid}`, {
-        method: "POST",
-        headers: {
-          Authorization: this.getAuthHeader()
-        }
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// src/storage/IPFSService.ts
-var IPFSService = class {
-  constructor(options) {
-    this.fallbackProviders = [];
-    this.defaultGateway = "https://ipfs.io/ipfs";
-    this.cdnGateway = "https://cloudflare-ipfs.com/ipfs";
-    this.options = {
-      ...options,
-      fallbackProviders: options.fallbackProviders || [],
-      enableCDN: options.enableCDN ?? true,
-      maxFileSize: options.maxFileSize || 100 * 1024 * 1024,
-      // 100MB
-      chunkSize: options.chunkSize || 5 * 1024 * 1024,
-      // 5MB
-      maxRetries: options.maxRetries || 3,
-      retryDelay: options.retryDelay || 1e3,
-      gatewayUrl: options.gatewayUrl || this.defaultGateway,
-      apiSecret: options.apiSecret
-    };
-    this.primaryProvider = this.createProvider(
-      this.options.provider,
-      this.options.apiKey,
-      this.options.apiSecret
-    );
-    for (const fallback of this.options.fallbackProviders) {
-      const provider = this.createProvider(fallback.provider, fallback.apiKey, fallback.apiSecret);
-      this.fallbackProviders.push(provider);
-    }
-  }
-  /**
-   * Create provider instance
-   */
-  createProvider(type, apiKey, apiSecret) {
-    switch (type) {
-      case "pinata":
-        return new PinataProvider(apiKey, apiSecret);
-      case "nft.storage":
-        return new NFTStorageProvider(apiKey);
-      case "infura":
-        return new InfuraProvider(apiKey, apiSecret);
-      default:
-        throw new Error(`Unknown IPFS provider: ${type}`);
-    }
-  }
-  /**
-   * Upload files to IPFS
-   *
-   * Returns CID and gateway URLs. Automatically retries on failure and falls back
-   * to backup providers if primary fails.
-   *
-   * @param options Upload options
-   * @returns Upload result with CID and URLs
-   * @throws {FileSizeExceededError} If file size exceeds maximum
-   * @throws {IPFSUploadError} If upload fails on all providers
-   */
-  async upload(options) {
-    const startTime = Date.now();
-    const totalSize = options.files.reduce((sum, file) => {
-      const size = file.content instanceof Buffer || file.content instanceof Uint8Array ? file.content.length : Buffer.from(file.content).length;
-      return sum + size;
-    }, 0);
-    if (totalSize > this.options.maxFileSize) {
-      throw new FileSizeExceededError(totalSize, this.options.maxFileSize);
-    }
-    const needsChunking = totalSize > this.options.chunkSize;
-    try {
-      const result = await this.uploadWithRetry(
-        this.primaryProvider,
-        this.options.provider,
-        options,
-        needsChunking
-      );
-      return this.buildUploadResult(result.cid, result.size, startTime, options.pin ?? true);
-    } catch (primaryError) {
-      console.warn(`Primary provider ${this.options.provider} failed:`, primaryError);
-      for (let i = 0; i < this.fallbackProviders.length; i++) {
-        const provider = this.fallbackProviders[i];
-        const providerType = this.options.fallbackProviders[i].provider;
-        try {
-          const result = await this.uploadWithRetry(provider, providerType, options, needsChunking);
-          return this.buildUploadResult(result.cid, result.size, startTime, options.pin ?? true);
-        } catch (error) {
-          console.warn(`Fallback provider ${providerType} failed:`, error);
-          continue;
-        }
-      }
-      throw new IPFSUploadError(
-        "Upload failed on all providers",
-        this.options.provider,
-        primaryError
-      );
-    }
-  }
-  /**
-   * Upload with retry logic
-   */
-  async uploadWithRetry(provider, providerType, options, needsChunking) {
-    let lastError;
-    for (let attempt = 0; attempt < this.options.maxRetries; attempt++) {
-      try {
-        if (needsChunking) {
-          return await this.uploadChunked(provider, options);
-        } else {
-          if (options.onProgress) {
-            const totalSize = options.files.reduce((sum, file) => {
-              const size = file.content instanceof Buffer || file.content instanceof Uint8Array ? file.content.length : Buffer.from(file.content).length;
-              return sum + size;
-            }, 0);
-            let uploadedBytes = 0;
-            for (const file of options.files) {
-              const size = file.content instanceof Buffer || file.content instanceof Uint8Array ? file.content.length : Buffer.from(file.content).length;
-              uploadedBytes += size;
-              options.onProgress({
-                uploadedBytes,
-                totalBytes: totalSize,
-                percentage: uploadedBytes / totalSize * 100,
-                currentFile: file.path
-              });
-            }
-          }
-          return await provider.upload(options.files, options);
-        }
-      } catch (error) {
-        lastError = error;
-        if (attempt < this.options.maxRetries - 1) {
-          const delay = this.options.retryDelay * Math.pow(2, attempt);
-          await this.delay(delay);
-        }
-      }
-    }
-    throw new IPFSUploadError(
-      `Upload failed after ${this.options.maxRetries} attempts`,
-      providerType,
-      lastError
-    );
-  }
-  /**
-   * Upload large files in chunks
-   *
-   * Breaks large files into smaller chunks, uploads them separately,
-   * and combines them into a single IPFS directory.
-   */
-  async uploadChunked(provider, options) {
-    const chunks = [];
-    let totalSize = 0;
-    let uploadedBytes = 0;
-    for (const file of options.files) {
-      const content = file.content instanceof Buffer || file.content instanceof Uint8Array ? file.content : Buffer.from(file.content);
-      const fileSize = content.length;
-      totalSize += fileSize;
-      if (fileSize > this.options.chunkSize) {
-        const numChunks = Math.ceil(fileSize / this.options.chunkSize);
-        for (let i = 0; i < numChunks; i++) {
-          const start = i * this.options.chunkSize;
-          const end = Math.min(start + this.options.chunkSize, fileSize);
-          const chunk = content.slice(start, end);
-          chunks.push({
-            path: `${file.path}.chunk${i}`,
-            content: chunk
-          });
-          uploadedBytes += chunk.length;
-          if (options.onProgress) {
-            options.onProgress({
-              uploadedBytes,
-              totalBytes: totalSize,
-              percentage: uploadedBytes / totalSize * 100,
-              currentFile: file.path
-            });
-          }
-        }
-      } else {
-        chunks.push(file);
-        uploadedBytes += fileSize;
-        if (options.onProgress) {
-          options.onProgress({
-            uploadedBytes,
-            totalBytes: totalSize,
-            percentage: uploadedBytes / totalSize * 100,
-            currentFile: file.path
-          });
-        }
-      }
-    }
-    return await provider.upload(chunks, options);
-  }
-  /**
-   * Build upload result
-   */
-  buildUploadResult(cid, size, startTime, pinned) {
-    const gatewayUrl = `${this.options.gatewayUrl}/${cid}`;
-    const cdnUrl = this.options.enableCDN ? `${this.cdnGateway}/${cid}` : void 0;
-    return {
-      cid,
-      uri: `ipfs://${cid}`,
-      gatewayUrl,
-      cdnUrl,
-      pinned,
-      size,
-      duration: Date.now() - startTime
-    };
-  }
-  /**
-   * Pin existing CID to IPFS
-   *
-   * @param cid IPFS CID to pin
-   * @param name Optional name for the pin
-   * @throws {IPFSPinError} If pin operation fails
-   */
-  async pin(cid, name) {
-    try {
-      await this.primaryProvider.pin(cid, name);
-    } catch (error) {
-      throw new IPFSPinError(`Failed to pin CID ${cid}`, cid, error);
-    }
-  }
-  /**
-   * Unpin CID from IPFS
-   *
-   * @param cid IPFS CID to unpin
-   * @throws {IPFSPinError} If unpin operation fails
-   */
-  async unpin(cid) {
-    try {
-      await this.primaryProvider.unpin(cid);
-    } catch (error) {
-      throw new IPFSPinError(`Failed to unpin CID ${cid}`, cid, error);
-    }
-  }
-  /**
-   * Get pin status for CID
-   *
-   * @param cid IPFS CID to check
-   * @returns Pin status ('pinned', 'pinning', or 'unpinned')
-   */
-  async getPinStatus(cid) {
-    return await this.primaryProvider.getPinStatus(cid);
-  }
-  /**
-   * Verify CID exists and is accessible
-   *
-   * @param cid IPFS CID to verify
-   * @returns True if CID is accessible
-   */
-  async verifyCID(cid) {
-    return await this.primaryProvider.verifyCID(cid);
-  }
-  /**
-   * Get file from IPFS
-   *
-   * @param cid IPFS CID
-   * @param path Optional path within directory
-   * @returns File content as Uint8Array
-   */
-  async get(cid, path) {
-    const url = path ? `${this.options.gatewayUrl}/${cid}/${path}` : `${this.options.gatewayUrl}/${cid}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch CID ${cid}: ${response.statusText}`);
-    }
-    const buffer = await response.arrayBuffer();
-    return new Uint8Array(buffer);
-  }
-  /**
-   * List all pins for account
-   *
-   * @returns Array of pin information
-   */
-  async listPins() {
-    return await this.primaryProvider.listPins();
-  }
-  /**
-   * Delay helper for retry logic
-   */
-  delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  /**
-   * Get CDN URL for CID
-   *
-   * @param cid IPFS CID
-   * @returns CDN URL if enabled, otherwise gateway URL
-   */
-  getCDNUrl(cid) {
-    return this.options.enableCDN ? `${this.cdnGateway}/${cid}` : `${this.options.gatewayUrl}/${cid}`;
-  }
-  /**
-   * Get gateway URL for CID
-   *
-   * @param cid IPFS CID
-   * @returns Gateway URL
-   */
-  getGatewayUrl(cid) {
-    return `${this.options.gatewayUrl}/${cid}`;
-  }
-  /**
-   * Get IPFS URI for CID
-   *
-   * @param cid IPFS CID
-   * @returns IPFS URI (ipfs://...)
-   */
-  getIPFSUri(cid) {
-    return `ipfs://${cid}`;
-  }
-};
-
-exports.FileSizeExceededError = FileSizeExceededError;
-exports.IPFSPinError = IPFSPinError;
-exports.IPFSService = IPFSService;
-exports.IPFSUploadError = IPFSUploadError;
-exports.InfuraProvider = InfuraProvider;
-exports.NFTStorageProvider = NFTStorageProvider;
-exports.PinataProvider = PinataProvider;
-//# sourceMappingURL=chunk-7LCYLPW2.cjs.map
-//# sourceMappingURL=chunk-7LCYLPW2.cjs.map