@blinkdotnew/sdk 0.14.13 → 0.17.0

package/dist/index.js

@@ -1817,20 +1817,27 @@ var BlinkStorageImpl = class {
    * Upload a file to project storage
    * 
    * @param file - File, Blob, or Buffer to upload
-   * @param path - Destination path within project storage
+   * @param path - Destination path within project storage (extension will be auto-corrected to match file type)
    * @param options - Upload options including upsert and progress callback
    * @returns Promise resolving to upload response with public URL
    * 
    * @example
    * ```ts
+   * // Extension automatically corrected to match actual file type
    * const { publicUrl } = await blink.storage.upload(
-   *   fileInput.files[0],
-   *   `avatars/${user.id}.png`,
-   *   {
-   *     upsert: true,
-   *     onProgress: pct => console.log(`${pct}%`)
-   *   }
+   *   pngFile,
+   *   `avatars/${user.id}`, // No extension needed!
+   *   { upsert: true }
+   * );
+   * // If file is PNG, final path will be: avatars/user123.png
+   * 
+   * // Or with extension (will be corrected if wrong)
+   * const { publicUrl } = await blink.storage.upload(
+   *   pngFile,
+   *   `avatars/${user.id}.jpg`, // Wrong extension
+   *   { upsert: true }
    * );
+   * // Final path will be: avatars/user123.png (auto-corrected!)
    * ```
    */
   async upload(file, path, options = {}) {
@@ -1851,10 +1858,12 @@ var BlinkStorageImpl = class {
       if (fileSize > maxSize) {
         throw new BlinkStorageError(`File size (${Math.round(fileSize / 1024 / 1024)}MB) exceeds maximum allowed size (50MB)`);
       }
+      const { correctedPath, detectedContentType } = await this.detectFileTypeAndCorrectPath(file, path);
       const response = await this.httpClient.uploadFile(
         `/api/storage/${this.httpClient.projectId}/upload`,
         file,
-        path,
+        correctedPath,
+        // Use corrected path with proper extension
         {
           upsert: options.upsert,
           onProgress: options.onProgress
@@ -1887,6 +1896,200 @@ var BlinkStorageImpl = class {
       );
     }
   }
+  /**
+   * Detect file type from actual file content and correct path extension
+   * This ensures the path extension always matches the actual file type
+   */
+  async detectFileTypeAndCorrectPath(file, originalPath) {
+    try {
+      const fileSignature = await this.getFileSignature(file);
+      const detectedType = this.detectFileTypeFromSignature(fileSignature);
+      let detectedContentType = detectedType.mimeType;
+      let detectedExtension = detectedType.extension;
+      if (!detectedContentType && file instanceof File && file.type) {
+        detectedContentType = file.type;
+        detectedExtension = this.getExtensionFromMimeType(file.type);
+      }
+      if (!detectedContentType) {
+        detectedContentType = "application/octet-stream";
+        detectedExtension = "bin";
+      }
+      const pathParts = originalPath.split("/");
+      const fileName = pathParts[pathParts.length - 1];
+      const directory = pathParts.slice(0, -1).join("/");
+      if (!fileName) {
+        throw new Error("Invalid path: filename cannot be empty");
+      }
+      const nameWithoutExt = fileName.includes(".") ? fileName.substring(0, fileName.lastIndexOf(".")) : fileName;
+      const correctedFileName = `${nameWithoutExt}.${detectedExtension}`;
+      const correctedPath = directory ? `${directory}/${correctedFileName}` : correctedFileName;
+      return {
+        correctedPath,
+        detectedContentType
+      };
+    } catch (error) {
+      console.warn("File type detection failed, using original path:", error);
+      return {
+        correctedPath: originalPath,
+        detectedContentType: "application/octet-stream"
+      };
+    }
+  }
+  /**
+   * Get the first few bytes of a file to analyze its signature
+   */
+  async getFileSignature(file) {
+    const bytesToRead = 12;
+    if (typeof Buffer !== "undefined" && file instanceof Buffer) {
+      return new Uint8Array(file.slice(0, bytesToRead));
+    }
+    if (file instanceof File || file instanceof Blob) {
+      const slice = file.slice(0, bytesToRead);
+      const arrayBuffer = await slice.arrayBuffer();
+      return new Uint8Array(arrayBuffer);
+    }
+    throw new Error("Unsupported file type for signature detection");
+  }
+  /**
+   * Detect file type from file signature (magic numbers)
+   * This is the most reliable way to detect actual file type
+   */
+  detectFileTypeFromSignature(signature) {
+    const hex = Array.from(signature).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const signatures = {
+      // Images
+      "ffd8ff": { mimeType: "image/jpeg", extension: "jpg" },
+      "89504e47": { mimeType: "image/png", extension: "png" },
+      "47494638": { mimeType: "image/gif", extension: "gif" },
+      "52494646": { mimeType: "image/webp", extension: "webp" },
+      // RIFF (WebP container)
+      "424d": { mimeType: "image/bmp", extension: "bmp" },
+      "49492a00": { mimeType: "image/tiff", extension: "tiff" },
+      "4d4d002a": { mimeType: "image/tiff", extension: "tiff" },
+      // Documents
+      "25504446": { mimeType: "application/pdf", extension: "pdf" },
+      "504b0304": { mimeType: "application/zip", extension: "zip" },
+      // Also used by docx, xlsx
+      "d0cf11e0": { mimeType: "application/msword", extension: "doc" },
+      // Audio
+      "494433": { mimeType: "audio/mpeg", extension: "mp3" },
+      "664c6143": { mimeType: "audio/flac", extension: "flac" },
+      "4f676753": { mimeType: "audio/ogg", extension: "ogg" },
+      // Video
+      "000000": { mimeType: "video/mp4", extension: "mp4" },
+      // ftyp box
+      "1a45dfa3": { mimeType: "video/webm", extension: "webm" },
+      // Text
+      "efbbbf": { mimeType: "text/plain", extension: "txt" }
+      // UTF-8 BOM
+    };
+    for (const [sig, type] of Object.entries(signatures)) {
+      if (hex.startsWith(sig)) {
+        return type;
+      }
+    }
+    if (hex.startsWith("52494646") && hex.substring(16, 24) === "57454250") {
+      return { mimeType: "image/webp", extension: "webp" };
+    }
+    if (hex.substring(8, 16) === "66747970") {
+      return { mimeType: "video/mp4", extension: "mp4" };
+    }
+    return { mimeType: "", extension: "" };
+  }
+  /**
+   * Get file extension from MIME type as fallback
+   */
+  getExtensionFromMimeType(mimeType) {
+    const mimeToExt = {
+      "image/jpeg": "jpg",
+      "image/png": "png",
+      "image/gif": "gif",
+      "image/webp": "webp",
+      "image/bmp": "bmp",
+      "image/svg+xml": "svg",
+      "application/pdf": "pdf",
+      "text/plain": "txt",
+      "text/html": "html",
+      "text/css": "css",
+      "application/javascript": "js",
+      "application/json": "json",
+      "audio/mpeg": "mp3",
+      "audio/wav": "wav",
+      "audio/ogg": "ogg",
+      "video/mp4": "mp4",
+      "video/webm": "webm",
+      "application/zip": "zip"
+    };
+    return mimeToExt[mimeType] || "bin";
+  }
+  /**
+   * Get a download URL for a file that triggers browser download
+   * 
+   * @param path - Path to the file in project storage
+   * @param options - Download options including custom filename
+   * @returns Promise resolving to download response with download URL
+   * 
+   * @example
+   * ```ts
+   * // Download with original filename
+   * const { downloadUrl, filename } = await blink.storage.download('images/photo.jpg');
+   * window.open(downloadUrl, '_blank');
+   * 
+   * // Download with custom filename
+   * const { downloadUrl } = await blink.storage.download(
+   *   'images/photo.jpg',
+   *   { filename: 'my-photo.jpg' }
+   * );
+   * 
+   * // Create download link in React
+   * <a href={downloadUrl} download={filename}>Download Image</a>
+   * ```
+   */
+  async download(path, options = {}) {
+    try {
+      if (!path || typeof path !== "string" || !path.trim()) {
+        throw new BlinkStorageError("Path must be a non-empty string");
+      }
+      const response = await this.httpClient.request(
+        `/api/storage/${this.httpClient.projectId}/download`,
+        {
+          method: "GET",
+          searchParams: {
+            path: path.trim(),
+            ...options.filename && { filename: options.filename }
+          }
+        }
+      );
+      if (response.data?.downloadUrl) {
+        return {
+          downloadUrl: response.data.downloadUrl,
+          filename: response.data.filename || options.filename || path.split("/").pop() || "download",
+          contentType: response.data.contentType,
+          size: response.data.size
+        };
+      } else {
+        throw new BlinkStorageError("Invalid response format: missing downloadUrl");
+      }
+    } catch (error) {
+      if (error instanceof BlinkStorageError) {
+        throw error;
+      }
+      if (error instanceof Error && "status" in error) {
+        const status = error.status;
+        if (status === 404) {
+          throw new BlinkStorageError("File not found", 404);
+        }
+        if (status === 400) {
+          throw new BlinkStorageError("Invalid request parameters", 400);
+        }
+      }
+      throw new BlinkStorageError(
+        `Download failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
   /**
    * Remove one or more files from project storage
    * 
@@ -2354,15 +2557,15 @@ var BlinkAIImpl = class {
     }
   }
   /**
-   * Generates images from text descriptions using AI image models.
+   * Generates images from text descriptions using AI.
    * 
    * @param options - Object containing:
-   *   - `prompt`: Text description of the image to generate (required)
-   *   - `size`: Image dimensions (e.g., "1024x1024", "512x512") - varies by model
-   *   - `quality`: Image quality ("standard" or "hd")
+   *   - `prompt`: Text description of the desired image (required)
+   *   - `size`: Image dimensions (default: "1024x1024")
+   *   - `quality`: Image quality ("standard" or "hd", default: "standard")
    *   - `n`: Number of images to generate (default: 1)
-   *   - `response_format`: Output format ("url" or "b64_json")
-   *   - Plus optional model, signal parameters
+   *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+   *   - Plus optional signal parameter
    * 
    * @example
    * ```ts
@@ -2375,29 +2578,25 @@ var BlinkAIImpl = class {
    * // High-quality image with specific size
    * const { data } = await blink.ai.generateImage({
    *   prompt: "A futuristic city skyline with flying cars",
-   *   size: "1792x1024",
+   *   size: "1536x1024",
    *   quality: "hd",
-   *   model: "dall-e-3"
+   *   background: "transparent"
    * });
    * 
    * // Multiple images
    * const { data } = await blink.ai.generateImage({
    *   prompt: "A cute robot mascot for a tech company",
    *   n: 3,
-   *   size: "1024x1024"
+   *   size: "1024x1024",
+   *   quality: "hd"
    * });
    * data.forEach((img, i) => console.log(`Image ${i+1}:`, img.url));
-   * 
-   * // Base64 format for direct embedding
-   * const { data } = await blink.ai.generateImage({
-   *   prompt: "A minimalist logo design",
-   *   response_format: "b64_json"
-   * });
-   * console.log("Base64 data:", data[0].b64_json);
    * ```
    * 
    * @returns Promise<ImageGenerationResponse> - Object containing:
-   *   - `data`: Array of generated images with url or b64_json
+   *   - `data`: Array of generated images with URLs
+   *   - `created`: Timestamp of generation
+   *   - `usage`: Token usage information
    */
   async generateImage(options) {
     try {
@@ -2407,11 +2606,12 @@ var BlinkAIImpl = class {
       const response = await this.httpClient.aiImage(
         options.prompt,
         {
-          model: options.model,
+          model: "gpt-image-1",
           size: options.size,
           quality: options.quality,
           n: options.n,
-          response_format: options.response_format,
+          background: options.background,
+          response_format: "url",
           signal: options.signal
         }
       );
@@ -2431,10 +2631,8 @@ var BlinkAIImpl = class {
           return { url: item };
         } else if (item.url) {
           return item;
-        } else if (item.b64_json) {
-          return { b64_json: item.b64_json };
         } else {
-          return { url: item };
+          throw new BlinkAIError("Invalid image response format");
         }
       });
       return imageResponse;
@@ -2449,6 +2647,129 @@ var BlinkAIImpl = class {
       );
     }
   }
+  /**
+   * Modifies existing images using AI with text prompts for image-to-image editing.
+   * 
+   * @param options - Object containing:
+   *   - `images`: Array of public image URLs to modify (required, up to 16 images)
+   *   - `prompt`: Text description of desired modifications (required)
+   *   - `size`: Output image dimensions (default: "auto")
+   *   - `quality`: Image quality ("standard" or "hd", default: "standard")
+   *   - `n`: Number of output images to generate (default: 1)
+   *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+   *   - Plus optional signal parameter
+   * 
+   * @example
+   * ```ts
+   * // Professional headshots from casual photos
+   * const { data } = await blink.ai.modifyImage({
+   *   images: [
+   *     "https://storage.example.com/user-photo-1.jpg",
+   *     "https://storage.example.com/user-photo-2.jpg"
+   *   ],
+   *   prompt: "Transform into professional business headshots with studio lighting",
+   *   quality: "hd",
+   *   n: 4
+   * });
+   * data.forEach((img, i) => console.log(`Headshot ${i+1}:`, img.url));
+   * 
+   * // Artistic style transformation
+   * const { data } = await blink.ai.modifyImage({
+   *   images: ["https://storage.example.com/portrait.jpg"],
+   *   prompt: "Transform into oil painting style with dramatic lighting",
+   *   quality: "hd",
+   *   size: "1024x1024"
+   * });
+   * 
+   * // Background replacement
+   * const { data } = await blink.ai.modifyImage({
+   *   images: ["https://storage.example.com/product.jpg"],
+   *   prompt: "Remove background and place on clean white studio background",
+   *   background: "transparent",
+   *   n: 2
+   * });
+   * 
+   * // Batch processing multiple photos
+   * const userPhotos = [
+   *   "https://storage.example.com/photo1.jpg",
+   *   "https://storage.example.com/photo2.jpg",
+   *   "https://storage.example.com/photo3.jpg"
+   * ];
+   * const { data } = await blink.ai.modifyImage({
+   *   images: userPhotos,
+   *   prompt: "Convert to black and white vintage style photographs",
+   *   quality: "hd"
+   * });
+   * ```
+   * 
+   * @returns Promise<ImageGenerationResponse> - Object containing:
+   *   - `data`: Array of modified images with URLs
+   *   - `created`: Timestamp of generation
+   *   - `usage`: Token usage information
+   */
+  async modifyImage(options) {
+    try {
+      if (!options.prompt) {
+        throw new BlinkAIError("Prompt is required");
+      }
+      if (!options.images || !Array.isArray(options.images) || options.images.length === 0) {
+        throw new BlinkAIError("Images array is required and must contain at least one image URL");
+      }
+      if (options.images.length > 16) {
+        throw new BlinkAIError("Maximum 16 images allowed");
+      }
+      for (let i = 0; i < options.images.length; i++) {
+        const validation = this.validateImageUrl(options.images[i]);
+        if (!validation.isValid) {
+          throw new BlinkAIError(`Image ${i + 1}: ${validation.error}`);
+        }
+      }
+      const response = await this.httpClient.aiImage(
+        options.prompt,
+        // Non-null assertion since we validated above
+        {
+          model: "gpt-image-1",
+          images: options.images,
+          size: options.size,
+          quality: options.quality,
+          n: options.n,
+          background: options.background,
+          response_format: "url",
+          signal: options.signal
+        }
+      );
+      let imageResponse;
+      if (response.data?.result?.data) {
+        imageResponse = response.data.result;
+      } else if (response.data?.data) {
+        imageResponse = response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing image data");
+      }
+      if (!Array.isArray(imageResponse.data)) {
+        throw new BlinkAIError("Invalid response format: data should be an array");
+      }
+      imageResponse.data = imageResponse.data.map((item) => {
+        if (typeof item === "string") {
+          return { url: item };
+        } else if (item.url) {
+          return item;
+        } else {
+          throw new BlinkAIError("Invalid image response format");
+        }
+      });
+      return imageResponse;
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Image modification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
   /**
    * Converts text to speech using AI voice synthesis models.
    * 
@@ -2977,6 +3298,15 @@ var BlinkRealtimeChannel = class {
       } catch (err) {
       }
     };
+    const originalTimeout = timeout;
+    const cleanupTimeout = setTimeout(() => {
+      if (this.websocket) {
+        this.websocket.removeEventListener("message", handleResponse);
+      }
+      reject(new BlinkRealtimeError("Message send timeout - no response from server"));
+    }, 1e4);
+    queuedMessage.timeout = cleanupTimeout;
+    clearTimeout(originalTimeout);
     this.websocket.addEventListener("message", handleResponse);
     this.websocket.send(message);
   }
@@ -3393,6 +3723,15 @@ var BlinkAnalyticsImpl = class {
     this.enabled = false;
     this.clearTimer();
   }
+  /**
+   * Cleanup analytics instance (remove from global tracking)
+   */
+  destroy() {
+    this.disable();
+    if (typeof window !== "undefined") {
+      window.__blinkAnalyticsInstances?.delete(this);
+    }
+  }
   /**
    * Enable analytics tracking
    */
@@ -3559,19 +3898,37 @@ var BlinkAnalyticsImpl = class {
     }
   }
   setupRouteChangeListener() {
-    const originalPushState = history.pushState;
-    const originalReplaceState = history.replaceState;
-    history.pushState = (...args) => {
-      originalPushState.apply(history, args);
-      this.log("pageview");
-    };
-    history.replaceState = (...args) => {
-      originalReplaceState.apply(history, args);
-      this.log("pageview");
-    };
-    window.addEventListener("popstate", () => {
-      this.log("pageview");
-    });
+    if (!window.__blinkAnalyticsSetup) {
+      const originalPushState = history.pushState;
+      const originalReplaceState = history.replaceState;
+      const analyticsInstances = /* @__PURE__ */ new Set();
+      window.__blinkAnalyticsInstances = analyticsInstances;
+      history.pushState = (...args) => {
+        originalPushState.apply(history, args);
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      };
+      history.replaceState = (...args) => {
+        originalReplaceState.apply(history, args);
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      };
+      window.addEventListener("popstate", () => {
+        analyticsInstances.forEach((instance) => {
+          if (instance.isEnabled()) {
+            instance.log("pageview");
+          }
+        });
+      });
+      window.__blinkAnalyticsSetup = true;
+    }
+    window.__blinkAnalyticsInstances?.add(this);
   }
   setupUnloadListener() {
     window.addEventListener("pagehide", () => {