@rohitaryal/whisk-api 4.0.0 → 4.0.1

package/dist/Project.d.ts

@@ -1,5 +1,5 @@
 import { Media } from "./Media.js";
-import type { MediaReference, PromptConfig } from "./Types.js";
+import type { ImageInput, MediaReference, PromptConfig } from "./Types.js";
 import { Account } from "./Whisk.js";
 export declare class Project {
     readonly account: Account;
@@ -11,21 +11,29 @@ export declare class Project {
     /**
      * Uploads a custom image and adds it as a subject reference
      *
-     * @param rawBytes Base64 encoded image (with or without data URI prefix)
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
      */
-    addSubject(rawBytes: string): Promise<void>;
+    addSubject(input: ImageInput): Promise<MediaReference>;
     /**
      * Uploads a custom image and adds it as a scene reference
      *
-     * @param rawBytes Base64 encoded image (with or without data URI prefix)
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
      */
-    addScene(rawBytes: string): Promise<void>;
+    addScene(input: ImageInput): Promise<MediaReference>;
     /**
      * Uploads a custom image and adds it as a style reference
      *
-     * @param rawBytes Base64 encoded image (with or without data URI prefix)
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
      */
-    addStyle(rawBytes: string): Promise<void>;
+    addStyle(input: ImageInput): Promise<MediaReference>;
+    addSubjectById(mediaGenerationId: string, prompt: string): void;
+    addSceneById(mediaGenerationId: string, prompt: string): void;
+    addStyleById(mediaGenerationId: string, prompt: string): void;
+    removeSubject(mediaGenerationId: string): MediaReference;
+    removeScene(mediaGenerationId: string): MediaReference;
+    removeStyle(mediaGenerationId: string): MediaReference;
+    private addById;
+    private removeById;
     private addReference;
     generateImage(input: string | PromptConfig): Promise<Media>;
     /**

package/dist/Project.js

@@ -1,6 +1,6 @@
 import { ImageGenerationModel, MediaCategory } from "./Constants.js";
 import { Media } from "./Media.js";
-import { request } from "./Utils.js";
+import { request, resolveImageInput } from "./Utils.js";
 import { Account, Whisk } from "./Whisk.js";
 export class Project {
     account;
@@ -24,28 +24,69 @@ export class Project {
     /**
      * Uploads a custom image and adds it as a subject reference
      *
-     * @param rawBytes Base64 encoded image (with or without data URI prefix)
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
      */
-    async addSubject(rawBytes) {
-        await this.addReference(rawBytes, MediaCategory.SUBJECT, this.subjects);
+    async addSubject(input) {
+        return this.addReference(input, MediaCategory.SUBJECT, this.subjects);
     }
     /**
      * Uploads a custom image and adds it as a scene reference
      *
-     * @param rawBytes Base64 encoded image (with or without data URI prefix)
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
      */
-    async addScene(rawBytes) {
-        await this.addReference(rawBytes, MediaCategory.SCENE, this.scenes);
+    async addScene(input) {
+        return this.addReference(input, MediaCategory.SCENE, this.scenes);
     }
     /**
      * Uploads a custom image and adds it as a style reference
      *
-     * @param rawBytes Base64 encoded image (with or without data URI prefix)
+     * @param input Image as { file: string }, { url: string }, or { base64: string }
      */
-    async addStyle(rawBytes) {
-        await this.addReference(rawBytes, MediaCategory.STYLE, this.styles);
+    async addStyle(input) {
+        return this.addReference(input, MediaCategory.STYLE, this.styles);
     }
-    async addReference(rawBytes, category, target) {
+    addSubjectById(mediaGenerationId, prompt) {
+        this.addById(mediaGenerationId, prompt, this.subjects);
+    }
+    addSceneById(mediaGenerationId, prompt) {
+        this.addById(mediaGenerationId, prompt, this.scenes);
+    }
+    addStyleById(mediaGenerationId, prompt) {
+        this.addById(mediaGenerationId, prompt, this.styles);
+    }
+    removeSubject(mediaGenerationId) {
+        return this.removeById(mediaGenerationId, this.subjects);
+    }
+    removeScene(mediaGenerationId) {
+        return this.removeById(mediaGenerationId, this.scenes);
+    }
+    removeStyle(mediaGenerationId) {
+        return this.removeById(mediaGenerationId, this.styles);
+    }
+    addById(mediaGenerationId, prompt, target) {
+        if (typeof mediaGenerationId !== "string" || !mediaGenerationId.trim()) {
+            throw new Error("media generation id is required");
+        }
+        if (typeof prompt !== "string" || !prompt.trim()) {
+            throw new Error("prompt is required");
+        }
+        if (target.some(ref => ref.mediaGenerationId === mediaGenerationId)) {
+            throw new Error(`'${mediaGenerationId}': reference already exists`);
+        }
+        target.push({ prompt, mediaGenerationId });
+    }
+    removeById(mediaGenerationId, target) {
+        if (typeof mediaGenerationId !== "string" || !mediaGenerationId.trim()) {
+            throw new Error("media generation id is required");
+        }
+        const index = target.findIndex(ref => ref.mediaGenerationId === mediaGenerationId);
+        if (index === -1) {
+            throw new Error(`'${mediaGenerationId}': reference not found`);
+        }
+        return target.splice(index, 1)[0];
+    }
+    async addReference(input, category, target) {
+        const rawBytes = await resolveImageInput(input);
         if (!(rawBytes?.trim?.())) {
             throw new Error("image data is required");
         }
@@ -68,7 +109,9 @@ export class Project {
         });
         const caption = captions.candidates[0].output;
         const uploadMediaGenerationId = await Whisk.uploadImage(rawBytes, caption, category, this.projectId, this.account);
-        target.push({ prompt: caption, mediaGenerationId: uploadMediaGenerationId });
+        const ref = { prompt: caption, mediaGenerationId: uploadMediaGenerationId };
+        target.push(ref);
+        return ref;
     }
     async generateImage(input) {
         if (typeof input === "string") {

package/dist/Types.d.ts

@@ -29,3 +29,10 @@ export interface MediaReference {
     prompt: string;
     mediaGenerationId: string;
 }
+export type ImageInput = {
+    file: string;
+} | {
+    url: string;
+} | {
+    base64: string;
+};

package/dist/Utils.d.ts

@@ -1,4 +1,4 @@
-import type { ImageExtensionTypes } from "./Types.js";
+import type { ImageInput } from "./Types.js";
 /**
  * Make a request, thats all
  *
@@ -12,10 +12,5 @@ export declare function request<T>(input: RequestInfo | URL, init?: RequestInit)
  * @param url URL of the image to fetch
  */
 export declare function imageFromUrl(url: string): Promise<string>;
-/**
- * Returns base64 encoded image
- *
- * @param imagePath Path to image file
- * @param imageType Extension of image (if that matters)
- */
-export declare function imageToBase64(imagePath: string, imageType?: ImageExtensionTypes): Promise<string>;
+export declare function resolveImageInput(input: ImageInput): Promise<string>;
+export declare function imageToBase64(imagePath: string): Promise<string>;

package/dist/Utils.js

@@ -32,27 +32,28 @@ export async function imageFromUrl(url) {
     if (!response.ok) {
         throw new Error(`Failed to fetch image (${response.status}): ${url}`);
     }
-    const contentType = response.headers.get("content-type") || "image/png";
+    const contentType = response.headers.get("content-type") || "";
+    const imageType = contentType.split("/")[1]?.split(";")[0];
+    if (!Object.values(ImageExtension).includes(imageType)) {
+        throw new Error(`'${url}': unsupported image type '${contentType}'`);
+    }
     const buffer = Buffer.from(await response.arrayBuffer());
-    return `data:${contentType};base64,${buffer.toString("base64")}`;
+    return `data:image/${imageType};base64,${buffer.toString("base64")}`;
 }
-/**
- * Returns base64 encoded image
- *
- * @param imagePath Path to image file
- * @param imageType Extension of image (if that matters)
- */
-export async function imageToBase64(imagePath, imageType) {
+export async function resolveImageInput(input) {
+    if ("file" in input)
+        return await imageToBase64(input.file);
+    if ("url" in input)
+        return await imageFromUrl(input.url);
+    return input.base64;
+}
+export async function imageToBase64(imagePath) {
     if (!(imagePath?.trim?.()) || !fs.existsSync(imagePath)) {
         throw new Error(`'${imagePath}': image not found`);
     }
-    // Try to figure out image type from its extension
-    if (!(imageType?.trim?.())) {
-        imageType = path.extname(imagePath).slice(1);
-    }
-    // If extension not in valid extension list throw error
+    const imageType = path.extname(imagePath).slice(1);
     if (!Object.values(ImageExtension).includes(imageType)) {
-        throw new Error(`'${imagePath}': couldn't identify image type, please specify 'imageType'`);
+        throw new Error(`'${imagePath}': unsupported image type '${imageType}'`);
     }
     const base64Header = `data:image/${imageType};base64,`;
     return new Promise((resolve, reject) => {

package/dist/index.d.ts

@@ -3,3 +3,5 @@ export { Whisk } from "./Whisk.js";
 export { Media } from "./Media.js";
 export { Project } from "./Project.js";
 export * from "./Types.js";
+export * from "./Constants.js";
+export { imageToBase64, imageFromUrl } from "./Utils.js";

package/dist/index.js

@@ -3,3 +3,5 @@ export { Whisk } from "./Whisk.js";
 export { Media } from "./Media.js";
 export { Project } from "./Project.js";
 export * from "./Types.js";
+export * from "./Constants.js";
+export { imageToBase64, imageFromUrl } from "./Utils.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rohitaryal/whisk-api",
-    "version": "4.0.0",
+    "version": "4.0.1",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",