react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

package/src/controllers/SpeechToTextController.ts

@@ -1,458 +0,0 @@
-import {
-  HAMMING_DIST_THRESHOLD,
-  MODEL_CONFIGS,
-  SECOND,
-  MODES,
-  NUM_TOKENS_TO_TRIM,
-  STREAMING_ACTION,
-} from '../constants/sttDefaults';
-import { AvailableModels, ModelConfig } from '../types/stt';
-import { SpeechToTextNativeModule } from '../native/RnExecutorchModules';
-import { TokenizerModule } from '../modules/natural_language_processing/TokenizerModule';
-import { ResourceSource } from '../types/common';
-import { ResourceFetcher } from '../utils/ResourceFetcher';
-import { longCommonInfPref } from '../utils/stt';
-import { SpeechToTextLanguage } from '../types/stt';
-import { ETError, getError } from '../Error';
-
-export class SpeechToTextController {
-  private speechToTextNativeModule = SpeechToTextNativeModule;
-
-  public sequence: number[] = [];
-  public isReady = false;
-  public isGenerating = false;
-
-  private overlapSeconds!: number;
-  private windowSize!: number;
-  private chunks: number[][] = [];
-  private seqs: number[][] = [];
-  private prevSeq: number[] = [];
-  private waveform: number[] = [];
-  private numOfChunks = 0;
-  private streaming = false;
-
-  // User callbacks
-  private decodedTranscribeCallback: (sequence: number[]) => void;
-  private modelDownloadProgressCallback:
-    | ((downloadProgress: number) => void)
-    | undefined;
-  private isReadyCallback: (isReady: boolean) => void;
-  private isGeneratingCallback: (isGenerating: boolean) => void;
-  private onErrorCallback: (error: any) => void;
-  private config!: ModelConfig;
-
-  constructor({
-    transcribeCallback,
-    modelDownloadProgressCallback,
-    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;
-    overlapSeconds?: number;
-    windowSize?: number;
-    streamingConfig?: keyof typeof MODES;
-  }) {
-    this.decodedTranscribeCallback = async (seq) =>
-      transcribeCallback(await this.tokenIdsToText(seq));
-    this.modelDownloadProgressCallback = modelDownloadProgressCallback;
-    this.isReadyCallback = (isReady) => {
-      this.isReady = isReady;
-      isReadyCallback?.(isReady);
-    };
-    this.isGeneratingCallback = (isGenerating) => {
-      this.isGenerating = isGenerating;
-      isGeneratingCallback?.(isGenerating);
-    };
-    this.onErrorCallback = (error) => {
-      if (onErrorCallback) {
-        onErrorCallback(error ? new Error(getError(error)) : undefined);
-        return;
-      } else {
-        throw new Error(getError(error));
-      }
-    };
-    this.configureStreaming(
-      overlapSeconds,
-      windowSize,
-      streamingConfig || 'balanced'
-    );
-  }
-
-  public async loadModel(
-    modelName: AvailableModels,
-    encoderSource?: ResourceSource,
-    decoderSource?: ResourceSource,
-    tokenizerSource?: ResourceSource
-  ) {
-    this.onErrorCallback(undefined);
-    this.isReadyCallback(false);
-    this.config = MODEL_CONFIGS[modelName];
-
-    try {
-      await TokenizerModule.load(
-        tokenizerSource || this.config.tokenizer.source
-      );
-
-      [encoderSource, decoderSource] =
-        await ResourceFetcher.fetchMultipleResources(
-          this.modelDownloadProgressCallback,
-          encoderSource || this.config.sources.encoder,
-          decoderSource || this.config.sources.decoder
-        );
-    } catch (e) {
-      this.onErrorCallback(e);
-      return;
-    }
-
-    if (modelName === 'whisperMultilingual') {
-      // The underlying native class is instantiated based on the name of the model. There is no need to
-      // 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';
-    }
-
-    try {
-      await this.speechToTextNativeModule.loadModule(modelName, [
-        encoderSource!,
-        decoderSource!,
-      ]);
-      this.modelDownloadProgressCallback?.(1);
-      this.isReadyCallback(true);
-    } catch (e) {
-      this.onErrorCallback(e);
-    }
-  }
-
-  public configureStreaming(
-    overlapSeconds?: number,
-    windowSize?: number,
-    streamingConfig?: keyof typeof MODES
-  ) {
-    if (streamingConfig) {
-      this.windowSize = MODES[streamingConfig].windowSize * SECOND;
-      this.overlapSeconds = MODES[streamingConfig].overlapSeconds * SECOND;
-    }
-    if (streamingConfig && (windowSize || overlapSeconds)) {
-      console.warn(
-        `windowSize and overlapSeconds overrides values from streamingConfig ${streamingConfig}.`
-      );
-    }
-    this.windowSize = (windowSize || 0) * SECOND || this.windowSize;
-    this.overlapSeconds = (overlapSeconds || 0) * SECOND || this.overlapSeconds;
-    if (2 * this.overlapSeconds + this.windowSize >= 30 * SECOND) {
-      console.warn(
-        `Invalid values for overlapSeconds and/or windowSize provided. Expected windowSize + 2 * overlapSeconds (== ${this.windowSize + 2 * this.overlapSeconds}) <= 30. Setting windowSize to ${30 * SECOND - 2 * this.overlapSeconds}.`
-      );
-      this.windowSize = 30 * SECOND - 2 * this.overlapSeconds;
-    }
-  }
-
-  private chunkWaveform() {
-    this.numOfChunks = Math.ceil(this.waveform.length / this.windowSize);
-    for (let i = 0; i < this.numOfChunks; i++) {
-      let chunk: number[] = [];
-      const left = Math.max(this.windowSize * i - this.overlapSeconds, 0);
-      const right = Math.min(
-        this.windowSize * (i + 1) + this.overlapSeconds,
-        this.waveform.length
-      );
-      chunk = this.waveform.slice(left, right);
-      this.chunks.push(chunk);
-    }
-  }
-
-  private resetState() {
-    this.sequence = [];
-    this.seqs = [];
-    this.waveform = [];
-    this.prevSeq = [];
-    this.chunks = [];
-    this.decodedTranscribeCallback([]);
-    this.onErrorCallback(undefined);
-  }
-
-  private expectedChunkLength() {
-    //only first chunk can be of shorter length, for first chunk there are no seqs decoded
-    return this.seqs.length
-      ? this.windowSize + 2 * this.overlapSeconds
-      : this.windowSize + this.overlapSeconds;
-  }
-
-  private async getStartingTokenIds(audioLanguage?: string): Promise<number[]> {
-    // We need different starting token ids based on the multilingualism of the model.
-    // The eng version only needs BOS token, while the multilingual one needs:
-    // [BOS, LANG, TRANSCRIBE]. Optionally we should also set notimestamps token, as timestamps
-    // is not yet supported.
-    if (!audioLanguage) {
-      return [this.config.tokenizer.bos];
-    }
-    // FIXME: I should use .getTokenId for the BOS as well, should remove it from config
-    const langTokenId = await TokenizerModule.tokenToId(`<|${audioLanguage}|>`);
-    const transcribeTokenId = await TokenizerModule.tokenToId('<|transcribe|>');
-    const noTimestampsTokenId =
-      await TokenizerModule.tokenToId('<|notimestamps|>');
-    const startingTokenIds = [
-      this.config.tokenizer.bos,
-      langTokenId,
-      transcribeTokenId,
-      noTimestampsTokenId,
-    ];
-    return startingTokenIds;
-  }
-
-  private async decodeChunk(
-    chunk: number[],
-    audioLanguage?: SpeechToTextLanguage
-  ): Promise<number[]> {
-    const seq = await this.getStartingTokenIds(audioLanguage);
-    let prevSeqTokenIdx = 0;
-    this.prevSeq = this.sequence.slice();
-    try {
-      await this.encode(chunk);
-    } catch (error) {
-      this.onErrorCallback(new Error(getError(error) + ' encoding error'));
-      return [];
-    }
-    let lastToken = seq.at(-1) as number;
-    while (lastToken !== this.config.tokenizer.eos) {
-      try {
-        lastToken = await this.decode(seq);
-      } catch (error) {
-        this.onErrorCallback(new Error(getError(error) + ' decoding error'));
-        return [...seq, this.config.tokenizer.eos];
-      }
-      seq.push(lastToken);
-      if (
-        this.seqs.length > 0 &&
-        seq.length < this.seqs.at(-1)!.length &&
-        seq.length % 3 !== 0
-      ) {
-        this.prevSeq.push(this.seqs.at(-1)![prevSeqTokenIdx++]!);
-        this.decodedTranscribeCallback(this.prevSeq);
-      }
-    }
-    return seq;
-  }
-
-  private async handleOverlaps(seqs: number[][]): Promise<number[]> {
-    const maxInd = longCommonInfPref(
-      seqs.at(-2)!,
-      seqs.at(-1)!,
-      HAMMING_DIST_THRESHOLD
-    );
-    this.sequence = [...this.sequence, ...seqs.at(-2)!.slice(0, maxInd)];
-    this.decodedTranscribeCallback(this.sequence);
-    return this.sequence.slice();
-  }
-
-  private trimLeft(numOfTokensToTrim: number) {
-    const idx = this.seqs.length - 1;
-    if (this.seqs[idx]![0] === this.config.tokenizer.bos) {
-      this.seqs[idx] = this.seqs[idx]!.slice(numOfTokensToTrim);
-    }
-  }
-
-  private trimRight(numOfTokensToTrim: number) {
-    const idx = this.seqs.length - 2;
-    if (this.seqs[idx]!.at(-1) === this.config.tokenizer.eos) {
-      this.seqs[idx] = this.seqs[idx]!.slice(0, -numOfTokensToTrim);
-    }
-  }
-
-  // since we are calling this every time (except first) after a new seq is pushed to this.seqs
-  // we can only trim left the last seq and trim right the second to last seq
-  private async trimSequences(audioLanguage?: string) {
-    const numSpecialTokens = (await this.getStartingTokenIds(audioLanguage))
-      .length;
-    this.trimLeft(numSpecialTokens + NUM_TOKENS_TO_TRIM);
-    this.trimRight(numSpecialTokens + NUM_TOKENS_TO_TRIM);
-  }
-
-  // if last chunk is too short combine it with second to last to improve quality
-  private validateAndFixLastChunk() {
-    if (this.chunks.length < 2) return;
-
-    const lastChunkLength = this.chunks.at(-1)!.length / SECOND;
-    const secondToLastChunkLength = this.chunks.at(-2)!.length / SECOND;
-    if (lastChunkLength < 5 && secondToLastChunkLength + lastChunkLength < 30) {
-      this.chunks[this.chunks.length - 2] = [
-        ...this.chunks.at(-2)!.slice(0, -this.overlapSeconds * 2),
-        ...this.chunks.at(-1)!,
-      ];
-      this.chunks = this.chunks.slice(0, -1);
-    }
-  }
-
-  private async tokenIdsToText(tokenIds: number[]): Promise<string> {
-    try {
-      return TokenizerModule.decode(tokenIds, true);
-    } catch (e) {
-      this.onErrorCallback(
-        new Error(`An error has occurred when decoding the token ids: ${e}`)
-      );
-      return '';
-    }
-  }
-
-  public async transcribe(
-    waveform: number[],
-    audioLanguage?: SpeechToTextLanguage
-  ): Promise<string> {
-    try {
-      if (!this.isReady) throw Error(getError(ETError.ModuleNotLoaded));
-      if (this.isGenerating || this.streaming)
-        throw Error(getError(ETError.ModelGenerating));
-      if (!!audioLanguage !== this.config.isMultilingual)
-        throw new Error(getError(ETError.MultilingualConfiguration));
-    } catch (e) {
-      this.onErrorCallback(e);
-      return '';
-    }
-
-    // Making sure that the error is not set when we get there
-    this.isGeneratingCallback(true);
-
-    this.resetState();
-    this.waveform = waveform;
-    this.chunkWaveform();
-    this.validateAndFixLastChunk();
-
-    for (let chunkId = 0; chunkId < this.chunks.length; chunkId++) {
-      const seq = await this.decodeChunk(
-        this.chunks!.at(chunkId)!,
-        audioLanguage
-      );
-      // whole audio is inside one chunk, no processing required
-      if (this.chunks.length === 1) {
-        this.sequence = seq;
-        this.decodedTranscribeCallback(seq);
-        break;
-      }
-      this.seqs.push(seq);
-
-      if (this.seqs.length < 2) continue;
-
-      // Remove starting tokenIds and some additional ones
-      await this.trimSequences(audioLanguage);
-
-      this.prevSeq = await this.handleOverlaps(this.seqs);
-
-      // last sequence processed
-      // overlaps are already handled, so just append the last seq
-      if (this.seqs.length === this.chunks.length) {
-        this.sequence = [...this.sequence, ...this.seqs.at(-1)!];
-        this.decodedTranscribeCallback(this.sequence);
-        this.prevSeq = this.sequence;
-      }
-    }
-    const decodedText = await this.tokenIdsToText(this.sequence);
-    this.isGeneratingCallback(false);
-    return decodedText;
-  }
-
-  public async streamingTranscribe(
-    streamAction: STREAMING_ACTION,
-    waveform?: number[],
-    audioLanguage?: SpeechToTextLanguage
-  ): Promise<string> {
-    try {
-      if (!this.isReady) throw Error(getError(ETError.ModuleNotLoaded));
-      if (!!audioLanguage !== this.config.isMultilingual)
-        throw new Error(getError(ETError.MultilingualConfiguration));
-
-      if (
-        streamAction === STREAMING_ACTION.START &&
-        !this.streaming &&
-        this.isGenerating
-      )
-        throw Error(getError(ETError.ModelGenerating));
-      if (streamAction === STREAMING_ACTION.START && this.streaming)
-        throw Error(getError(ETError.ModelGenerating));
-      if (streamAction === STREAMING_ACTION.DATA && !this.streaming)
-        throw Error(getError(ETError.StreamingNotStarted));
-      if (streamAction === STREAMING_ACTION.STOP && !this.streaming)
-        throw Error(getError(ETError.StreamingNotStarted));
-      if (streamAction === STREAMING_ACTION.DATA && !waveform)
-        throw new Error(getError(ETError.MissingDataChunk));
-    } catch (e) {
-      this.onErrorCallback(e);
-      return '';
-    }
-
-    if (streamAction === STREAMING_ACTION.START) {
-      this.resetState();
-      this.streaming = true;
-      this.isGeneratingCallback(true);
-    }
-
-    this.waveform = [...this.waveform, ...(waveform || [])];
-
-    // while buffer has at least required size get chunk and decode
-    while (this.waveform.length >= this.expectedChunkLength()) {
-      const chunk = this.waveform.slice(
-        0,
-        this.windowSize +
-          this.overlapSeconds * (1 + Number(this.seqs.length > 0))
-      );
-      this.chunks = [chunk]; //save last chunk for STREAMING_ACTION.STOP
-      this.waveform = this.waveform.slice(
-        this.windowSize - this.overlapSeconds * Number(this.seqs.length === 0)
-      );
-      const seq = await this.decodeChunk(chunk, audioLanguage);
-      this.seqs.push(seq);
-
-      if (this.seqs.length < 2) continue;
-
-      await this.trimSequences(audioLanguage);
-      await this.handleOverlaps(this.seqs);
-    }
-
-    // got final package, process all remaining waveform data
-    // since we run the loop above the waveform has at most one chunk in it
-    if (streamAction === STREAMING_ACTION.STOP) {
-      // pad remaining waveform data with previous chunk to this.windowSize + 2 * this.overlapSeconds
-      const chunk = this.chunks.length
-        ? [
-            ...this.chunks[0]!.slice(0, this.windowSize),
-            ...this.waveform,
-          ].slice(-this.windowSize - 2 * this.overlapSeconds)
-        : this.waveform;
-
-      this.waveform = [];
-      const seq = await this.decodeChunk(chunk, audioLanguage);
-      this.seqs.push(seq);
-
-      if (this.seqs.length === 1) {
-        this.sequence = this.seqs[0]!;
-      } else {
-        await this.trimSequences(audioLanguage);
-        await this.handleOverlaps(this.seqs);
-        this.sequence = [...this.sequence, ...this.seqs.at(-1)!];
-      }
-      this.decodedTranscribeCallback(this.sequence);
-      this.isGeneratingCallback(false);
-      this.streaming = false;
-    }
-
-    const decodedText = await this.tokenIdsToText(this.sequence);
-
-    return decodedText;
-  }
-
-  public async encode(waveform: number[]) {
-    return await this.speechToTextNativeModule.encode(waveform);
-  }
-
-  public async decode(seq: number[], encodings?: number[]) {
-    return await this.speechToTextNativeModule.decode(seq, encodings || []);
-  }
-}

package/src/index.tsx

@@ -1,47 +0,0 @@
-import { SpeechToTextLanguage } from './types/stt';
-
-// 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/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/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 './modules/general/ExecutorchModule';
-
-// utils
-export * from './utils/ResourceFetcher';
-
-// 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 } from './constants/sttDefaults';

package/src/native/NativeClassification.ts

@@ -1,9 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-
-export interface Spec extends TurboModule {
-  loadModule(modelSource: string): Promise<number>;
-  forward(input: string): Promise<{ [category: string]: number }>;
-}
-
-export default TurboModuleRegistry.get<Spec>('Classification');

package/src/native/NativeETModule.ts

@@ -1,14 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-
-export interface Spec extends TurboModule {
-  loadModule(modelSource: string): Promise<number>;
-  forward(
-    inputs: number[][],
-    shapes: number[][],
-    inputTypes: number[]
-  ): Promise<number[][]>;
-  loadMethod(methodName: string): Promise<number>;
-}
-
-export default TurboModuleRegistry.get<Spec>('ETModule');

package/src/native/NativeImageSegmentation.ts

@@ -1,14 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-
-export interface Spec extends TurboModule {
-  loadModule(modelSource: string): Promise<number>;
-
-  forward(
-    input: string,
-    classesOfInterest: string[],
-    resize: boolean
-  ): Promise<{ [category: string]: number[] }>;
-}
-
-export default TurboModuleRegistry.get<Spec>('ImageSegmentation');

package/src/native/NativeLLM.ts

@@ -1,14 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
-
-export interface Spec extends TurboModule {
-  loadLLM(modelSource: string, tokenizerSource: string): Promise<string>;
-  forward(input: string): Promise<string>;
-  interrupt(): void;
-  releaseResources(): void;
-
-  readonly onToken: EventEmitter<string>;
-}
-
-export default TurboModuleRegistry.get<Spec>('LLM');

package/src/native/NativeOCR.ts

@@ -1,16 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-import { OCRDetection } from '../types/ocr';
-
-export interface Spec extends TurboModule {
-  loadModule(
-    detectorSource: string,
-    recognizerSourceLarge: string,
-    recognizerSourceMedium: string,
-    recognizerSourceSmall: string,
-    symbols: string
-  ): Promise<number>;
-  forward(input: string): Promise<OCRDetection[]>;
-}
-
-export default TurboModuleRegistry.get<Spec>('OCR');

package/src/native/NativeObjectDetection.ts

@@ -1,10 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-import { Detection } from '../types/objectDetection';
-
-export interface Spec extends TurboModule {
-  loadModule(modelSource: string): Promise<number>;
-  forward(input: string): Promise<Detection[]>;
-}
-
-export default TurboModuleRegistry.get<Spec>('ObjectDetection');

package/src/native/NativeSpeechToText.ts

@@ -1,17 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
-
-export interface Spec extends TurboModule {
-  loadModule(
-    modelName: string,
-    modelSources: (string | number)[]
-  ): Promise<number>;
-  generate(waveform: number[]): Promise<number[]>;
-  encode(input: number[]): Promise<number[]>;
-  decode(prevTokens: number[], encoderOutput: number[]): Promise<number>;
-
-  readonly onToken: EventEmitter<number>;
-}
-
-export default TurboModuleRegistry.get<Spec>('SpeechToText');

package/src/native/NativeStyleTransfer.ts

@@ -1,10 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-
-export interface Spec extends TurboModule {
-  loadModule(modelSource: string): Promise<number>;
-
-  forward(input: string): Promise<string>;
-}
-
-export default TurboModuleRegistry.get<Spec>('StyleTransfer');

package/src/native/NativeTextEmbeddings.ts

@@ -1,9 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-
-export interface Spec extends TurboModule {
-  loadModule(modelSource: string, tokenizerSource: string): Promise<number>;
-  forward(input: string): Promise<number[]>;
-}
-
-export default TurboModuleRegistry.get<Spec>('TextEmbeddings');

package/src/native/NativeTokenizer.ts

@@ -1,13 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-
-export interface Spec extends TurboModule {
-  loadModule(tokenizerSource: string): Promise<number>;
-  decode(input: number[], skipSpecialTokens: boolean): Promise<string>;
-  encode(input: string): Promise<number[]>;
-  getVocabSize(): Promise<number>;
-  idToToken(tokenId: number): Promise<string>;
-  tokenToId(token: string): Promise<number>;
-}
-
-export default TurboModuleRegistry.get<Spec>('Tokenizer');

package/src/native/NativeVerticalOCR.ts

@@ -1,16 +0,0 @@
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
-import { OCRDetection } from '../types/ocr';
-
-export interface Spec extends TurboModule {
-  loadModule(
-    detectorLargeSource: string,
-    detectorNarrowSource: string,
-    recognizerSource: string,
-    symbols: string,
-    independentCharacters: boolean
-  ): Promise<number>;
-  forward(input: string): Promise<OCRDetection[]>;
-}
-
-export default TurboModuleRegistry.get<Spec>('VerticalOCR');

package/src/utils/stt.ts

@@ -1,28 +0,0 @@
-export const longCommonInfPref = (
-  seq1: number[],
-  seq2: number[],
-  hammingDistThreshold: number
-) => {
-  let maxInd = 0;
-  let maxLength = 0;
-
-  for (let i = 0; i < seq1.length; i++) {
-    let j = 0;
-    let hammingDist = 0;
-    while (
-      j < seq2.length &&
-      i + j < seq1.length &&
-      (seq1[i + j] === seq2[j] || hammingDist < hammingDistThreshold)
-    ) {
-      if (seq1[i + j] !== seq2[j]) {
-        hammingDist++;
-      }
-      j++;
-    }
-    if (j >= maxLength) {
-      maxLength = j;
-      maxInd = i;
-    }
-  }
-  return maxInd;
-};