react-native-executorch 0.5.1 → 0.5.3

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']>;
+}

package/lib/modules/natural_language_processing/SpeechToTextModule.js

@@ -0,0 +1,36 @@
+import { SpeechToTextController } from '../../controllers/SpeechToTextController';
+export class SpeechToTextModule {
+    module;
+    constructor({ transcribeCallback, overlapSeconds, windowSize, streamingConfig, } = {}) {
+        this.module = new SpeechToTextController({
+            transcribeCallback: transcribeCallback || (() => { }),
+            overlapSeconds,
+            windowSize,
+            streamingConfig,
+        });
+    }
+    async load(model, onDownloadProgressCallback = () => { }) {
+        await this.module.load({
+            modelName: model.modelName,
+            encoderSource: model.encoderSource,
+            decoderSource: model.decoderSource,
+            tokenizerSource: model.tokenizerSource,
+            onDownloadProgressCallback,
+        });
+    }
+    configureStreaming(overlapSeconds, windowSize, streamingConfig) {
+        this.module.configureStreaming(overlapSeconds, windowSize, streamingConfig);
+    }
+    async encode(waveform) {
+        return await this.module.encode(waveform);
+    }
+    async decode(seq) {
+        return await this.module.decode(seq);
+    }
+    async transcribe(waveform, audioLanguage) {
+        return await this.module.transcribe(waveform, audioLanguage);
+    }
+    async streamingTranscribe(streamAction, waveform, audioLanguage) {
+        return await this.module.streamingTranscribe(streamAction, waveform, audioLanguage);
+    }
+}

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

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

package/lib/modules/natural_language_processing/TextEmbeddingsModule.js

@@ -0,0 +1,21 @@
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+import { BaseNonStaticModule } from '../BaseNonStaticModule';
+export class TextEmbeddingsModule extends BaseNonStaticModule {
+    async load(model, onDownloadProgressCallback = () => { }) {
+        const modelPromise = ResourceFetcher.fetch(onDownloadProgressCallback, model.modelSource);
+        const tokenizerPromise = ResourceFetcher.fetch(undefined, model.tokenizerSource);
+        const [modelResult, tokenizerResult] = await Promise.all([
+            modelPromise,
+            tokenizerPromise,
+        ]);
+        const modelPath = modelResult?.[0];
+        const tokenizerPath = tokenizerResult?.[0];
+        if (!modelPath || !tokenizerPath) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadTextEmbeddings(modelPath, tokenizerPath);
+    }
+    async forward(input) {
+        return new Float32Array(await this.nativeModule.generate(input));
+    }
+}

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

@@ -0,0 +1,12 @@
+import { ResourceSource } from '../../types/common';
+export declare class TokenizerModule {
+    nativeModule: any;
+    load(tokenizer: {
+        tokenizerSource: ResourceSource;
+    }, onDownloadProgressCallback?: (progress: number) => void): Promise<void>;
+    encode(s: string): Promise<any>;
+    decode(tokens: number[], skipSpecialTokens?: boolean): Promise<any>;
+    getVocabSize(): Promise<number>;
+    idToToken(tokenId: number): Promise<string>;
+    tokenToId(token: string): Promise<number>;
+}

package/lib/modules/natural_language_processing/TokenizerModule.js

@@ -0,0 +1,30 @@
+import { ResourceFetcher } from '../../utils/ResourceFetcher';
+export class TokenizerModule {
+    nativeModule;
+    async load(tokenizer, onDownloadProgressCallback = () => { }) {
+        const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, tokenizer.tokenizerSource);
+        const path = paths?.[0];
+        if (!path) {
+            throw new Error('Download interrupted.');
+        }
+        this.nativeModule = global.loadTokenizerModule(path);
+    }
+    async encode(s) {
+        return await this.nativeModule.encode(s);
+    }
+    async decode(tokens, skipSpecialTokens = true) {
+        if (tokens.length === 0) {
+            return '';
+        }
+        return await this.nativeModule.decode(tokens, skipSpecialTokens);
+    }
+    async getVocabSize() {
+        return await this.nativeModule.getVocabSize();
+    }
+    async idToToken(tokenId) {
+        return this.nativeModule.idToToken(tokenId);
+    }
+    async tokenToId(token) {
+        return await this.nativeModule.tokenToId(token);
+    }
+}

package/lib/native/NativeETInstaller.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('ETInstaller');

package/lib/native/NativeOCR.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('OCR');

package/lib/native/NativeVerticalOCR.js

@@ -0,0 +1,2 @@
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.get('VerticalOCR');

package/lib/native/RnExecutorchModules.d.ts

@@ -0,0 +1,7 @@
+import { Spec as OCRInterface } from './NativeOCR';
+import { Spec as VerticalOCRInterface } from './NativeVerticalOCR';
+import { Spec as ETInstallerInterface } from './NativeETInstaller';
+declare const OCRNativeModule: OCRInterface;
+declare const VerticalOCRNativeModule: VerticalOCRInterface;
+declare const ETInstallerNativeModule: ETInstallerInterface;
+export { OCRNativeModule, VerticalOCRNativeModule, ETInstallerNativeModule };

package/lib/native/RnExecutorchModules.js

@@ -0,0 +1,18 @@
+import { Platform } from 'react-native';
+const LINKING_ERROR = `The package 'react-native-executorch' doesn't seem to be linked. Make sure: \n\n` +
+    Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo Go\n';
+function returnSpecOrThrowLinkingError(spec) {
+    return spec
+        ? spec
+        : new Proxy({}, {
+            get() {
+                throw new Error(LINKING_ERROR);
+            },
+        });
+}
+const OCRNativeModule = returnSpecOrThrowLinkingError(require('./NativeOCR').default);
+const VerticalOCRNativeModule = returnSpecOrThrowLinkingError(require('./NativeVerticalOCR').default);
+const ETInstallerNativeModule = returnSpecOrThrowLinkingError(require('./NativeETInstaller').default);
+export { OCRNativeModule, VerticalOCRNativeModule, ETInstallerNativeModule };