react-native-executorch/lib/controllers/OCRController.js

An easy way to run AI models in React Native with ExecuTorch

import { symbols } from '../constants/ocr/symbols';
import { ETError, getError } from '../Error';
import { OCRNativeModule } from '../native/RnExecutorchModules';
import { ResourceFetcher } from '../utils/ResourceFetcher';
export class OCRController {
    nativeModule;
    isReady = false;
    isGenerating = false;
    error = null;
    modelDownloadProgressCallback;
    isReadyCallback;
    isGeneratingCallback;
    errorCallback;
    constructor({ modelDownloadProgressCallback = (_downloadProgress) => { }, isReadyCallback = (_isReady) => { }, isGeneratingCallback = (_isGenerating) => { }, errorCallback = (_error) => { }, }) {
        this.nativeModule = OCRNativeModule;
        this.modelDownloadProgressCallback = modelDownloadProgressCallback;
        this.isReadyCallback = isReadyCallback;
        this.isGeneratingCallback = isGeneratingCallback;
        this.errorCallback = errorCallback;
    }
    loadModel = async (detectorSource, recognizerSources, language) => {
        try {
            if (!detectorSource || Object.keys(recognizerSources).length !== 3)
                return;
            if (!symbols[language]) {
                throw new Error(getError(ETError.LanguageNotSupported));
            }
            this.isReady = false;
            this.isReadyCallback(false);
            const paths = await ResourceFetcher.fetch(this.modelDownloadProgressCallback, detectorSource, recognizerSources.recognizerLarge, recognizerSources.recognizerMedium, recognizerSources.recognizerSmall);
            if (paths === null || paths?.length < 4) {
                throw new Error('Download interrupted!');
            }
            await this.nativeModule.loadModule(paths[0], paths[1], paths[2], paths[3], symbols[language]);
            this.isReady = true;
            this.isReadyCallback(this.isReady);
        }
        catch (e) {
            if (this.errorCallback) {
                this.errorCallback(getError(e));
            }
            else {
                throw new Error(getError(e));
            }
        }
    };
    forward = async (input) => {
        if (!this.isReady) {
            throw new Error(getError(ETError.ModuleNotLoaded));
        }
        if (this.isGenerating) {
            throw new Error(getError(ETError.ModelGenerating));
        }
        try {
            this.isGenerating = true;
            this.isGeneratingCallback(this.isGenerating);
            return await this.nativeModule.forward(input);
        }
        catch (e) {
            throw new Error(getError(e));
        }
        finally {
            this.isGenerating = false;
            this.isGeneratingCallback(this.isGenerating);
        }
    };
}