@coreviz/sdk 1.0.14 → 1.0.17

package/README.md

@@ -51,6 +51,17 @@ Check out [coreviz.io/tools](https://coreviz.io/tools) to explore these features
 npm install @coreviz/sdk
 ```
 
+### React Native / Expo
+
+When using this SDK in Expo / React Native, install the Expo image utilities (used for `resize`):
+
+```bash
+npx expo install expo-image-manipulator expo-file-system
+```
+
+Notes:
+- **Local mode** (`mode: 'local'`) for `tag()` / `embed()` is **not supported** on React Native / Expo.
+
 ## Configuration
 
 To use the AI features, you need to instantiate the `CoreViz` class with your API key.

package/dist/coreviz.native.d.ts

@@ -0,0 +1,49 @@
+export interface CoreVizConfig {
+    apiKey?: string;
+    token?: string;
+}
+export interface DescribeOptions {
+}
+export interface EditOptions {
+    prompt: string;
+    aspectRatio?: 'match_input_image' | '1:1' | '16:9' | '9:16' | '4:3' | '3:4';
+    outputFormat?: 'jpg' | 'png';
+    model?: 'flux-kontext-max' | 'google/nano-banana' | 'seedream-4';
+}
+export interface TagOptions {
+    prompt: string;
+    options?: string[];
+    multiple?: boolean;
+    mode?: 'api' | 'local';
+}
+export interface TagResponse {
+    tags: string[];
+    raw?: unknown;
+}
+export interface EmbedOptions {
+    type?: 'image' | 'text';
+    mode?: 'api' | 'local';
+}
+export interface EmbedResponse {
+    embedding: number[];
+}
+export interface BatchGenerateOptions {
+    referenceImages?: string[];
+    count?: number;
+    aspectRatio?: '1:1' | '2:3' | '3:2' | '3:4' | '4:3' | '4:5' | '5:4' | '9:16' | '16:9' | '21:9';
+    model?: 'google/nano-banana' | 'google/nano-banana-pro';
+}
+export declare class CoreViz {
+    private apiKey?;
+    private token?;
+    constructor(config?: CoreVizConfig);
+    private getHeaders;
+    private handleResponse;
+    describe(image: string, _options?: DescribeOptions): Promise<string>;
+    edit(image: string, options: EditOptions): Promise<string>;
+    batchGenerate(prompt: string, options?: BatchGenerateOptions): Promise<string[]>;
+    tag(image: string, options: TagOptions): Promise<TagResponse>;
+    embed(input: string, options?: EmbedOptions): Promise<EmbedResponse>;
+    resize(input: string | File, maxWidth?: number, maxHeight?: number): Promise<string>;
+    similarity(vecA: number[], vecB: number[]): number;
+}

package/dist/coreviz.native.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreViz = void 0;
+const resize_native_1 = require("./resize.native");
+class CoreViz {
+    constructor(config = {}) {
+        // React Native / Expo doesn't provide `process.env` in the same way; keep config explicit.
+        this.apiKey = config.apiKey;
+        this.token = config.token;
+    }
+    getHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.token) {
+            headers['Authorization'] = `Bearer ${this.token}`;
+        }
+        else {
+            headers['x-api-key'] = this.apiKey || '';
+        }
+        return headers;
+    }
+    async handleResponse(response) {
+        if (response.status === 402) {
+            throw new Error('Insufficient credits');
+        }
+        if (!response.ok) {
+            throw new Error(`Request failed (${response.status})`);
+        }
+        const data = (await response.json());
+        if (data.error) {
+            throw new Error(data.error);
+        }
+        return data;
+    }
+    async describe(image, _options) {
+        const resizedImage = await (0, resize_native_1.resize)(image, 512, 512);
+        const headers = this.getHeaders();
+        const response = await fetch(`https://lab.coreviz.io/api/ai/describe`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({ image: resizedImage }),
+        });
+        const data = await this.handleResponse(response);
+        return data.description;
+    }
+    async edit(image, options) {
+        const resizedImage = await (0, resize_native_1.resize)(image, 1024, 1024);
+        const headers = this.getHeaders();
+        const response = await fetch(`https://lab.coreviz.io/api/ai/edit`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                image: resizedImage,
+                prompt: options.prompt,
+                aspectRatio: options.aspectRatio || 'match_input_image',
+                outputFormat: options.outputFormat || 'jpg',
+                model: options.model || 'flux-kontext-max',
+            }),
+        });
+        const data = await this.handleResponse(response);
+        return data.result;
+    }
+    async batchGenerate(prompt, options = {}) {
+        const headers = this.getHeaders();
+        let resizedImages = [];
+        if (options.referenceImages && options.referenceImages.length > 0) {
+            resizedImages = await Promise.all(options.referenceImages.map((img) => (0, resize_native_1.resize)(img, 1024, 1024)));
+        }
+        const response = await fetch(`https://lab.coreviz.io/api/ai/batch-generate`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                prompt,
+                image: resizedImages.length > 0 ? resizedImages : undefined,
+                count: options.count || 1,
+                aspectRatio: options.aspectRatio,
+                model: options.model || 'google/nano-banana-pro',
+            }),
+        });
+        const data = await this.handleResponse(response);
+        return data.results || [];
+    }
+    async tag(image, options) {
+        const mode = options?.mode || 'api';
+        if (mode === 'local') {
+            throw new Error("Local tagging is not supported on React Native/Expo. Use `mode: 'api'`.");
+        }
+        const resizedImage = await (0, resize_native_1.resize)(image, 512, 512);
+        const headers = this.getHeaders();
+        const response = await fetch('https://lab.coreviz.io/api/ai/tag', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                image: resizedImage,
+                prompt: options.prompt,
+                options: options.options && options.options.length > 0 ? options.options : undefined,
+                multiple: options.multiple ?? true,
+            }),
+        });
+        const data = await this.handleResponse(response);
+        const tags = Array.isArray(data.tags)
+            ? data.tags
+            : Array.isArray(data.result)
+                ? data.result
+                : typeof data.tag === 'string'
+                    ? [data.tag]
+                    : [];
+        return {
+            tags,
+            raw: data,
+        };
+    }
+    async embed(input, options) {
+        const mode = options?.mode || 'api';
+        if (mode === 'local') {
+            throw new Error("Local embedding is not supported on React Native/Expo. Use `mode: 'api'`.");
+        }
+        const headers = this.getHeaders();
+        let body = {};
+        // Determine type
+        let isImage = false;
+        if (options?.type) {
+            isImage = options.type === 'image';
+        }
+        else {
+            // Heuristic: assume URL/data:image => image
+            isImage = input.startsWith('data:image') || input.startsWith('http://') || input.startsWith('https://') || input.startsWith('file://');
+        }
+        if (isImage) {
+            const resizedImage = await (0, resize_native_1.resize)(input, 512, 512);
+            body.image = resizedImage;
+        }
+        else {
+            body.text = input;
+        }
+        const response = await fetch('https://lab.coreviz.io/api/ai/embed', {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+        const data = await this.handleResponse(response);
+        return data;
+    }
+    async resize(input, maxWidth, maxHeight) {
+        return (0, resize_native_1.resize)(input, maxWidth, maxHeight);
+    }
+    similarity(vecA, vecB) {
+        if (vecA.length !== vecB.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < vecA.length; i++) {
+            dotProduct += vecA[i] * vecB[i];
+            normA += vecA[i] * vecA[i];
+            normB += vecB[i] * vecB[i];
+        }
+        if (normA === 0 || normB === 0)
+            return 0;
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+}
+exports.CoreViz = CoreViz;

package/dist/index.native.d.ts

@@ -0,0 +1,4 @@
+import { CoreViz, CoreVizConfig, DescribeOptions, EditOptions, TagOptions, TagResponse, EmbedOptions, EmbedResponse } from './coreviz.native';
+import { resize } from './resize.native';
+export { CoreViz, resize };
+export type { CoreVizConfig, DescribeOptions, EditOptions, TagOptions, TagResponse, EmbedOptions, EmbedResponse };

package/dist/index.native.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resize = exports.CoreViz = void 0;
+const coreviz_native_1 = require("./coreviz.native");
+Object.defineProperty(exports, "CoreViz", { enumerable: true, get: function () { return coreviz_native_1.CoreViz; } });
+const resize_native_1 = require("./resize.native");
+Object.defineProperty(exports, "resize", { enumerable: true, get: function () { return resize_native_1.resize; } });

package/dist/resize.js

@@ -112,6 +112,7 @@ async function serverResize(inputStr, maxWidth, maxHeight) {
     }
     try {
         // Dynamic import to prevent bundling sharp on the client
+        // Note: `sharp` is an optional dependency (for RN/Expo compatibility). If missing, we gracefully fall back.
         const sharpModule = await Promise.resolve().then(() => __importStar(require('sharp')));
         const sharp = sharpModule.default;
         let buffer;
@@ -155,7 +156,7 @@ async function serverResize(inputStr, maxWidth, maxHeight) {
         return inputStr;
     }
     catch (error) {
-        console.warn("Failed to resize image on server:", error);
+        console.warn("Failed to resize image on server. If you need server-side resizing, ensure `sharp` is installed. Falling back to original image.", error);
         return inputStr; // Fallback to original
     }
 }

package/dist/resize.native.d.ts

@@ -0,0 +1,16 @@
+/**
+ * React Native / Expo image resize implementation.
+ *
+ * - Uses `expo-image-manipulator` to resize while preserving aspect ratio (fit: inside).
+ * - Supports inputs:
+ *   - `file://...` URIs (typical from Expo ImagePicker/Camera)
+ *   - `data:image/...;base64,...` data URLs
+ *   - `http(s)://...` URLs (downloaded to cache first)
+ *
+ * Dependencies (expected to be installed by Expo apps):
+ * - expo-image-manipulator
+ * - expo-file-system
+ */
+type ResizeInput = string | File;
+export declare function resize(input: ResizeInput, maxWidth?: number, maxHeight?: number): Promise<string>;
+export {};

package/dist/resize.native.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * React Native / Expo image resize implementation.
+ *
+ * - Uses `expo-image-manipulator` to resize while preserving aspect ratio (fit: inside).
+ * - Supports inputs:
+ *   - `file://...` URIs (typical from Expo ImagePicker/Camera)
+ *   - `data:image/...;base64,...` data URLs
+ *   - `http(s)://...` URLs (downloaded to cache first)
+ *
+ * Dependencies (expected to be installed by Expo apps):
+ * - expo-image-manipulator
+ * - expo-file-system
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resize = resize;
+function isDataUrl(s) {
+    return /^data:image\/\w+;base64,/.test(s);
+}
+function isHttpUrl(s) {
+    return /^https?:\/\//.test(s);
+}
+function getExtFromDataUrl(dataUrl) {
+    const m = dataUrl.match(/^data:(image\/\w+);base64,/);
+    const mime = m?.[1] || 'image/jpeg';
+    return mime.includes('png') ? 'png' : 'jpg';
+}
+function fitInside(width, height, maxWidth, maxHeight) {
+    if (width <= 0 || height <= 0)
+        return { width, height };
+    const wRatio = maxWidth / width;
+    const hRatio = maxHeight / height;
+    const ratio = Math.min(wRatio, hRatio, 1); // never enlarge
+    return { width: Math.round(width * ratio), height: Math.round(height * ratio) };
+}
+async function getImageSize(uri) {
+    // Importing from 'react-native' is safe for RN builds; this file is never used in web/node builds.
+    const { Image } = await Promise.resolve().then(() => __importStar(require('react-native')));
+    return await new Promise((resolve, reject) => {
+        Image.getSize(uri, (width, height) => resolve({ width, height }), (error) => reject(error));
+    });
+}
+async function ensureLocalFileUri(input) {
+    const FileSystem = await Promise.resolve().then(() => __importStar(require('expo-file-system/legacy')));
+    const cacheDir = FileSystem.cacheDirectory;
+    // data URL -> write to cache
+    if (isDataUrl(input)) {
+        const format = getExtFromDataUrl(input);
+        const base64Data = input.split(',')[1] || '';
+        const fileUri = `${cacheDir}coreviz_${Date.now()}.${format}`;
+        await FileSystem.writeAsStringAsync(fileUri, base64Data, { encoding: FileSystem.EncodingType.Base64 });
+        return { uri: fileUri, format };
+    }
+    // http(s) URL -> download to cache
+    if (isHttpUrl(input)) {
+        const format = input.toLowerCase().includes('.png') ? 'png' : 'jpg';
+        const fileUri = `${cacheDir}coreviz_${Date.now()}.${format}`;
+        const res = await FileSystem.downloadAsync(input, fileUri);
+        return { uri: res.uri, format };
+    }
+    // assume it's already a local file URI (file://...) or a content URI
+    return { uri: input, format: 'jpg' };
+}
+async function resize(input, maxWidth = 1920, maxHeight = 1080) {
+    if (typeof input !== 'string') {
+        throw new Error('React Native resizing only supports string inputs (file URI, data URL, or http(s) URL).');
+    }
+    // Lazy import to keep this module Expo-safe and avoid forcing deps in web/node builds.
+    let ImageManipulator;
+    try {
+        ImageManipulator = await Promise.resolve().then(() => __importStar(require('expo-image-manipulator')));
+    }
+    catch (e) {
+        throw new Error("Missing optional dependency 'expo-image-manipulator'. Install it in your Expo app: `npx expo install expo-image-manipulator`");
+    }
+    const { uri, format } = await ensureLocalFileUri(input);
+    const { width, height } = await getImageSize(uri);
+    const target = fitInside(width, height, maxWidth, maxHeight);
+    // If already within constraints, still normalize to a data URL (so downstream API calls always have base64 available).
+    const actions = target.width === width && target.height === height ? [] : [{ resize: { width: target.width, height: target.height } }];
+    const saveFormat = format === 'png' ? ImageManipulator.SaveFormat.PNG : ImageManipulator.SaveFormat.JPEG;
+    const result = await ImageManipulator.manipulateAsync(uri, actions, {
+        base64: true,
+        compress: saveFormat === ImageManipulator.SaveFormat.JPEG ? 0.92 : 1,
+        format: saveFormat,
+    });
+    if (!result.base64) {
+        throw new Error('Failed to produce base64 output during resize.');
+    }
+    const mime = saveFormat === ImageManipulator.SaveFormat.PNG ? 'image/png' : 'image/jpeg';
+    return `data:${mime};base64,${result.base64}`;
+}

package/package.json

@@ -1,9 +1,22 @@
 {
   "name": "@coreviz/sdk",
-  "version": "1.0.14",
+  "version": "1.0.17",
   "description": "CoreViz SDK",
   "main": "dist/index.js",
+  "react-native": "dist/index.native.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "react-native": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.native.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
   "files": [
     "dist",
     "README.md"
@@ -31,8 +44,21 @@
     "@types/node": "^24.10.1",
     "typescript": "^5.9.3"
   },
-  "dependencies": {
+  "dependencies": {},
+  "optionalDependencies": {
     "sharp": "^0.34.5",
     "@huggingface/transformers": "^3.8.0"
+  },
+  "peerDependencies": {
+    "expo-file-system": "*",
+    "expo-image-manipulator": "*"
+  },
+  "peerDependenciesMeta": {
+    "expo-file-system": {
+      "optional": true
+    },
+    "expo-image-manipulator": {
+      "optional": true
+    }
   }
 }