react-native-executorch 0.5.1-rc.0 → 0.5.2

package/lib/controllers/OCRController.d.ts

@@ -0,0 +1,23 @@
+import { ResourceSource } from '../types/common';
+import { OCRLanguage } from '../types/ocr';
+export declare class OCRController {
+    private nativeModule;
+    isReady: boolean;
+    isGenerating: boolean;
+    error: string | null;
+    private isReadyCallback;
+    private isGeneratingCallback;
+    private errorCallback;
+    constructor({ isReadyCallback, isGeneratingCallback, errorCallback, }?: {
+        isReadyCallback?: ((_isReady: boolean) => void) | undefined;
+        isGeneratingCallback?: ((_isGenerating: boolean) => void) | undefined;
+        errorCallback?: ((_error: string) => void) | undefined;
+    });
+    load: (detectorSource: ResourceSource, recognizerSources: {
+        recognizerLarge: ResourceSource;
+        recognizerMedium: ResourceSource;
+        recognizerSmall: ResourceSource;
+    }, language: OCRLanguage, onDownloadProgressCallback?: (downloadProgress: number) => void) => Promise<void>;
+    forward: (input: string) => Promise<any>;
+    delete(): void;
+}

package/lib/controllers/OCRController.js

@@ -6,17 +6,15 @@ export class OCRController {
     isReady = false;
     isGenerating = false;
     error = null;
-    modelDownloadProgressCallback;
     isReadyCallback;
     isGeneratingCallback;
     errorCallback;
-    constructor({ modelDownloadProgressCallback = (_downloadProgress) => { }, isReadyCallback = (_isReady) => { }, isGeneratingCallback = (_isGenerating) => { }, errorCallback = (_error) => { }, }) {
-        this.modelDownloadProgressCallback = modelDownloadProgressCallback;
+    constructor({ isReadyCallback = (_isReady) => { }, isGeneratingCallback = (_isGenerating) => { }, errorCallback = (_error) => { }, } = {}) {
         this.isReadyCallback = isReadyCallback;
         this.isGeneratingCallback = isGeneratingCallback;
         this.errorCallback = errorCallback;
     }
-    load = async (detectorSource, recognizerSources, language) => {
+    load = async (detectorSource, recognizerSources, language, onDownloadProgressCallback) => {
         try {
             if (!detectorSource || Object.keys(recognizerSources).length !== 3)
                 return;
@@ -25,7 +23,7 @@ export class OCRController {
             }
             this.isReady = false;
             this.isReadyCallback(false);
-            const paths = await ResourceFetcher.fetch(this.modelDownloadProgressCallback, detectorSource, recognizerSources.recognizerLarge, recognizerSources.recognizerMedium, recognizerSources.recognizerSmall);
+            const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, detectorSource, recognizerSources.recognizerLarge, recognizerSources.recognizerMedium, recognizerSources.recognizerSmall);
             if (paths === null || paths?.length < 4) {
                 throw new Error('Download interrupted!');
             }
@@ -62,4 +60,13 @@ export class OCRController {
             this.isGeneratingCallback(this.isGenerating);
         }
     };
+    delete() {
+        if (this.isGenerating) {
+            throw new Error(getError(ETError.ModelGenerating) +
+                'You cannot delete the model. You must wait until the generating is finished.');
+        }
+        this.nativeModule.unload();
+        this.isReadyCallback(false);
+        this.isGeneratingCallback(false);
+    }
 }

package/lib/controllers/SpeechToTextController.d.ts

@@ -17,14 +17,12 @@ export declare class SpeechToTextController {
     private numOfChunks;
     private streaming;
     private decodedTranscribeCallback;
-    private modelDownloadProgressCallback;
     private isReadyCallback;
     private isGeneratingCallback;
     private onErrorCallback;
     private config;
-    constructor({ transcribeCallback, modelDownloadProgressCallback, isReadyCallback, isGeneratingCallback, onErrorCallback, overlapSeconds, windowSize, streamingConfig, }: {
+    constructor({ transcribeCallback, isReadyCallback, isGeneratingCallback, onErrorCallback, overlapSeconds, windowSize, streamingConfig, }: {
         transcribeCallback: (sequence: string) => void;
-        modelDownloadProgressCallback?: (downloadProgress: number) => void;
         isReadyCallback?: (isReady: boolean) => void;
         isGeneratingCallback?: (isGenerating: boolean) => void;
         onErrorCallback?: (error: Error | undefined) => void;
@@ -32,7 +30,13 @@ export declare class SpeechToTextController {
         windowSize?: number;
         streamingConfig?: keyof typeof MODES;
     });
-    loadModel(modelName: AvailableModels, encoderSource?: ResourceSource, decoderSource?: ResourceSource, tokenizerSource?: ResourceSource): Promise<void>;
+    load({ modelName, encoderSource, decoderSource, tokenizerSource, onDownloadProgressCallback, }: {
+        modelName: AvailableModels;
+        encoderSource?: ResourceSource;
+        decoderSource?: ResourceSource;
+        tokenizerSource?: ResourceSource;
+        onDownloadProgressCallback?: (downloadProgress: number) => void;
+    }): Promise<void>;
     configureStreaming(overlapSeconds?: number, windowSize?: number, streamingConfig?: keyof typeof MODES): void;
     private chunkWaveform;
     private resetState;

package/lib/controllers/SpeechToTextController.js

@@ -1,4 +1,5 @@
 import { HAMMING_DIST_THRESHOLD, MODEL_CONFIGS, SECOND, MODES, NUM_TOKENS_TO_TRIM, STREAMING_ACTION, } from '../constants/sttDefaults';
+import { AvailableModels } from '../types/stt';
 import { TokenizerModule } from '../modules/natural_language_processing/TokenizerModule';
 import { ResourceFetcher } from '../utils/ResourceFetcher';
 import { longCommonInfPref } from '../utils/stt';
@@ -20,15 +21,13 @@ export class SpeechToTextController {
     streaming = false;
     // User callbacks
     decodedTranscribeCallback;
-    modelDownloadProgressCallback;
     isReadyCallback;
     isGeneratingCallback;
     onErrorCallback;
     config;
-    constructor({ transcribeCallback, modelDownloadProgressCallback, isReadyCallback, isGeneratingCallback, onErrorCallback, overlapSeconds, windowSize, streamingConfig, }) {
+    constructor({ transcribeCallback, isReadyCallback, isGeneratingCallback, onErrorCallback, overlapSeconds, windowSize, streamingConfig, }) {
         this.tokenizerModule = new TokenizerModule();
         this.decodedTranscribeCallback = async (seq) => transcribeCallback(await this.tokenIdsToText(seq));
-        this.modelDownloadProgressCallback = modelDownloadProgressCallback;
         this.isReadyCallback = (isReady) => {
             this.isReady = isReady;
             isReadyCallback?.(isReady);
@@ -48,17 +47,24 @@ export class SpeechToTextController {
         };
         this.configureStreaming(overlapSeconds, windowSize, streamingConfig || 'balanced');
     }
-    async loadModel(modelName, encoderSource, decoderSource, tokenizerSource) {
+    async load({ modelName, encoderSource, decoderSource, tokenizerSource, onDownloadProgressCallback, }) {
         this.onErrorCallback(undefined);
         this.isReadyCallback(false);
         this.config = MODEL_CONFIGS[modelName];
         try {
-            await this.tokenizerModule.load(tokenizerSource || this.config.tokenizer.source);
-            const paths = await ResourceFetcher.fetch(this.modelDownloadProgressCallback, encoderSource || this.config.sources.encoder, decoderSource || this.config.sources.decoder);
-            if (paths === null || paths.length < 2) {
+            const tokenizerLoadPromise = this.tokenizerModule.load({
+                tokenizerSource: tokenizerSource || this.config.tokenizer.source,
+            });
+            const pathsPromise = ResourceFetcher.fetch(onDownloadProgressCallback, encoderSource || this.config.sources.encoder, decoderSource || this.config.sources.decoder);
+            const [_, encoderDecoderResults] = await Promise.all([
+                tokenizerLoadPromise,
+                pathsPromise,
+            ]);
+            encoderSource = encoderDecoderResults?.[0];
+            decoderSource = encoderDecoderResults?.[1];
+            if (!encoderSource || !decoderSource) {
                 throw new Error('Download interrupted.');
             }
-            [encoderSource, decoderSource] = paths;
         }
         catch (e) {
             this.onErrorCallback(e);
@@ -69,7 +75,7 @@ export class SpeechToTextController {
             // create a separate class for multilingual version of Whisper, since it is the same. We just need
             // the distinction here, in TS, for start tokens and such. If we introduce
             // more versions of Whisper, such as the small one, this should be refactored.
-            modelName = 'whisper';
+            modelName = AvailableModels.WHISPER;
         }
         try {
             const nativeSpeechToText = await global.loadSpeechToText(encoderSource, decoderSource, modelName);

package/lib/controllers/VerticalOCRController.d.ts

@@ -0,0 +1,25 @@
+import { ResourceSource } from '../types/common';
+import { OCRLanguage } from '../types/ocr';
+export declare class VerticalOCRController {
+    private ocrNativeModule;
+    isReady: boolean;
+    isGenerating: boolean;
+    error: string | null;
+    private isReadyCallback;
+    private isGeneratingCallback;
+    private errorCallback;
+    constructor({ isReadyCallback, isGeneratingCallback, errorCallback, }?: {
+        isReadyCallback?: ((_isReady: boolean) => void) | undefined;
+        isGeneratingCallback?: ((_isGenerating: boolean) => void) | undefined;
+        errorCallback?: ((_error: string) => void) | undefined;
+    });
+    load: (detectorSources: {
+        detectorLarge: ResourceSource;
+        detectorNarrow: ResourceSource;
+    }, recognizerSources: {
+        recognizerLarge: ResourceSource;
+        recognizerSmall: ResourceSource;
+    }, language: OCRLanguage, independentCharacters: boolean, onDownloadProgressCallback: (downloadProgress: number) => void) => Promise<void>;
+    forward: (input: string) => Promise<any>;
+    delete(): void;
+}

package/lib/controllers/VerticalOCRController.js

@@ -0,0 +1,75 @@
+import { symbols } from '../constants/ocr/symbols';
+import { ETError, getError } from '../Error';
+import { ResourceFetcher } from '../utils/ResourceFetcher';
+export class VerticalOCRController {
+    ocrNativeModule;
+    isReady = false;
+    isGenerating = false;
+    error = null;
+    isReadyCallback;
+    isGeneratingCallback;
+    errorCallback;
+    constructor({ isReadyCallback = (_isReady) => { }, isGeneratingCallback = (_isGenerating) => { }, errorCallback = (_error) => { }, } = {}) {
+        this.isReadyCallback = isReadyCallback;
+        this.isGeneratingCallback = isGeneratingCallback;
+        this.errorCallback = errorCallback;
+    }
+    load = async (detectorSources, recognizerSources, language, independentCharacters, onDownloadProgressCallback) => {
+        try {
+            if (Object.keys(detectorSources).length !== 2 ||
+                Object.keys(recognizerSources).length !== 2)
+                return;
+            if (!symbols[language]) {
+                throw new Error(getError(ETError.LanguageNotSupported));
+            }
+            this.isReady = false;
+            this.isReadyCallback(this.isReady);
+            const paths = await ResourceFetcher.fetch(onDownloadProgressCallback, detectorSources.detectorLarge, detectorSources.detectorNarrow, independentCharacters
+                ? recognizerSources.recognizerSmall
+                : recognizerSources.recognizerLarge);
+            if (paths === null || paths.length < 3) {
+                throw new Error('Download interrupted');
+            }
+            this.ocrNativeModule = global.loadVerticalOCR(paths[0], paths[1], paths[2], symbols[language], independentCharacters);
+            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.ocrNativeModule.generate(input);
+        }
+        catch (e) {
+            throw new Error(getError(e));
+        }
+        finally {
+            this.isGenerating = false;
+            this.isGeneratingCallback(this.isGenerating);
+        }
+    };
+    delete() {
+        if (this.isGenerating) {
+            throw new Error(getError(ETError.ModelGenerating) +
+                'You cannot delete the model. You must wait until the generating is finished.');
+        }
+        this.ocrNativeModule.unload();
+        this.isReadyCallback(false);
+        this.isGeneratingCallback(false);
+    }
+}

package/lib/hooks/computer_vision/useClassification.d.ts

@@ -0,0 +1,15 @@
+import { ResourceSource } from '../../types/common';
+interface Props {
+    model: {
+        modelSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}
+export declare const useClassification: ({ model, preventLoad }: Props) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (imageSource: string) => Promise<any>;
+};
+export {};

package/lib/hooks/computer_vision/useClassification.js

@@ -0,0 +1,7 @@
+import { useNonStaticModule } from '../useNonStaticModule';
+import { ClassificationModule } from '../../modules/computer_vision/ClassificationModule';
+export const useClassification = ({ model, preventLoad = false }) => useNonStaticModule({
+    module: ClassificationModule,
+    model,
+    preventLoad: preventLoad,
+});

package/lib/hooks/computer_vision/useImageEmbeddings.d.ts

@@ -0,0 +1,15 @@
+import { ResourceSource } from '../../types/common';
+interface Props {
+    model: {
+        modelSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}
+export declare const useImageEmbeddings: ({ model, preventLoad }: Props) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (imageSource: string) => Promise<Float32Array<ArrayBufferLike>>;
+};
+export {};

package/lib/hooks/computer_vision/useImageEmbeddings.js

@@ -0,0 +1,7 @@
+import { ImageEmbeddingsModule } from '../../modules/computer_vision/ImageEmbeddingsModule';
+import { useNonStaticModule } from '../useNonStaticModule';
+export const useImageEmbeddings = ({ model, preventLoad = false }) => useNonStaticModule({
+    module: ImageEmbeddingsModule,
+    model,
+    preventLoad,
+});

package/lib/hooks/computer_vision/useImageSegmentation.d.ts

@@ -0,0 +1,38 @@
+import { ResourceSource } from '../../types/common';
+interface Props {
+    model: {
+        modelSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}
+export declare const useImageSegmentation: ({ model, preventLoad }: Props) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (imageSource: string, classesOfInterest?: import("../..").DeeplabLabel[] | undefined, resize?: boolean | undefined) => Promise<{
+        0?: number[] | undefined;
+        1?: number[] | undefined;
+        2?: number[] | undefined;
+        3?: number[] | undefined;
+        4?: number[] | undefined;
+        5?: number[] | undefined;
+        6?: number[] | undefined;
+        7?: number[] | undefined;
+        8?: number[] | undefined;
+        9?: number[] | undefined;
+        10?: number[] | undefined;
+        11?: number[] | undefined;
+        12?: number[] | undefined;
+        13?: number[] | undefined;
+        14?: number[] | undefined;
+        15?: number[] | undefined;
+        16?: number[] | undefined;
+        17?: number[] | undefined;
+        18?: number[] | undefined;
+        19?: number[] | undefined;
+        20?: number[] | undefined;
+        21?: number[] | undefined;
+    }>;
+};
+export {};

package/lib/hooks/computer_vision/useImageSegmentation.js

@@ -0,0 +1,7 @@
+import { useNonStaticModule } from '../useNonStaticModule';
+import { ImageSegmentationModule } from '../../modules/computer_vision/ImageSegmentationModule';
+export const useImageSegmentation = ({ model, preventLoad = false }) => useNonStaticModule({
+    module: ImageSegmentationModule,
+    model,
+    preventLoad,
+});

package/lib/hooks/computer_vision/useOCR.d.ts

@@ -0,0 +1,20 @@
+import { ResourceSource } from '../../types/common';
+import { OCRDetection, OCRLanguage } from '../../types/ocr';
+interface OCRModule {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    forward: (input: string) => Promise<OCRDetection[]>;
+    downloadProgress: number;
+}
+export declare const useOCR: ({ model, preventLoad, }: {
+    model: {
+        detectorSource: ResourceSource;
+        recognizerLarge: ResourceSource;
+        recognizerMedium: ResourceSource;
+        recognizerSmall: ResourceSource;
+        language: OCRLanguage;
+    };
+    preventLoad?: boolean;
+}) => OCRModule;
+export {};

package/lib/hooks/computer_vision/useOCR.js

@@ -0,0 +1,42 @@
+import { useEffect, useMemo, useState } from 'react';
+import { OCRController } from '../../controllers/OCRController';
+export const useOCR = ({ model, preventLoad = false, }) => {
+    const [error, setError] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const controllerInstance = useMemo(() => new OCRController({
+        isReadyCallback: setIsReady,
+        isGeneratingCallback: setIsGenerating,
+        errorCallback: setError,
+    }), []);
+    useEffect(() => {
+        if (preventLoad)
+            return;
+        (async () => {
+            await controllerInstance.load(model.detectorSource, {
+                recognizerLarge: model.recognizerLarge,
+                recognizerMedium: model.recognizerMedium,
+                recognizerSmall: model.recognizerSmall,
+            }, model.language, setDownloadProgress);
+        })();
+        return () => {
+            controllerInstance.delete();
+        };
+    }, [
+        controllerInstance,
+        model.detectorSource,
+        model.recognizerLarge,
+        model.recognizerMedium,
+        model.recognizerSmall,
+        model.language,
+        preventLoad,
+    ]);
+    return {
+        error,
+        isReady,
+        isGenerating,
+        forward: controllerInstance.forward,
+        downloadProgress,
+    };
+};

package/lib/hooks/computer_vision/useObjectDetection.d.ts

@@ -0,0 +1,15 @@
+import { ResourceSource } from '../../types/common';
+interface Props {
+    model: {
+        modelSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}
+export declare const useObjectDetection: ({ model, preventLoad }: Props) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (imageSource: string, detectionThreshold?: number | undefined) => Promise<import("../..").Detection[]>;
+};
+export {};

package/lib/hooks/computer_vision/useObjectDetection.js

@@ -0,0 +1,7 @@
+import { useNonStaticModule } from '../useNonStaticModule';
+import { ObjectDetectionModule } from '../../modules/computer_vision/ObjectDetectionModule';
+export const useObjectDetection = ({ model, preventLoad = false }) => useNonStaticModule({
+    module: ObjectDetectionModule,
+    model,
+    preventLoad: preventLoad,
+});

package/lib/hooks/computer_vision/useStyleTransfer.d.ts

@@ -0,0 +1,15 @@
+import { ResourceSource } from '../../types/common';
+interface Props {
+    model: {
+        modelSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}
+export declare const useStyleTransfer: ({ model, preventLoad }: Props) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (imageSource: string) => Promise<string>;
+};
+export {};

package/lib/hooks/computer_vision/useStyleTransfer.js

@@ -0,0 +1,7 @@
+import { useNonStaticModule } from '../useNonStaticModule';
+import { StyleTransferModule } from '../../modules/computer_vision/StyleTransferModule';
+export const useStyleTransfer = ({ model, preventLoad = false }) => useNonStaticModule({
+    module: StyleTransferModule,
+    model,
+    preventLoad: preventLoad,
+});

package/lib/hooks/computer_vision/useVerticalOCR.d.ts

@@ -0,0 +1,21 @@
+import { ResourceSource } from '../../types/common';
+import { OCRDetection, OCRLanguage } from '../../types/ocr';
+interface OCRModule {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    forward: (input: string) => Promise<OCRDetection[]>;
+    downloadProgress: number;
+}
+export declare const useVerticalOCR: ({ model, independentCharacters, preventLoad, }: {
+    model: {
+        detectorLarge: ResourceSource;
+        detectorNarrow: ResourceSource;
+        recognizerLarge: ResourceSource;
+        recognizerSmall: ResourceSource;
+        language: OCRLanguage;
+    };
+    independentCharacters?: boolean;
+    preventLoad?: boolean;
+}) => OCRModule;
+export {};

package/lib/hooks/computer_vision/useVerticalOCR.js

@@ -0,0 +1,45 @@
+import { useEffect, useMemo, useState } from 'react';
+import { VerticalOCRController } from '../../controllers/VerticalOCRController';
+export const useVerticalOCR = ({ model, independentCharacters = false, preventLoad = false, }) => {
+    const [error, setError] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const controllerInstance = useMemo(() => new VerticalOCRController({
+        isReadyCallback: setIsReady,
+        isGeneratingCallback: setIsGenerating,
+        errorCallback: setError,
+    }), []);
+    useEffect(() => {
+        if (preventLoad)
+            return;
+        (async () => {
+            await controllerInstance.load({
+                detectorLarge: model.detectorLarge,
+                detectorNarrow: model.detectorNarrow,
+            }, {
+                recognizerLarge: model.recognizerLarge,
+                recognizerSmall: model.recognizerSmall,
+            }, model.language, independentCharacters, setDownloadProgress);
+        })();
+        return () => {
+            controllerInstance.delete();
+        };
+    }, [
+        controllerInstance,
+        model.detectorLarge,
+        model.detectorNarrow,
+        model.recognizerLarge,
+        model.recognizerSmall,
+        model.language,
+        independentCharacters,
+        preventLoad,
+    ]);
+    return {
+        error,
+        isReady,
+        isGenerating,
+        forward: controllerInstance.forward,
+        downloadProgress,
+    };
+};

package/lib/hooks/general/useExecutorchModule.d.ts

@@ -0,0 +1,13 @@
+import { ResourceSource } from '../../types/common';
+interface Props {
+    modelSource: ResourceSource;
+    preventLoad?: boolean;
+}
+export declare const useExecutorchModule: ({ modelSource, preventLoad, }: Props) => {
+    error: string | null;
+    isReady: boolean;
+    isGenerating: boolean;
+    downloadProgress: number;
+    forward: (inputTensor: import("../../types/common").TensorPtr[]) => Promise<import("../../types/common").TensorPtr[]>;
+};
+export {};

package/lib/hooks/general/useExecutorchModule.js

@@ -0,0 +1,7 @@
+import { ExecutorchModule } from '../../modules/general/ExecutorchModule';
+import { useNonStaticModule } from '../useNonStaticModule';
+export const useExecutorchModule = ({ modelSource, preventLoad = false, }) => useNonStaticModule({
+    module: ExecutorchModule,
+    model: { modelSource },
+    preventLoad,
+});

package/lib/hooks/natural_language_processing/useLLM.d.ts

@@ -0,0 +1,10 @@
+import { ResourceSource } from '../../types/common';
+import { LLMType } from '../../types/llm';
+export declare const useLLM: ({ model, preventLoad, }: {
+    model: {
+        modelSource: ResourceSource;
+        tokenizerSource: ResourceSource;
+        tokenizerConfigSource: ResourceSource;
+    };
+    preventLoad?: boolean;
+}) => LLMType;

package/lib/hooks/natural_language_processing/useLLM.js

@@ -0,0 +1,78 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { LLMController } from '../../controllers/LLMController';
+/*
+Hook version of LLMModule
+*/
+export const useLLM = ({ model, preventLoad = false, }) => {
+    const [token, setToken] = useState('');
+    const [response, setResponse] = useState('');
+    const [messageHistory, setMessageHistory] = useState([]);
+    const [isReady, setIsReady] = useState(false);
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [downloadProgress, setDownloadProgress] = useState(0);
+    const [error, setError] = useState(null);
+    const tokenCallback = useCallback((newToken) => {
+        setToken(newToken);
+        setResponse((prevResponse) => prevResponse + newToken);
+    }, []);
+    const controllerInstance = useMemo(() => new LLMController({
+        tokenCallback: tokenCallback,
+        messageHistoryCallback: setMessageHistory,
+        isReadyCallback: setIsReady,
+        isGeneratingCallback: setIsGenerating,
+    }), [tokenCallback]);
+    useEffect(() => {
+        setDownloadProgress(0);
+        setError(null);
+        if (preventLoad)
+            return;
+        (async () => {
+            try {
+                await controllerInstance.load({
+                    modelSource: model.modelSource,
+                    tokenizerSource: model.tokenizerSource,
+                    tokenizerConfigSource: model.tokenizerConfigSource,
+                    onDownloadProgressCallback: setDownloadProgress,
+                });
+            }
+            catch (e) {
+                setError(e);
+            }
+        })();
+        return () => {
+            controllerInstance.delete();
+        };
+    }, [
+        controllerInstance,
+        model.modelSource,
+        model.tokenizerSource,
+        model.tokenizerConfigSource,
+        preventLoad,
+    ]);
+    // memoization of returned functions
+    const configure = useCallback(({ chatConfig, toolsConfig, }) => controllerInstance.configure({ chatConfig, toolsConfig }), [controllerInstance]);
+    const generate = useCallback((messages, tools) => {
+        setResponse('');
+        return controllerInstance.generate(messages, tools);
+    }, [controllerInstance]);
+    const sendMessage = useCallback((message) => {
+        setResponse('');
+        return controllerInstance.sendMessage(message);
+    }, [controllerInstance]);
+    const deleteMessage = useCallback((index) => controllerInstance.deleteMessage(index), [controllerInstance]);
+    const interrupt = useCallback(() => controllerInstance.interrupt(), [controllerInstance]);
+    return {
+        messageHistory,
+        response,
+        token,
+        isReady,
+        isGenerating,
+        downloadProgress,
+        error,
+        configure: configure,
+        generate: generate,
+        sendMessage: sendMessage,
+        deleteMessage: deleteMessage,
+        interrupt: interrupt,
+    };
+};