@runware/sdk-js 1.1.12 → 1.1.13

package/dist/esm/Runware/types.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EOpenPosePreProcessor = exports.EPreProcessor = exports.EPreProcessorGroup = exports.EControlMode = exports.ETaskType = exports.SdkType = exports.Environment = void 0;
+var Environment;
+(function (Environment) {
+    Environment["PRODUCTION"] = "PRODUCTION";
+    Environment["DEVELOPMENT"] = "DEVELOPMENT";
+    Environment["TEST"] = "TEST";
+})(Environment || (exports.Environment = Environment = {}));
+var SdkType;
+(function (SdkType) {
+    SdkType["CLIENT"] = "CLIENT";
+    SdkType["SERVER"] = "SERVER";
+})(SdkType || (exports.SdkType = SdkType = {}));
+var ETaskType;
+(function (ETaskType) {
+    ETaskType["IMAGE_INFERENCE"] = "imageInference";
+    ETaskType["IMAGE_UPLOAD"] = "imageUpload";
+    ETaskType["IMAGE_UPSCALE"] = "imageUpscale";
+    ETaskType["IMAGE_BACKGROUND_REMOVAL"] = "imageBackgroundRemoval";
+    ETaskType["IMAGE_CAPTION"] = "imageCaption";
+    ETaskType["IMAGE_CONTROL_NET_PRE_PROCESS"] = "imageControlNetPreProcess";
+    ETaskType["PROMPT_ENHANCE"] = "promptEnhance";
+    ETaskType["AUTHENTICATION"] = "authentication";
+})(ETaskType || (exports.ETaskType = ETaskType = {}));
+var EControlMode;
+(function (EControlMode) {
+    EControlMode["BALANCED"] = "balanced";
+    EControlMode["PROMPT"] = "prompt";
+    EControlMode["CONTROL_NET"] = "controlnet";
+})(EControlMode || (exports.EControlMode = EControlMode = {}));
+var EPreProcessorGroup;
+(function (EPreProcessorGroup) {
+    EPreProcessorGroup["canny"] = "canny";
+    EPreProcessorGroup["depth"] = "depth";
+    EPreProcessorGroup["mlsd"] = "mlsd";
+    EPreProcessorGroup["normalbae"] = "normalbae";
+    EPreProcessorGroup["openpose"] = "openpose";
+    EPreProcessorGroup["tile"] = "tile";
+    EPreProcessorGroup["seg"] = "seg";
+    EPreProcessorGroup["lineart"] = "lineart";
+    EPreProcessorGroup["lineart_anime"] = "lineart_anime";
+    EPreProcessorGroup["shuffle"] = "shuffle";
+    EPreProcessorGroup["scribble"] = "scribble";
+    EPreProcessorGroup["softedge"] = "softedge";
+})(EPreProcessorGroup || (exports.EPreProcessorGroup = EPreProcessorGroup = {}));
+var EPreProcessor;
+(function (EPreProcessor) {
+    EPreProcessor["canny"] = "canny";
+    EPreProcessor["depth_leres"] = "depth_leres";
+    EPreProcessor["depth_midas"] = "depth_midas";
+    EPreProcessor["depth_zoe"] = "depth_zoe";
+    EPreProcessor["inpaint_global_harmonious"] = "inpaint_global_harmonious";
+    EPreProcessor["lineart_anime"] = "lineart_anime";
+    EPreProcessor["lineart_coarse"] = "lineart_coarse";
+    EPreProcessor["lineart_realistic"] = "lineart_realistic";
+    EPreProcessor["lineart_standard"] = "lineart_standard";
+    EPreProcessor["mlsd"] = "mlsd";
+    EPreProcessor["normal_bae"] = "normal_bae";
+    EPreProcessor["scribble_hed"] = "scribble_hed";
+    EPreProcessor["scribble_pidinet"] = "scribble_pidinet";
+    EPreProcessor["seg_ofade20k"] = "seg_ofade20k";
+    EPreProcessor["seg_ofcoco"] = "seg_ofcoco";
+    EPreProcessor["seg_ufade20k"] = "seg_ufade20k";
+    EPreProcessor["shuffle"] = "shuffle";
+    EPreProcessor["softedge_hed"] = "softedge_hed";
+    EPreProcessor["softedge_hedsafe"] = "softedge_hedsafe";
+    EPreProcessor["softedge_pidinet"] = "softedge_pidinet";
+    EPreProcessor["softedge_pidisafe"] = "softedge_pidisafe";
+    EPreProcessor["tile_gaussian"] = "tile_gaussian";
+    EPreProcessor["openpose"] = "openpose";
+    EPreProcessor["openpose_face"] = "openpose_face";
+    EPreProcessor["openpose_faceonly"] = "openpose_faceonly";
+    EPreProcessor["openpose_full"] = "openpose_full";
+    EPreProcessor["openpose_hand"] = "openpose_hand";
+})(EPreProcessor || (exports.EPreProcessor = EPreProcessor = {}));
+var EOpenPosePreProcessor;
+(function (EOpenPosePreProcessor) {
+    EOpenPosePreProcessor["openpose"] = "openpose";
+    EOpenPosePreProcessor["openpose_face"] = "openpose_face";
+    EOpenPosePreProcessor["openpose_faceonly"] = "openpose_faceonly";
+    EOpenPosePreProcessor["openpose_full"] = "openpose_full";
+    EOpenPosePreProcessor["openpose_hand"] = "openpose_hand";
+})(EOpenPosePreProcessor || (exports.EOpenPosePreProcessor = EOpenPosePreProcessor = {}));

package/dist/esm/Runware/utils.d.ts

@@ -0,0 +1,45 @@
+import { EPreProcessor, EPreProcessorGroup, GetWithPromiseCallBackType } from "./types";
+export declare const BASE_RUNWARE_URLS: {
+    PRODUCTION: string;
+    TEST: string;
+};
+export declare const removeFromAray: <T>(col: T[], targetElem: T) => void;
+export declare const getIntervalWithPromise: (callback: GetWithPromiseCallBackType, { debugKey, timeOutDuration, shouldThrowError, }: {
+    debugKey?: string | undefined;
+    timeOutDuration?: number | undefined;
+    shouldThrowError?: boolean | undefined;
+}) => Promise<unknown>;
+export declare const fileToBase64: (file: File) => Promise<unknown>;
+export declare const getUUID: () => string;
+export declare const isValidUUID: (uuid: string) => boolean;
+export declare const compact: (value: any, data: any) => any;
+export declare const getPreprocessorType: (processor: EPreProcessor) => EPreProcessorGroup;
+export declare const accessDeepObject: ({ key, data, useZero, shouldReturnString, }: {
+    key: string;
+    data: Record<string, any>;
+    useZero?: boolean | undefined;
+    shouldReturnString?: boolean | undefined;
+}) => Record<string, any>;
+export declare const delay: (time: number, milliseconds?: number) => Promise<unknown>;
+export declare class MockFile {
+    create: (name: string, size: number, mimeType: string) => any;
+}
+export declare const RETRY_SDK_COUNTS: {
+    GLOBAL: number;
+    REQUEST_IMAGES: number;
+};
+export declare const remove1Mutate: (col: any, targetElem: any) => void;
+export declare const removeListener: (listeners: any[], listener: any) => any[];
+export declare const removeAllKeyListener: ({ listeners, key, }: {
+    listeners: any[];
+    key: any;
+}) => any[];
+export declare enum LISTEN_TO_IMAGES_KEY {
+    REQUEST_IMAGES = "REQUEST_IMAGES"
+}
+export declare const evaluateNonTrue: ({ key, value, }: {
+    key: string;
+    value: any;
+}) => {
+    [x: string]: any;
+};

package/dist/esm/Runware/utils.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateNonTrue = exports.LISTEN_TO_IMAGES_KEY = exports.removeAllKeyListener = exports.removeListener = exports.remove1Mutate = exports.RETRY_SDK_COUNTS = exports.MockFile = exports.delay = exports.accessDeepObject = exports.getPreprocessorType = exports.compact = exports.isValidUUID = exports.getUUID = exports.fileToBase64 = exports.getIntervalWithPromise = exports.removeFromAray = exports.BASE_RUNWARE_URLS = void 0;
+const types_1 = require("./types");
+const uuid_1 = require("uuid");
+const TIMEOUT_DURATION = 60000; // 120S;
+const POLLING_INTERVAL = 100; // 1s;
+exports.BASE_RUNWARE_URLS = {
+    [types_1.Environment.PRODUCTION]: "wss://ws-api.runware.ai/v1",
+    [types_1.Environment.TEST]: "ws://localhost:8080",
+};
+const removeFromAray = (col, targetElem) => {
+    if (col == null) {
+        return;
+    }
+    let i = col.indexOf(targetElem);
+    if (i === -1) {
+        return;
+    }
+    col.splice(i, 1);
+};
+exports.removeFromAray = removeFromAray;
+const getIntervalWithPromise = (callback, { debugKey = "debugKey", timeOutDuration = TIMEOUT_DURATION, shouldThrowError = true, }) => {
+    return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            if (intervalId) {
+                clearInterval(intervalId);
+                if (shouldThrowError) {
+                    reject(`Message could not be received for ${debugKey}`);
+                    console.error("Message could not be received for ", debugKey);
+                }
+            }
+            clearTimeout(timeoutId);
+            // reject();
+        }, timeOutDuration);
+        let intervalId = setInterval(async () => {
+            const shouldClear = callback({ resolve, reject, intervalId });
+            if (shouldClear) {
+                clearInterval(intervalId);
+                clearTimeout(timeoutId);
+            }
+            // resolve(imagesWithSimilarTask); // Resolve the promise with the data
+        }, POLLING_INTERVAL); // Check every 1 second (adjust the interval as needed)
+    });
+};
+exports.getIntervalWithPromise = getIntervalWithPromise;
+const fileToBase64 = (file) => new Promise((resolve) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = function () {
+        resolve(reader.result);
+    };
+});
+exports.fileToBase64 = fileToBase64;
+// export const getUUID = () => crypto.randomUUID();
+const getUUID = () => (0, uuid_1.v4)();
+exports.getUUID = getUUID;
+const isValidUUID = (uuid) => (0, uuid_1.validate)(uuid);
+exports.isValidUUID = isValidUUID;
+const evaluateToBoolean = (...args) => [...args].every((e) => !!e);
+const compact = (value, data) => (!!value ? data : {});
+exports.compact = compact;
+const getPreprocessorType = (processor) => {
+    const processorGroup = Object.keys(types_1.EPreProcessorGroup);
+    switch (processor) {
+        case types_1.EPreProcessor.canny:
+            return types_1.EPreProcessorGroup.canny;
+        // break
+        case types_1.EPreProcessor.depth_leres:
+        case types_1.EPreProcessor.depth_midas:
+        case types_1.EPreProcessor.depth_zoe:
+            return types_1.EPreProcessorGroup.depth;
+        // break
+        case types_1.EPreProcessor.inpaint_global_harmonious:
+            return types_1.EPreProcessorGroup.depth;
+        // break
+        case types_1.EPreProcessor.lineart_anime:
+            return types_1.EPreProcessorGroup.lineart_anime;
+        // break
+        case types_1.EPreProcessor.lineart_coarse:
+        case types_1.EPreProcessor.lineart_realistic:
+        case types_1.EPreProcessor.lineart_standard:
+            return types_1.EPreProcessorGroup.lineart;
+        // break
+        case types_1.EPreProcessor.mlsd:
+            return types_1.EPreProcessorGroup.mlsd;
+        // break
+        case types_1.EPreProcessor.normal_bae:
+            return types_1.EPreProcessorGroup.normalbae;
+        // break
+        case types_1.EPreProcessor.openpose_face:
+        case types_1.EPreProcessor.openpose_faceonly:
+        case types_1.EPreProcessor.openpose_full:
+        case types_1.EPreProcessor.openpose_hand:
+        case types_1.EPreProcessor.openpose:
+            return types_1.EPreProcessorGroup.openpose;
+        // break
+        case types_1.EPreProcessor.scribble_hed:
+        case types_1.EPreProcessor.scribble_pidinet:
+            return types_1.EPreProcessorGroup.scribble;
+        // break
+        case types_1.EPreProcessor.seg_ofade20k:
+        case types_1.EPreProcessor.seg_ofcoco:
+        case types_1.EPreProcessor.seg_ufade20k:
+            return types_1.EPreProcessorGroup.seg;
+        // break
+        case types_1.EPreProcessor.shuffle:
+            return types_1.EPreProcessorGroup.shuffle;
+        // break
+        case types_1.EPreProcessor.softedge_hed:
+        case types_1.EPreProcessor.softedge_hedsafe:
+        case types_1.EPreProcessor.softedge_pidinet:
+        case types_1.EPreProcessor.softedge_pidisafe:
+            return types_1.EPreProcessorGroup.softedge;
+        // break
+        case types_1.EPreProcessor.tile_gaussian:
+            return types_1.EPreProcessorGroup.tile;
+        // break
+        default:
+            return types_1.EPreProcessorGroup.canny;
+    }
+};
+exports.getPreprocessorType = getPreprocessorType;
+const accessDeepObject = ({ key, data, useZero = true, shouldReturnString = false, }) => {
+    const splittedKeys = key.split(/\.|\[/).map((key) => key.replace(/\]$/, ""));
+    const value = splittedKeys.reduce((acc, curr) => {
+        var _a, _b;
+        const returnZero = useZero ? 0 : undefined;
+        const currentValue = acc === null || acc === void 0 ? void 0 : acc[curr];
+        if (!currentValue) {
+            return returnZero;
+        }
+        if (Array.isArray(currentValue) && /^\d+$/.test(curr)) {
+            const index = parseInt(curr, 10);
+            if (index >= 0 && index < currentValue.length) {
+                return (acc[curr] = currentValue[index]);
+            }
+            else {
+                return (_a = acc[curr]) !== null && _a !== void 0 ? _a : returnZero;
+            }
+        }
+        else {
+            return (_b = acc[curr]) !== null && _b !== void 0 ? _b : returnZero;
+        }
+    }, data || {});
+    // if (typeof value === "object" && shouldReturnString) {
+    //   return JSON.stringify(value);
+    // }
+    return value !== null && value !== void 0 ? value : {};
+};
+exports.accessDeepObject = accessDeepObject;
+const delay = (time, milliseconds = 1000) => {
+    return new Promise((resolve) => setTimeout(resolve, time * milliseconds));
+};
+exports.delay = delay;
+class MockFile {
+    constructor() {
+        this.create = function (name, size, mimeType) {
+            name = name || "mock.txt";
+            size = size || 1024;
+            mimeType = mimeType || "plain/txt";
+            var blob = new Blob([range(size)], { type: mimeType });
+            blob.lastModifiedDate = new Date();
+            blob.name = name;
+            return blob;
+        };
+    }
+}
+exports.MockFile = MockFile;
+function range(count) {
+    var output = "";
+    for (var i = 0; i < count; i++) {
+        output += "a";
+    }
+    return output;
+}
+exports.RETRY_SDK_COUNTS = {
+    GLOBAL: 2,
+    REQUEST_IMAGES: 2,
+};
+const remove1Mutate = (col, targetElem) => {
+    if (col == null) {
+        return;
+    }
+    let i = col.indexOf(targetElem);
+    if (i === -1) {
+        return;
+    }
+    col.splice(i, 1);
+};
+exports.remove1Mutate = remove1Mutate;
+const removeListener = (listeners, listener) => {
+    return listeners.filter((lis) => lis.key !== listener.key);
+};
+exports.removeListener = removeListener;
+const removeAllKeyListener = ({ listeners, key, }) => {
+    return listeners.filter((lis) => (lis === null || lis === void 0 ? void 0 : lis.key) !== key);
+};
+exports.removeAllKeyListener = removeAllKeyListener;
+var LISTEN_TO_IMAGES_KEY;
+(function (LISTEN_TO_IMAGES_KEY) {
+    LISTEN_TO_IMAGES_KEY["REQUEST_IMAGES"] = "REQUEST_IMAGES";
+})(LISTEN_TO_IMAGES_KEY || (exports.LISTEN_TO_IMAGES_KEY = LISTEN_TO_IMAGES_KEY = {}));
+const evaluateNonTrue = ({ key, value, }) => {
+    if (!!value || value === 0 || value === false) {
+        return { [key]: value };
+    }
+    else {
+        return {};
+    }
+};
+exports.evaluateNonTrue = evaluateNonTrue;

package/dist/esm/tests/Runware/enhance-prompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tests/Runware/enhance-prompt.test.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const test_utils_1 = require("../test-utils");
+const mockServer_1 = require("../mockServer");
+const Runware_1 = require("../../Runware");
+vitest_1.vi.mock("../../Runware/utils", async () => {
+    const actual = await vitest_1.vi.importActual("../../Runware/utils");
+    return Object.assign(Object.assign({}, actual), { fileToBase64: vitest_1.vi.fn().mockReturnValue("FILE_TO_BASE_64"), getIntervalWithPromise: vitest_1.vi.fn(), getUUID: vitest_1.vi.fn().mockImplementation(() => "UNIQUE_UID") });
+});
+(0, vitest_1.describe)("When user request to enhance prompt", async () => {
+    const { mockServer, runware } = await (0, mockServer_1.startMockServer)();
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.beforeEach)(() => {
+        mockServer.stop();
+    });
+    (0, vitest_1.beforeAll)(async () => {
+        vitest_1.vi.spyOn(runware, "uploadImage").mockReturnValue(test_utils_1.testExamples.imageUploadRes);
+    });
+    (0, vitest_1.test)("it should give an enhanced prompt", async () => {
+        const globalListenerSpy = vitest_1.vi.spyOn(runware, "globalListener");
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware.enhancePrompt({
+            prompt: "Mock prompt",
+            promptMaxLength: 200,
+            promptVersions: 4,
+        });
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith({
+            prompt: "Mock prompt",
+            taskUUID: test_utils_1.mockTaskUUID,
+            promptMaxLength: 200,
+            promptVersions: 4,
+            taskType: Runware_1.ETaskType.PROMPT_ENHANCE,
+        });
+        (0, vitest_1.expect)(globalListenerSpy).toHaveBeenCalledWith({
+            taskUUID: test_utils_1.mockTaskUUID,
+        });
+    });
+    (0, vitest_1.test)("it should give an enhanced prompt with default config", async () => {
+        const globalListenerSpy = vitest_1.vi.spyOn(runware, "globalListener");
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware.enhancePrompt({
+            prompt: "Mock prompt",
+        });
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith({
+            prompt: "Mock prompt",
+            taskUUID: test_utils_1.mockTaskUUID,
+            promptMaxLength: 380,
+            promptVersions: 1,
+            taskType: Runware_1.ETaskType.PROMPT_ENHANCE,
+        });
+        (0, vitest_1.expect)(globalListenerSpy).toHaveBeenCalledWith({
+            taskUUID: test_utils_1.mockTaskUUID,
+        });
+    });
+});

package/dist/esm/tests/Runware/remove-image-background.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tests/Runware/remove-image-background.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const test_utils_1 = require("../test-utils");
+const mockServer_1 = require("../mockServer");
+const Runware_1 = require("../../Runware");
+vitest_1.vi.mock("../../Runware/utils", async () => {
+    const actual = await vitest_1.vi.importActual("../../Runware/utils");
+    return Object.assign(Object.assign({}, actual), { fileToBase64: vitest_1.vi.fn().mockReturnValue("FILE_TO_BASE_64"), getIntervalWithPromise: vitest_1.vi.fn(), getUUID: vitest_1.vi.fn().mockImplementation(() => "UNIQUE_UID") });
+});
+(0, vitest_1.describe)("When user request to remove image background", async () => {
+    const { mockServer, runware } = await (0, mockServer_1.startMockServer)();
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.beforeEach)(() => {
+        mockServer.stop();
+    });
+    (0, vitest_1.beforeAll)(async () => {
+        vitest_1.vi.spyOn(runware, "uploadImage").mockReturnValue(test_utils_1.testExamples.imageUploadRes);
+    });
+    (0, vitest_1.test)("it should remove an image background", async () => {
+        const imageUploadSpy = vitest_1.vi.spyOn(runware, "uploadImage");
+        const globalListenerSpy = vitest_1.vi.spyOn(runware, "globalListener");
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware.removeImageBackground({ inputImage: test_utils_1.mockUploadFile });
+        (0, vitest_1.expect)(imageUploadSpy).toHaveBeenCalled();
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith({
+            inputImage: test_utils_1.testExamples.imageUploadRes.imageUUID,
+            taskUUID: test_utils_1.mockTaskUUID,
+            taskType: Runware_1.ETaskType.IMAGE_BACKGROUND_REMOVAL,
+        });
+        (0, vitest_1.expect)(globalListenerSpy).toHaveBeenCalledWith({
+            taskUUID: test_utils_1.mockTaskUUID,
+        });
+    });
+});

package/dist/esm/tests/Runware/request-image-to-text.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tests/Runware/request-image-to-text.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const test_utils_1 = require("../test-utils");
+const mockServer_1 = require("../mockServer");
+const Runware_1 = require("../../Runware");
+vitest_1.vi.mock("../../Runware/utils", async () => {
+    const actual = await vitest_1.vi.importActual("../../Runware/utils");
+    return Object.assign(Object.assign({}, actual), { fileToBase64: vitest_1.vi.fn().mockReturnValue("FILE_TO_BASE_64"), getIntervalWithPromise: vitest_1.vi.fn(), getUUID: vitest_1.vi.fn().mockImplementation(() => "UNIQUE_UID") });
+});
+(0, vitest_1.describe)("When user request image to text", async () => {
+    const { mockServer, runware } = await (0, mockServer_1.startMockServer)();
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.beforeEach)(() => {
+        mockServer.stop();
+    });
+    (0, vitest_1.beforeAll)(async () => {
+        vitest_1.vi.spyOn(runware, "uploadImage").mockReturnValue(test_utils_1.testExamples.imageUploadRes);
+    });
+    (0, vitest_1.test)("it should get a text conversion", async () => {
+        const imageUploadSpy = vitest_1.vi.spyOn(runware, "uploadImage");
+        const globalListenerSpy = vitest_1.vi.spyOn(runware, "globalListener");
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware.requestImageToText({ inputImage: test_utils_1.mockUploadFile });
+        (0, vitest_1.expect)(imageUploadSpy).toHaveBeenCalled();
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith({
+            inputImage: test_utils_1.testExamples.imageUploadRes.imageUUID,
+            taskUUID: test_utils_1.mockTaskUUID,
+            taskType: Runware_1.ETaskType.IMAGE_CAPTION,
+        });
+        (0, vitest_1.expect)(globalListenerSpy).toHaveBeenCalledWith({
+            taskUUID: test_utils_1.mockTaskUUID,
+        });
+    });
+});

package/dist/esm/tests/Runware/request-images.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tests/Runware/request-images.test.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const test_utils_1 = require("../test-utils");
+const mockServer_1 = require("../mockServer");
+const Runware_1 = require("../../Runware");
+vitest_1.vi.mock("../../Runware/utils", async () => {
+    const actual = await vitest_1.vi.importActual("../../Runware/utils");
+    return Object.assign(Object.assign({}, actual), { fileToBase64: vitest_1.vi.fn().mockReturnValue("FILE_TO_BASE_64"), getIntervalWithPromise: vitest_1.vi.fn(), getUUID: vitest_1.vi.fn().mockImplementation(() => "UNIQUE_UID") });
+});
+(0, vitest_1.describe)("When user request an image", async () => {
+    const { mockServer, runware } = await (0, mockServer_1.startMockServer)();
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.beforeEach)(() => {
+        mockServer.stop();
+    });
+    (0, vitest_1.beforeAll)(async () => {
+        vitest_1.vi.spyOn(runware, "uploadImage").mockReturnValue(test_utils_1.testExamples.imageUploadRes);
+    });
+    (0, vitest_1.test)("it should request image without an image initiator", async () => {
+        const imageUploadSpy = vitest_1.vi.spyOn(runware, "uploadImage");
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware.requestImages(test_utils_1.testExamples.imageReq);
+        (0, vitest_1.expect)(imageUploadSpy).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith(Object.assign({}, test_utils_1.testExamples.imageRes));
+    });
+    (0, vitest_1.test)("it should request image with an image initiator", async () => {
+        const imageUploadSpy = vitest_1.vi.spyOn(runware, "uploadImage");
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware.requestImages(Object.assign(Object.assign({}, test_utils_1.testExamples.imageReq), { seedImage: test_utils_1.mockTextImageUpload }));
+        (0, vitest_1.expect)(imageUploadSpy).toHaveBeenCalled();
+        (0, vitest_1.expect)(imageUploadSpy).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith(Object.assign(Object.assign({}, test_utils_1.testExamples.imageRes), { seedImage: test_utils_1.testExamples.imageUploadRes.imageUUID, taskType: Runware_1.ETaskType.IMAGE_INFERENCE }));
+    });
+    (0, vitest_1.test)("it should request image with an image initiator and image mask initiator", async () => {
+        const imageUploadSpy = vitest_1.vi.spyOn(runware, "uploadImage");
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware.requestImages(Object.assign(Object.assign({}, test_utils_1.testExamples.imageReq), { seedImage: test_utils_1.mockTextImageUpload, maskImage: test_utils_1.mockTextImageUpload }));
+        (0, vitest_1.expect)(imageUploadSpy).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith(Object.assign(Object.assign({}, test_utils_1.testExamples.imageRes), { seedImage: test_utils_1.testExamples.imageUploadRes.imageUUID, maskImage: test_utils_1.testExamples.imageUploadRes.imageUUID, taskType: Runware_1.ETaskType.IMAGE_INFERENCE }));
+    });
+    (0, vitest_1.test)("it should request image with an image initiator and image mask initiator and control net", async () => {
+        const imageUploadSpy = vitest_1.vi.spyOn(runware, "uploadImage");
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware.requestImages(Object.assign(Object.assign({}, test_utils_1.testExamples.imageReq), { seedImage: test_utils_1.mockTextImageUpload, maskImage: test_utils_1.mockTextImageUpload, controlNet: [Object.assign(Object.assign({}, test_utils_1.testExamples.controlNet), { model: "control_net_model" })] }));
+        (0, vitest_1.expect)(imageUploadSpy).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith(Object.assign(Object.assign({}, test_utils_1.testExamples.imageRes), { seedImage: test_utils_1.testExamples.imageUploadRes.imageUUID, maskImage: test_utils_1.testExamples.imageUploadRes.imageUUID, controlNet: [
+                {
+                    controlMode: Runware_1.EControlMode.CONTROL_NET,
+                    endStep: 20,
+                    guideImage: "NEW_IMAGE_UID",
+                    model: "control_net_model",
+                    startStep: 0,
+                    weight: 1,
+                },
+            ], taskType: Runware_1.ETaskType.IMAGE_INFERENCE }));
+    });
+    (0, vitest_1.test)("it should request multiple images in parallel", async () => {
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        const listenToImages = vitest_1.vi.spyOn(runware, "listenToImages");
+        await Promise.all([
+            runware.requestImages(Object.assign({}, test_utils_1.testExamples.imageReq)),
+            runware.requestImages(Object.assign(Object.assign({}, test_utils_1.testExamples.imageReq), { positivePrompt: "cat" })),
+        ]);
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith(Object.assign(Object.assign({}, test_utils_1.testExamples.imageRes), { taskType: Runware_1.ETaskType.IMAGE_INFERENCE }));
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith(Object.assign(Object.assign({}, test_utils_1.testExamples.imageRes), { positivePrompt: "cat", taskType: Runware_1.ETaskType.IMAGE_INFERENCE }));
+        (0, vitest_1.expect)(listenToImages).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/esm/tests/Runware/runware-server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tests/Runware/runware-server.test.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const mockServer_1 = require("../mockServer");
+const Runware_1 = require("../../Runware");
+const utils_1 = require("../../Runware/utils");
+const PORT = 8080;
+(0, vitest_1.describe)("When using backend mockServer", async () => {
+    const { mockServer } = await (0, mockServer_1.startMockBackendServer)();
+    (0, vitest_1.beforeAll)(async () => { });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.beforeAll)(async () => { });
+    (0, vitest_1.test)("it should instantiate server correctly", async () => {
+        vitest_1.vi.spyOn(Runware_1.RunwareServer.prototype, "addListener").mockImplementation(() => "afa");
+        vitest_1.vi.spyOn(Runware_1.RunwareServer.prototype, "connect");
+        const runwareServer = new Runware_1.RunwareServer({
+            apiKey: "API_KEY",
+            url: utils_1.BASE_RUNWARE_URLS.TEST,
+        });
+        (0, vitest_1.expect)(runwareServer._apiKey).toBe("API_KEY");
+        (0, vitest_1.expect)(runwareServer.connect).toBeCalledTimes(1);
+        (0, vitest_1.expect)(runwareServer._ws).toBeDefined();
+    });
+});

package/dist/esm/tests/Runware/upload-image.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tests/Runware/upload-image.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const utils_1 = require("../../Runware/utils");
+const test_utils_1 = require("../test-utils");
+const mockServer_1 = require("../mockServer");
+const Runware_1 = require("../../Runware");
+vitest_1.vi.mock("../../Runware/utils", async () => {
+    const actual = await vitest_1.vi.importActual("../../Runware/utils");
+    return Object.assign(Object.assign({}, actual), { fileToBase64: vitest_1.vi.fn().mockReturnValue("FILE_TO_BASE_64"), getIntervalWithPromise: vitest_1.vi.fn(), getUUID: vitest_1.vi.fn().mockReturnValue("UNIQUE_UID") });
+});
+(0, vitest_1.describe)("When user uploads an image:", async () => {
+    const { mockServer, runware } = await (0, mockServer_1.startMockServer)();
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.beforeEach)(() => {
+        mockServer.stop();
+    });
+    (0, vitest_1.test)("it should accept string during image upload", async () => {
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware["uploadImage"]("IMAGE_UPLOAD");
+        (0, vitest_1.expect)(utils_1.fileToBase64).to.not.toHaveBeenCalled();
+        (0, vitest_1.expect)(sendSpy).toBeCalledTimes(1);
+    });
+    (0, vitest_1.test)("it should accept file during image upload", async () => {
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        await runware["uploadImage"](test_utils_1.mockUploadFile);
+        (0, vitest_1.expect)(utils_1.fileToBase64).toHaveBeenCalled();
+        (0, vitest_1.expect)(sendSpy).toBeCalledTimes(1);
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith({
+            image: test_utils_1.mockFileToBase64,
+            taskUUID: test_utils_1.mockTaskUUID,
+            taskType: Runware_1.ETaskType.IMAGE_UPLOAD,
+        });
+    });
+    (0, vitest_1.test)("it should upload image successfully", async () => {
+        const sendSpy = vitest_1.vi.spyOn(runware, "send");
+        const globalListenerSpy = vitest_1.vi.spyOn(runware, "globalListener");
+        await runware["uploadImage"](test_utils_1.mockTextImageUpload);
+        (0, vitest_1.expect)(utils_1.fileToBase64).to.not.toHaveBeenCalled();
+        (0, vitest_1.expect)(sendSpy).toHaveBeenCalledWith({
+            image: test_utils_1.mockTextImageUpload,
+            taskUUID: test_utils_1.mockTaskUUID,
+            taskType: Runware_1.ETaskType.IMAGE_UPLOAD,
+        });
+        (0, vitest_1.expect)(globalListenerSpy).toHaveBeenCalledWith({
+            taskUUID: test_utils_1.mockTaskUUID,
+        });
+        (0, vitest_1.expect)(utils_1.getIntervalWithPromise).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/esm/tests/Runware/upscale-gan.test.d.ts

@@ -0,0 +1 @@
+export {};