react-native-executorch 0.5.7 → 0.5.8

package/lib/hooks/useModule.js

@@ -0,0 +1,45 @@
+import { useEffect, useState } from 'react';
+import { ETError, getError } from '../Error';
+export const useModule = ({ module, loadArgs, preventLoad = false, }) => {
+    const [error, setError] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    useEffect(() => {
+        const loadModule = async () => {
+            try {
+                setIsReady(false);
+                module.onDownloadProgress(setDownloadProgress);
+                await module.load(...loadArgs);
+                setIsReady(true);
+            }
+            catch (err) {
+                setError(err.message);
+            }
+        };
+        if (!preventLoad) {
+            loadModule();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [...loadArgs, preventLoad]);
+    const forward = async (...input) => {
+        if (!isReady)
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        if (isGenerating)
+            throw new Error(getError(ETError.ModelGenerating));
+        try {
+            setIsGenerating(true);
+            return await module.forward(...input);
+        }
+        finally {
+            setIsGenerating(false);
+        }
+    };
+    return {
+        error,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        forward,
+    };
+};

package/lib/hooks/useNonStaticModule.d.ts

@@ -0,0 +1,20 @@
+interface Module {
+    load: (...args: any[]) => Promise<void>;
+    forward: (...args: any[]) => Promise<any>;
+    delete: () => void;
+}
+interface ModuleConstructor<M extends Module> {
+    new (): M;
+}
+export declare const useNonStaticModule: <M extends Module, LoadArgs extends Parameters<M["load"]>, ForwardArgs extends Parameters<M["forward"]>, ForwardReturn extends Awaited<ReturnType<M["forward"]>>>({ module, model, preventLoad, }: {
+    module: ModuleConstructor<M>;
+    model: LoadArgs[0];
+    preventLoad?: boolean;
+}) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (...input: ForwardArgs) => Promise<ForwardReturn>;
+};
+export {};

package/lib/hooks/useNonStaticModule.js

@@ -0,0 +1,49 @@
+import { useEffect, useState, useMemo } from 'react';
+import { ETError, getError } from '../Error';
+export const useNonStaticModule = ({ module, model, preventLoad = false, }) => {
+    const [error, setError] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const moduleInstance = useMemo(() => new module(), [module]);
+    useEffect(() => {
+        if (preventLoad)
+            return;
+        (async () => {
+            setDownloadProgress(0);
+            setError(null);
+            try {
+                setIsReady(false);
+                await moduleInstance.load(model, setDownloadProgress);
+                setIsReady(true);
+            }
+            catch (err) {
+                setError(err.message);
+            }
+        })();
+        return () => {
+            moduleInstance.delete();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [moduleInstance, ...Object.values(model), preventLoad]);
+    const forward = async (...input) => {
+        if (!isReady)
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        if (isGenerating)
+            throw new Error(getError(ETError.ModelGenerating));
+        try {
+            setIsGenerating(true);
+            return await moduleInstance.forward(...input);
+        }
+        finally {
+            setIsGenerating(false);
+        }
+    };
+    return {
+        error,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        forward,
+    };
+};

package/lib/index.d.ts

@@ -0,0 +1,48 @@
+import { SpeechToTextLanguage } from './types/stt';
+declare global {
+    var loadStyleTransfer: (source: string) => any;
+    var loadImageSegmentation: (source: string) => any;
+    var loadClassification: (source: string) => any;
+    var loadObjectDetection: (source: string) => any;
+    var loadExecutorchModule: (source: string) => any;
+    var loadTokenizerModule: (source: string) => any;
+    var loadImageEmbeddings: (source: string) => any;
+    var loadTextEmbeddings: (modelSource: string, tokenizerSource: string) => any;
+    var loadLLM: (modelSource: string, tokenizerSource: string) => any;
+    var loadSpeechToText: (encoderSource: string, decoderSource: string, modelName: string) => any;
+}
+export * from './hooks/computer_vision/useClassification';
+export * from './hooks/computer_vision/useObjectDetection';
+export * from './hooks/computer_vision/useStyleTransfer';
+export * from './hooks/computer_vision/useImageSegmentation';
+export * from './hooks/computer_vision/useOCR';
+export * from './hooks/computer_vision/useVerticalOCR';
+export * from './hooks/computer_vision/useImageEmbeddings';
+export * from './hooks/natural_language_processing/useLLM';
+export * from './hooks/natural_language_processing/useSpeechToText';
+export * from './hooks/natural_language_processing/useTextEmbeddings';
+export * from './hooks/natural_language_processing/useTokenizer';
+export * from './hooks/general/useExecutorchModule';
+export * from './modules/computer_vision/ClassificationModule';
+export * from './modules/computer_vision/ObjectDetectionModule';
+export * from './modules/computer_vision/StyleTransferModule';
+export * from './modules/computer_vision/ImageSegmentationModule';
+export * from './modules/computer_vision/OCRModule';
+export * from './modules/computer_vision/VerticalOCRModule';
+export * from './modules/general/ExecutorchModule';
+export * from './modules/computer_vision/ImageEmbeddingsModule';
+export * from './modules/natural_language_processing/LLMModule';
+export * from './modules/natural_language_processing/SpeechToTextModule';
+export * from './modules/natural_language_processing/TextEmbeddingsModule';
+export * from './modules/natural_language_processing/TokenizerModule';
+export * from './utils/ResourceFetcher';
+export * from './utils/llm';
+export * from './types/objectDetection';
+export * from './types/ocr';
+export * from './types/imageSegmentation';
+export * from './types/llm';
+export { SpeechToTextLanguage };
+export * from './constants/modelUrls';
+export * from './constants/ocr/models';
+export * from './constants/llmDefaults';
+export { STREAMING_ACTION, MODES, AvailableModels, } from './constants/sttDefaults';

package/lib/index.js

@@ -0,0 +1,58 @@
+import { SpeechToTextLanguage } from './types/stt';
+import { ETInstallerNativeModule } from './native/RnExecutorchModules';
+// eslint-disable no-var
+if (global.loadStyleTransfer == null ||
+    global.loadImageSegmentation == null ||
+    global.loadExecutorchModule == null ||
+    global.loadClassification == null ||
+    global.loadObjectDetection == null ||
+    global.loadTokenizerModule == null ||
+    global.loadTextEmbeddings == null ||
+    global.loadImageEmbeddings == null ||
+    global.loadLLM == null ||
+    global.loadSpeechToText == null) {
+    if (!ETInstallerNativeModule) {
+        throw new Error(`Failed to install react-native-executorch: The native module could not be found.`);
+    }
+    ETInstallerNativeModule.install();
+}
+// hooks
+export * from './hooks/computer_vision/useClassification';
+export * from './hooks/computer_vision/useObjectDetection';
+export * from './hooks/computer_vision/useStyleTransfer';
+export * from './hooks/computer_vision/useImageSegmentation';
+export * from './hooks/computer_vision/useOCR';
+export * from './hooks/computer_vision/useVerticalOCR';
+export * from './hooks/computer_vision/useImageEmbeddings';
+export * from './hooks/natural_language_processing/useLLM';
+export * from './hooks/natural_language_processing/useSpeechToText';
+export * from './hooks/natural_language_processing/useTextEmbeddings';
+export * from './hooks/natural_language_processing/useTokenizer';
+export * from './hooks/general/useExecutorchModule';
+// modules
+export * from './modules/computer_vision/ClassificationModule';
+export * from './modules/computer_vision/ObjectDetectionModule';
+export * from './modules/computer_vision/StyleTransferModule';
+export * from './modules/computer_vision/ImageSegmentationModule';
+export * from './modules/computer_vision/OCRModule';
+export * from './modules/computer_vision/VerticalOCRModule';
+export * from './modules/general/ExecutorchModule';
+export * from './modules/computer_vision/ImageEmbeddingsModule';
+export * from './modules/natural_language_processing/LLMModule';
+export * from './modules/natural_language_processing/SpeechToTextModule';
+export * from './modules/natural_language_processing/TextEmbeddingsModule';
+export * from './modules/natural_language_processing/TokenizerModule';
+// utils
+export * from './utils/ResourceFetcher';
+export * from './utils/llm';
+// types
+export * from './types/objectDetection';
+export * from './types/ocr';
+export * from './types/imageSegmentation';
+export * from './types/llm';
+export { SpeechToTextLanguage };
+// constants
+export * from './constants/modelUrls';
+export * from './constants/ocr/models';
+export * from './constants/llmDefaults';
+export { STREAMING_ACTION, MODES, AvailableModels, } from './constants/sttDefaults';

package/lib/module/modules/natural_language_processing/LLMModule.js

@@ -54,6 +54,9 @@ export class LLMModule {
   interrupt() {
     this.controller.interrupt();
   }
+  getGeneratedTokenCount() {
+    return this.controller.getGeneratedTokenCount();
+  }
   delete() {
     this.controller.delete();
   }

package/lib/module/modules/natural_language_processing/LLMModule.js.map

@@ -1 +1 @@
-{"version":3,"names":["LLMController","LLMModule","constructor","tokenCallback","responseCallback","messageHistoryCallback","controller","load","model","onDownloadProgressCallback","setTokenCallback","configure","chatConfig","toolsConfig","generationConfig","forward","input","response","generate","messages","tools","sendMessage","message","messageHistory","deleteMessage","index","interrupt","delete"],"sourceRoot":"../../../../src","sources":["modules/natural_language_processing/LLMModule.ts"],"mappings":";;AAAA,SAASA,aAAa,QAAQ,iCAAiC;AAU/D,OAAO,MAAMC,SAAS,CAAC;EAGrBC,WAAWA,CAAC;IACVC,aAAa;IACbC,gBAAgB;IAChBC;EAKF,CAAC,GAAG,CAAC,CAAC,EAAE;IACN,IAAI,CAACC,UAAU,GAAG,IAAIN,aAAa,CAAC;MAClCG,aAAa;MACbC,gBAAgB;MAChBC;IACF,CAAC,CAAC;EACJ;EAEA,MAAME,IAAIA,CACRC,KAIC,EACDC,0BAAsD,GAAGA,CAAA,KAAM,CAAC,CAAC,EACjE;IACA,MAAM,IAAI,CAACH,UAAU,CAACC,IAAI,CAAC;MACzB,GAAGC,KAAK;MACRC;IACF,CAAC,CAAC;EACJ;EAEAC,gBAAgBA,CAAC;IACfP;EAGF,CAAC,EAAE;IACD,IAAI,CAACG,UAAU,CAACI,gBAAgB,CAACP,aAAa,CAAC;EACjD;EAEAQ,SAASA,CAAC;IACRC,UAAU;IACVC,WAAW;IACXC;EAKF,CAAC,EAAE;IACD,IAAI,CAACR,UAAU,CAACK,SAAS,CAAC;MAAEC,UAAU;MAAEC,WAAW;MAAEC;IAAiB,CAAC,CAAC;EAC1E;EAEA,MAAMC,OAAOA,CAACC,KAAa,EAAmB;IAC5C,MAAM,IAAI,CAACV,UAAU,CAACS,OAAO,CAACC,KAAK,CAAC;IACpC,OAAO,IAAI,CAACV,UAAU,CAACW,QAAQ;EACjC;EAEA,MAAMC,QAAQA,CAACC,QAAmB,EAAEC,KAAiB,EAAmB;IACtE,MAAM,IAAI,CAACd,UAAU,CAACY,QAAQ,CAACC,QAAQ,EAAEC,KAAK,CAAC;IAC/C,OAAO,IAAI,CAACd,UAAU,CAACW,QAAQ;EACjC;EAEA,MAAMI,WAAWA,CAACC,OAAe,EAAsB;IACrD,MAAM,IAAI,CAAChB,UAAU,CAACe,WAAW,CAACC,OAAO,CAAC;IAC1C,OAAO,IAAI,CAAChB,UAAU,CAACiB,cAAc;EACvC;EAEAC,aAAaA,CAACC,KAAa,EAAa;IACtC,IAAI,CAACnB,UAAU,CAACkB,aAAa,CAACC,KAAK,CAAC;IACpC,OAAO,IAAI,CAACnB,UAAU,CAACiB,cAAc;EACvC;EAEAG,SAASA,CAAA,EAAG;IACV,IAAI,CAACpB,UAAU,CAACoB,SAAS,CAAC,CAAC;EAC7B;EAEAC,MAAMA,CAAA,EAAG;IACP,IAAI,CAACrB,UAAU,CAACqB,MAAM,CAAC,CAAC;EAC1B;AACF","ignoreList":[]}
+{"version":3,"names":["LLMController","LLMModule","constructor","tokenCallback","responseCallback","messageHistoryCallback","controller","load","model","onDownloadProgressCallback","setTokenCallback","configure","chatConfig","toolsConfig","generationConfig","forward","input","response","generate","messages","tools","sendMessage","message","messageHistory","deleteMessage","index","interrupt","getGeneratedTokenCount","delete"],"sourceRoot":"../../../../src","sources":["modules/natural_language_processing/LLMModule.ts"],"mappings":";;AAAA,SAASA,aAAa,QAAQ,iCAAiC;AAU/D,OAAO,MAAMC,SAAS,CAAC;EAGrBC,WAAWA,CAAC;IACVC,aAAa;IACbC,gBAAgB;IAChBC;EAKF,CAAC,GAAG,CAAC,CAAC,EAAE;IACN,IAAI,CAACC,UAAU,GAAG,IAAIN,aAAa,CAAC;MAClCG,aAAa;MACbC,gBAAgB;MAChBC;IACF,CAAC,CAAC;EACJ;EAEA,MAAME,IAAIA,CACRC,KAIC,EACDC,0BAAsD,GAAGA,CAAA,KAAM,CAAC,CAAC,EACjE;IACA,MAAM,IAAI,CAACH,UAAU,CAACC,IAAI,CAAC;MACzB,GAAGC,KAAK;MACRC;IACF,CAAC,CAAC;EACJ;EAEAC,gBAAgBA,CAAC;IACfP;EAGF,CAAC,EAAE;IACD,IAAI,CAACG,UAAU,CAACI,gBAAgB,CAACP,aAAa,CAAC;EACjD;EAEAQ,SAASA,CAAC;IACRC,UAAU;IACVC,WAAW;IACXC;EAKF,CAAC,EAAE;IACD,IAAI,CAACR,UAAU,CAACK,SAAS,CAAC;MAAEC,UAAU;MAAEC,WAAW;MAAEC;IAAiB,CAAC,CAAC;EAC1E;EAEA,MAAMC,OAAOA,CAACC,KAAa,EAAmB;IAC5C,MAAM,IAAI,CAACV,UAAU,CAACS,OAAO,CAACC,KAAK,CAAC;IACpC,OAAO,IAAI,CAACV,UAAU,CAACW,QAAQ;EACjC;EAEA,MAAMC,QAAQA,CAACC,QAAmB,EAAEC,KAAiB,EAAmB;IACtE,MAAM,IAAI,CAACd,UAAU,CAACY,QAAQ,CAACC,QAAQ,EAAEC,KAAK,CAAC;IAC/C,OAAO,IAAI,CAACd,UAAU,CAACW,QAAQ;EACjC;EAEA,MAAMI,WAAWA,CAACC,OAAe,EAAsB;IACrD,MAAM,IAAI,CAAChB,UAAU,CAACe,WAAW,CAACC,OAAO,CAAC;IAC1C,OAAO,IAAI,CAAChB,UAAU,CAACiB,cAAc;EACvC;EAEAC,aAAaA,CAACC,KAAa,EAAa;IACtC,IAAI,CAACnB,UAAU,CAACkB,aAAa,CAACC,KAAK,CAAC;IACpC,OAAO,IAAI,CAACnB,UAAU,CAACiB,cAAc;EACvC;EAEAG,SAASA,CAAA,EAAG;IACV,IAAI,CAACpB,UAAU,CAACoB,SAAS,CAAC,CAAC;EAC7B;EAEAC,sBAAsBA,CAAA,EAAG;IACvB,OAAO,IAAI,CAACrB,UAAU,CAACqB,sBAAsB,CAAC,CAAC;EACjD;EAEAC,MAAMA,CAAA,EAAG;IACP,IAAI,CAACtB,UAAU,CAACsB,MAAM,CAAC,CAAC;EAC1B;AACF","ignoreList":[]}

package/lib/modules/BaseModule.js

@@ -0,0 +1,25 @@
+import { ResourceFetcher } from '../utils/ResourceFetcher';
+import { getError } from '../Error';
+export class BaseModule {
+    static nativeModule;
+    static onDownloadProgressCallback = () => { };
+    static async load(sources, ...loadArgs // this can be used in derived classes to pass extra args to load method
+    ) {
+        try {
+            const paths = await ResourceFetcher.fetch(this.onDownloadProgressCallback, ...sources);
+            if (paths === null || paths.length < sources.length) {
+                throw new Error('Download interrupted.');
+            }
+            await this.nativeModule.loadModule(...paths, ...loadArgs);
+        }
+        catch (error) {
+            throw new Error(getError(error));
+        }
+    }
+    static async forward(..._args) {
+        throw new Error('forward method is not implemented in the BaseModule class. Please implement it in the derived class.');
+    }
+    static onDownloadProgress(callback) {
+        this.onDownloadProgressCallback = callback;
+    }
+}

package/lib/modules/BaseNonStaticModule.js

@@ -0,0 +1,14 @@
+export class BaseNonStaticModule {
+    nativeModule = null;
+    async forwardET(inputTensor) {
+        return await this.nativeModule.forward(inputTensor);
+    }
+    async getInputShape(methodName, index) {
+        return this.nativeModule.getInputShape(methodName, index);
+    }
+    delete() {
+        if (this.nativeModule !== null) {
+            this.nativeModule.unload();
+        }
+    }
+}

package/lib/modules/computer_vision/ClassificationModule.d.ts

@@ -0,0 +1,8 @@
+import { ResourceSource } from '../../types/common';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export declare class ClassificationModule extends BaseNonStaticModule {
+    load(model: {
+        modelSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    forward(imageSource: string): Promise<any>;
+}

package/lib/modules/computer_vision/ClassificationModule.js

@@ -0,0 +1,17 @@
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+import { ETError, getError } from '../../Error';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export class ClassificationModule extends BaseNonStaticModule {
+    async load(model, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, model.modelSource);
+        if (paths === null || paths.length < 1) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadClassification(paths[0] || '');
+    }
+    async forward(imageSource) {
+        if (this.nativeModule == null)
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        return await this.nativeModule.generate(imageSource);
+    }
+}

package/lib/modules/computer_vision/ImageEmbeddingsModule.d.ts

@@ -0,0 +1,8 @@
+import { ResourceSource } from '../../types/common';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export declare class ImageEmbeddingsModule extends BaseNonStaticModule {
+    load(model: {
+        modelSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    forward(imageSource: string): Promise<Float32Array>;
+}

package/lib/modules/computer_vision/ImageEmbeddingsModule.js

@@ -0,0 +1,17 @@
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+import { ETError, getError } from '../../Error';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export class ImageEmbeddingsModule extends BaseNonStaticModule {
+    async load(model, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, model.modelSource);
+        if (paths === null || paths.length < 1) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadImageEmbeddings(paths[0] || '');
+    }
+    async forward(imageSource) {
+        if (this.nativeModule == null)
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        return new Float32Array(await this.nativeModule.generate(imageSource));
+    }
+}

package/lib/modules/computer_vision/ImageSegmentationModule.d.ts

@@ -0,0 +1,11 @@
+import { ResourceSource } from '../../types/common';
+import { DeeplabLabel } from '../../types/imageSegmentation';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export declare class ImageSegmentationModule extends BaseNonStaticModule {
+    load(model: {
+        modelSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    forward(imageSource: string, classesOfInterest?: DeeplabLabel[], resize?: boolean): Promise<{
+        [key in DeeplabLabel]?: number[];
+    }>;
+}

package/lib/modules/computer_vision/ImageSegmentationModule.js

@@ -0,0 +1,27 @@
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+import { DeeplabLabel } from '../../types/imageSegmentation';
+import { ETError, getError } from '../../Error';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export class ImageSegmentationModule extends BaseNonStaticModule {
+    async load(model, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, model.modelSource);
+        if (paths === null || paths.length < 1) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadImageSegmentation(paths[0] || '');
+    }
+    async forward(imageSource, classesOfInterest, resize) {
+        if (this.nativeModule == null) {
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        }
+        const stringDict = await this.nativeModule.generate(imageSource, (classesOfInterest || []).map((label) => DeeplabLabel[label]), resize || false);
+        let enumDict = {};
+        for (const key in stringDict) {
+            if (key in DeeplabLabel) {
+                const enumKey = DeeplabLabel[key];
+                enumDict[enumKey] = stringDict[key];
+            }
+        }
+        return enumDict;
+    }
+}

package/lib/modules/computer_vision/OCRModule.d.ts

@@ -0,0 +1,14 @@
+import { OCRController } from '../../controllers/OCRController';
+import { ResourceSource } from '../../types/common';
+import { OCRLanguage } from '../../types/ocr';
+export declare class OCRModule {
+    static module: OCRController;
+    static load(model: {
+        detectorSource: ResourceSource;
+        recognizerLarge: ResourceSource;
+        recognizerMedium: ResourceSource;
+        recognizerSmall: ResourceSource;
+        language: OCRLanguage;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    static forward(input: string): Promise<import("../../types/ocr").OCRDetection[]>;
+}

package/lib/modules/computer_vision/OCRModule.js

@@ -0,0 +1,17 @@
+import { OCRController } from '../../controllers/OCRController';
+export class OCRModule {
+    static module;
+    static async load(model, onDownloadProgressCallback = () => { }) {
+        this.module = new OCRController({
+            modelDownloadProgressCallback: onDownloadProgressCallback,
+        });
+        await this.module.loadModel(model.detectorSource, {
+            recognizerLarge: model.recognizerLarge,
+            recognizerMedium: model.recognizerMedium,
+            recognizerSmall: model.recognizerSmall,
+        }, model.language);
+    }
+    static async forward(input) {
+        return await this.module.forward(input);
+    }
+}

package/lib/modules/computer_vision/ObjectDetectionModule.d.ts

@@ -0,0 +1,9 @@
+import { ResourceSource } from '../../types/common';
+import { Detection } from '../../types/objectDetection';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export declare class ObjectDetectionModule extends BaseNonStaticModule {
+    load(model: {
+        modelSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    forward(imageSource: string, detectionThreshold?: number): Promise<Detection[]>;
+}

package/lib/modules/computer_vision/ObjectDetectionModule.js

@@ -0,0 +1,17 @@
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+import { ETError, getError } from '../../Error';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export class ObjectDetectionModule extends BaseNonStaticModule {
+    async load(model, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, model.modelSource);
+        if (paths === null || paths.length < 1) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadObjectDetection(paths[0] || '');
+    }
+    async forward(imageSource, detectionThreshold = 0.7) {
+        if (this.nativeModule == null)
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        return await this.nativeModule.generate(imageSource, detectionThreshold);
+    }
+}

package/lib/modules/computer_vision/StyleTransferModule.d.ts

@@ -0,0 +1,8 @@
+import { ResourceSource } from '../../types/common';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export declare class StyleTransferModule extends BaseNonStaticModule {
+    load(model: {
+        modelSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    forward(imageSource: string): Promise<string>;
+}

package/lib/modules/computer_vision/StyleTransferModule.js

@@ -0,0 +1,17 @@
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+import { ETError, getError } from '../../Error';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export class StyleTransferModule extends BaseNonStaticModule {
+    async load(model, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, model.modelSource);
+        if (paths === null || paths.length < 1) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadStyleTransfer(paths[0] || '');
+    }
+    async forward(imageSource) {
+        if (this.nativeModule == null)
+            throw new Error(getError(ETError.ModuleNotLoaded));
+        return await this.nativeModule.generate(imageSource);
+    }
+}

package/lib/modules/computer_vision/VerticalOCRModule.d.ts

@@ -0,0 +1,14 @@
+import { VerticalOCRController } from '../../controllers/VerticalOCRController';
+import { ResourceSource } from '../../types/common';
+import { OCRLanguage } from '../../types/ocr';
+export declare class VerticalOCRModule {
+    static module: VerticalOCRController;
+    static load(model: {
+        detectorLarge: ResourceSource;
+        detectorNarrow: ResourceSource;
+        recognizerLarge: ResourceSource;
+        recognizerSmall: ResourceSource;
+        language: OCRLanguage;
+    }, independentCharacters: boolean, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    static forward(input: string): Promise<import("../../types/ocr").OCRDetection[]>;
+}

package/lib/modules/computer_vision/VerticalOCRModule.js

@@ -0,0 +1,19 @@
+import { VerticalOCRController } from '../../controllers/VerticalOCRController';
+export class VerticalOCRModule {
+    static module;
+    static async load(model, independentCharacters, onDownloadProgressCallback = () => { }) {
+        this.module = new VerticalOCRController({
+            modelDownloadProgressCallback: onDownloadProgressCallback,
+        });
+        await this.module.loadModel({
+            detectorLarge: model.detectorLarge,
+            detectorNarrow: model.detectorNarrow,
+        }, {
+            recognizerLarge: model.recognizerLarge,
+            recognizerSmall: model.recognizerSmall,
+        }, model.language, independentCharacters);
+    }
+    static async forward(input) {
+        return await this.module.forward(input);
+    }
+}

package/lib/modules/general/ExecutorchModule.d.ts

@@ -0,0 +1,7 @@
+import { TensorPtr } from '../../types/common';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+import { ResourceSource } from '../../types/common';
+export declare class ExecutorchModule extends BaseNonStaticModule {
+    load(modelSource: ResourceSource, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    forward(inputTensor: TensorPtr[]): Promise<TensorPtr[]>;
+}

package/lib/modules/general/ExecutorchModule.js

@@ -0,0 +1,14 @@
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+export class ExecutorchModule extends BaseNonStaticModule {
+    async load(modelSource, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, modelSource);
+        if (paths === null || paths.length < 1) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadExecutorchModule(paths[0] || '');
+    }
+    async forward(inputTensor) {
+        return await this.forwardET(inputTensor);
+    }
+}

package/lib/modules/natural_language_processing/LLMModule.d.ts

@@ -0,0 +1,28 @@
+import { ResourceSource } from '../../types/common';
+import { ChatConfig, LLMTool, Message, ToolsConfig } from '../../types/llm';
+export declare class LLMModule {
+    private controller;
+    constructor({ tokenCallback, responseCallback, messageHistoryCallback, }?: {
+        tokenCallback?: (token: string) => void;
+        responseCallback?: (response: string) => void;
+        messageHistoryCallback?: (messageHistory: Message[]) => void;
+    });
+    load(model: {
+        modelSource: ResourceSource;
+        tokenizerSource: ResourceSource;
+        tokenizerConfigSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    setTokenCallback({ tokenCallback, }: {
+        tokenCallback: (token: string) => void;
+    }): void;
+    configure({ chatConfig, toolsConfig, }: {
+        chatConfig?: Partial<ChatConfig>;
+        toolsConfig?: ToolsConfig;
+    }): void;
+    forward(input: string): Promise<string>;
+    generate(messages: Message[], tools?: LLMTool[]): Promise<string>;
+    sendMessage(message: string): Promise<Message[]>;
+    deleteMessage(index: number): Message[];
+    interrupt(): void;
+    delete(): void;
+}

package/lib/modules/natural_language_processing/LLMModule.js

@@ -0,0 +1,45 @@
+import { LLMController } from '../../controllers/LLMController';
+export class LLMModule {
+    controller;
+    constructor({ tokenCallback, responseCallback, messageHistoryCallback, } = {}) {
+        this.controller = new LLMController({
+            tokenCallback,
+            responseCallback,
+            messageHistoryCallback,
+        });
+    }
+    async load(model, onDownloadProgressCallback = () => { }) {
+        await this.controller.load({
+            ...model,
+            onDownloadProgressCallback,
+        });
+    }
+    setTokenCallback({ tokenCallback, }) {
+        this.controller.setTokenCallback(tokenCallback);
+    }
+    configure({ chatConfig, toolsConfig, }) {
+        this.controller.configure({ chatConfig, toolsConfig });
+    }
+    async forward(input) {
+        await this.controller.forward(input);
+        return this.controller.response;
+    }
+    async generate(messages, tools) {
+        await this.controller.generate(messages, tools);
+        return this.controller.response;
+    }
+    async sendMessage(message) {
+        await this.controller.sendMessage(message);
+        return this.controller.messageHistory;
+    }
+    deleteMessage(index) {
+        this.controller.deleteMessage(index);
+        return this.controller.messageHistory;
+    }
+    interrupt() {
+        this.controller.interrupt();
+    }
+    delete() {
+        this.controller.delete();
+    }
+}

package/lib/modules/natural_language_processing/SpeechToTextModule.d.ts

@@ -0,0 +1,24 @@
+import { ResourceSource } from '../../types/common';
+import { SpeechToTextController } from '../../controllers/SpeechToTextController';
+import { AvailableModels, SpeechToTextLanguage } from '../../types/stt';
+import { STREAMING_ACTION } from '../../constants/sttDefaults';
+export declare class SpeechToTextModule {
+    private module;
+    constructor({ transcribeCallback, overlapSeconds, windowSize, streamingConfig, }?: {
+        transcribeCallback?: (sequence: string) => void;
+        overlapSeconds?: ConstructorParameters<typeof SpeechToTextController>['0']['overlapSeconds'];
+        windowSize?: ConstructorParameters<typeof SpeechToTextController>['0']['windowSize'];
+        streamingConfig?: ConstructorParameters<typeof SpeechToTextController>['0']['streamingConfig'];
+    });
+    load(model: {
+        modelName: AvailableModels;
+        encoderSource?: ResourceSource;
+        decoderSource?: ResourceSource;
+        tokenizerSource?: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    configureStreaming(overlapSeconds: Parameters<SpeechToTextController['configureStreaming']>[0], windowSize: Parameters<SpeechToTextController['configureStreaming']>[1], streamingConfig: Parameters<SpeechToTextController['configureStreaming']>[2]): void;
+    encode(waveform: Float32Array): Promise<null>;
+    decode(seq: number[]): Promise<number>;
+    transcribe(waveform: number[], audioLanguage?: SpeechToTextLanguage): ReturnType<SpeechToTextController['transcribe']>;
+    streamingTranscribe(streamAction: STREAMING_ACTION, waveform?: number[], audioLanguage?: SpeechToTextLanguage): ReturnType<SpeechToTextController['streamingTranscribe']>;
+}