react-native-sherpa-onnx 0.2.0 → 0.3.0

package/src/download/extractTarBz2.ts

@@ -0,0 +1,78 @@
+import { DeviceEventEmitter } from 'react-native';
+import SherpaOnnx from '../NativeSherpaOnnx';
+
+export type ExtractProgressEvent = {
+  bytes: number;
+  totalBytes: number;
+  percent: number;
+};
+
+type ExtractResult = {
+  success: boolean;
+  path?: string;
+  sha256?: string;
+  reason?: string;
+};
+
+export async function extractTarBz2(
+  sourcePath: string,
+  targetPath: string,
+  force = true,
+  onProgress?: (event: ExtractProgressEvent) => void,
+  signal?: AbortSignal
+): Promise<ExtractResult> {
+  let subscription: { remove: () => void } | null = null;
+  let removeAbortListener: (() => void) | null = null;
+
+  if (signal?.aborted) {
+    const abortError = new Error('Extraction aborted');
+    abortError.name = 'AbortError';
+    throw abortError;
+  }
+
+  if (onProgress) {
+    subscription = DeviceEventEmitter.addListener(
+      'extractTarBz2Progress',
+      (event: ExtractProgressEvent & { sourcePath?: string }) => {
+        // Only handle events for this extraction (fixes parallel extractions showing same %)
+        if (event.sourcePath != null && event.sourcePath !== sourcePath) {
+          return;
+        }
+        const safePercent = Math.max(0, Math.min(100, event.percent));
+        onProgress({ ...event, percent: safePercent });
+      }
+    );
+  }
+
+  if (signal) {
+    const onAbort = () => {
+      try {
+        SherpaOnnx.cancelExtractTarBz2();
+      } catch {
+        // Ignore cancel errors to avoid crashing on abort.
+      }
+    };
+    signal.addEventListener('abort', onAbort);
+    removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+  }
+
+  try {
+    const result = await SherpaOnnx.extractTarBz2(
+      sourcePath,
+      targetPath,
+      force
+    );
+    if (!result.success) {
+      const message = result.reason || 'Extraction failed';
+      const error = new Error(message);
+      if (signal?.aborted || /cancel/i.test(message)) {
+        error.name = 'AbortError';
+      }
+      throw error;
+    }
+    return result;
+  } finally {
+    subscription?.remove();
+    removeAbortListener?.();
+  }
+}

package/src/download/index.ts

@@ -0,0 +1,43 @@
+export { extractTarBz2 } from './extractTarBz2';
+export type { ExtractProgressEvent } from './extractTarBz2';
+export {
+  listModelsByCategory,
+  refreshModelsByCategory,
+  getModelsCacheStatusByCategory,
+  getModelByIdByCategory,
+  listDownloadedModelsByCategory,
+  isModelDownloadedByCategory,
+  getLocalModelPathByCategory,
+  downloadModelByCategory,
+  deleteModelByCategory,
+  clearModelCacheByCategory,
+  getDownloadStorageBase,
+  subscribeDownloadProgress,
+  subscribeModelsListUpdated,
+  updateModelLastUsed,
+  listDownloadedModelsWithMetadata,
+  cleanupLeastRecentlyUsed,
+  ModelCategory,
+} from './ModelDownloadManager';
+export type {
+  ModelMetaBase,
+  TtsModelMeta,
+  TtsModelType,
+  Quantization,
+  SizeTier,
+  DownloadProgress,
+  DownloadProgressListener,
+  ModelsListUpdatedListener,
+  DownloadResult,
+  ModelWithMetadata,
+} from './ModelDownloadManager';
+export {
+  validateChecksum,
+  validateExtractedFiles,
+  checkDiskSpace,
+  setExpectedFilesForCategory,
+  getExpectedFilesForCategory,
+  parseChecksumFile,
+  calculateFileChecksum,
+} from './validation';
+export type { ValidationError } from './validation';

package/src/download/validation.ts

@@ -0,0 +1,279 @@
+import {
+  DocumentDirectoryPath,
+  stat,
+  exists,
+  readDir,
+  type ReadDirResItemT,
+} from '@dr.pogodin/react-native-fs';
+import SherpaOnnx from '../NativeSherpaOnnx';
+
+export type ValidationError =
+  | 'CHECKSUM_MISMATCH'
+  | 'CHECKSUM_FAILED'
+  | 'MISSING_FILES'
+  | 'INSUFFICIENT_DISK_SPACE';
+
+export class ValidationResult {
+  success: boolean;
+  error?: ValidationError;
+  message?: string;
+
+  constructor(success: boolean, error?: ValidationError, message?: string) {
+    this.success = success;
+    this.error = error;
+    this.message = message;
+  }
+}
+
+/**
+ * Parse checksum.txt format into a Map of filename -> hash
+ * Expected format:
+ * filename\tsha256hash
+ * example:
+ * vits-vctk.tar.bz2	4f0a02db66914b3760b144cebc004e65dd4d1aeef43379f2b058849e74002490
+ */
+export function parseChecksumFile(content: string): Map<string, string> {
+  const checksums = new Map<string, string>();
+  const lines = content.split('\n').filter((line) => line.trim());
+
+  for (const line of lines) {
+    const [filename, hash] = line.split(/\s+/);
+    if (filename && hash) {
+      checksums.set(filename.trim(), hash.trim());
+    }
+  }
+
+  return checksums;
+}
+
+/**
+ * Calculate SHA256 hash of a file in chunks to avoid OOM
+ * Reads file in 1MB chunks and processes them efficiently
+ */
+export async function calculateFileChecksum(
+  filePath: string,
+  onProgress?: (
+    bytesProcessed: number,
+    totalBytes: number,
+    percent: number
+  ) => void
+): Promise<string> {
+  try {
+    const digest = await SherpaOnnx.computeFileSha256(filePath);
+    if (onProgress) {
+      const statResult = await stat(filePath);
+      const total = statResult.size;
+      onProgress(total, total, 100);
+    }
+    return digest.toLowerCase();
+  } catch (error) {
+    throw new Error(`Failed to calculate checksum: ${error}`);
+  }
+}
+
+/**
+ * Validate checksum of downloaded file
+ */
+export async function validateChecksum(
+  filePath: string,
+  expectedChecksum: string,
+  onProgress?: (
+    bytesProcessed: number,
+    totalBytes: number,
+    percent: number
+  ) => void
+): Promise<ValidationResult> {
+  try {
+    const actualChecksum = await calculateFileChecksum(filePath, onProgress);
+    // checksum comparison logged
+    if (actualChecksum.toLowerCase() !== expectedChecksum.toLowerCase()) {
+      return new ValidationResult(
+        false,
+        'CHECKSUM_MISMATCH',
+        `Checksum mismatch: expected ${expectedChecksum}, got ${actualChecksum}`
+      );
+    }
+    return new ValidationResult(true);
+  } catch (error) {
+    return new ValidationResult(
+      false,
+      'CHECKSUM_FAILED',
+      `Failed to validate checksum: ${error}`
+    );
+  }
+}
+
+/**
+ * Validate that extraction was successful by checking:
+ * - Directory exists and is not empty
+ * - Contains at least some files (not just directories)
+ *
+ * The actual model validation (correct files for specific model type)
+ * is delegated to the native DetectSttModel / DetectTtsModel functions,
+ * so we don't need to check for specific filenames here.
+ */
+export async function validateExtractedFiles(
+  modelDir: string,
+  _category: string
+): Promise<ValidationResult> {
+  try {
+    const dirExists = await exists(modelDir);
+    if (!dirExists) {
+      return new ValidationResult(
+        false,
+        'MISSING_FILES',
+        `Model directory does not exist: ${modelDir}`
+      );
+    }
+
+    const isModelLikeFile = (name: string) => {
+      const lower = name.toLowerCase();
+      return (
+        lower.endsWith('.onnx') ||
+        lower.endsWith('.txt') ||
+        lower.endsWith('.bin') ||
+        lower.endsWith('.json')
+      );
+    };
+
+    const collectFilesRecursive = async (
+      dir: string,
+      depth = 0,
+      maxDepth = 4
+    ): Promise<ReadDirResItemT[]> => {
+      if (depth > maxDepth) return [];
+
+      const entries = await readDir(dir);
+      const files: ReadDirResItemT[] = [];
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const nested = await collectFilesRecursive(
+            entry.path,
+            depth + 1,
+            maxDepth
+          );
+          files.push(...nested);
+        } else {
+          files.push(entry);
+        }
+      }
+
+      return files;
+    };
+
+    const entries = await readDir(modelDir);
+    const actualFiles = entries.filter((entry) => !entry.isDirectory());
+    const subdirs = entries.filter((entry) => entry.isDirectory());
+
+    if (actualFiles.length === 0 && subdirs.length === 0) {
+      return new ValidationResult(
+        false,
+        'MISSING_FILES',
+        `Extraction failed: directory is empty: ${modelDir}`
+      );
+    }
+
+    let hasModelLikeFiles = actualFiles.some((file) =>
+      isModelLikeFile(file.name)
+    );
+
+    if (!hasModelLikeFiles) {
+      const nestedFiles = await collectFilesRecursive(modelDir);
+      hasModelLikeFiles = nestedFiles.some((file) =>
+        isModelLikeFile(file.name)
+      );
+    }
+
+    if (!hasModelLikeFiles) {
+      return new ValidationResult(
+        false,
+        'MISSING_FILES',
+        `Extraction may have failed: no model files (.onnx/.txt/.bin/.json) found under ${modelDir}`
+      );
+    }
+
+    return new ValidationResult(true);
+  } catch (error) {
+    return new ValidationResult(
+      false,
+      'MISSING_FILES',
+      `Failed to validate extracted files: ${error}`
+    );
+  }
+}
+
+/**
+ * Get available disk space (in bytes)
+ * This is a simplified version. For accurate values on Android/iOS, use native modules.
+ */
+export async function getAvailableDiskSpace(): Promise<number> {
+  try {
+    // Try to get the document directory (simple check for availability)
+    const dirExists = await exists(DocumentDirectoryPath);
+    if (dirExists) {
+      // Default to 10GB for modern devices
+      // In production, integrate native disk space calculation
+      return 10 * 1024 * 1024 * 1024; // 10GB
+    }
+  } catch (error) {
+    console.warn('Failed to check disk space:', error);
+  }
+
+  // Fallback: return 10GB estimate for modern devices
+  return 10 * 1024 * 1024 * 1024;
+}
+
+/**
+ * Check if there's enough disk space for download
+ * Adds 20% buffer to the required size
+ */
+export async function checkDiskSpace(
+  requiredBytes: number
+): Promise<ValidationResult> {
+  try {
+    const available = await getAvailableDiskSpace();
+    const buffer = requiredBytes * 0.2; // 20% safety buffer
+    const totalRequired = requiredBytes + buffer;
+
+    if (available < totalRequired) {
+      const availableGB = (available / (1024 * 1024 * 1024)).toFixed(2);
+      const requiredGB = (totalRequired / (1024 * 1024 * 1024)).toFixed(2);
+      return new ValidationResult(
+        false,
+        'INSUFFICIENT_DISK_SPACE',
+        `Insufficient disk space. Available: ${availableGB}GB, Required: ${requiredGB}GB`
+      );
+    }
+
+    return new ValidationResult(true);
+  } catch (error) {
+    return new ValidationResult(
+      false,
+      'INSUFFICIENT_DISK_SPACE',
+      `Failed to check disk space: ${error}`
+    );
+  }
+}
+
+/**
+ * Update expected files configuration for a category
+ * DEPRECATED: The native DetectSttModel/DetectTtsModel functions handle model validation.
+ * This function is kept for backward compatibility but does nothing.
+ */
+export function setExpectedFilesForCategory(
+  _category: string,
+  _files: string[]
+): void {
+  // No-op: validation is now handled by native detect functions
+}
+
+/**
+ * Get expected files for a category
+ * DEPRECATED: The native DetectSttModel/DetectTtsModel functions handle model validation.
+ * This function is kept for backward compatibility.
+ */
+export function getExpectedFilesForCategory(_category: string): string[] {
+  // Return empty array: validation is now handled by native detect functions
+  return [];
+}

package/src/enhancement/index.ts

@@ -10,16 +10,18 @@
  * // Future usage:
  * import { initializeEnhancement, enhanceAudio } from 'react-native-sherpa-onnx/enhancement';
  *
- * await initializeEnhancement({ modelPath: 'models/enhancement-model' });
+ * await initializeEnhancement({ modelPath: { type: 'auto', path: 'models/enhancement-model' } });
  * const enhancedPath = await enhanceAudio('path/to/noisy-audio.wav');
  * ```
  */
 
+import type { ModelPathConfig } from '../types';
+
 /**
  * Enhancement initialization options (placeholder)
  */
 export interface EnhancementInitializeOptions {
-  modelPath: string;
+  modelPath: ModelPathConfig;
   // Additional enhancement-specific options will be added here
 }
 

package/src/index.tsx

@@ -1,27 +1,78 @@
-import SherpaOnnx from './NativeSherpaOnnx';
-
-// Export common types and utilities
-export type { InitializeOptions, ModelPathConfig, ModelType } from './types';
-export {
-  assetModelPath,
-  autoModelPath,
-  fileModelPath,
-  getDefaultModelPath,
-  listAssetModels,
-  resolveModelPath,
-} from './utils';
-
-// Note: Feature-specific exports are available via subpath imports:
-// - import { ... } from 'react-native-sherpa-onnx/stt'
-// - import { ... } from 'react-native-sherpa-onnx/tts'
-// - import { ... } from 'react-native-sherpa-onnx/vad' (planned)
-// - import { ... } from 'react-native-sherpa-onnx/diarization' (planned)
-// - import { ... } from 'react-native-sherpa-onnx/enhancement' (planned)
-// - import { ... } from 'react-native-sherpa-onnx/separation' (planned)
-
-/**
- * Test method to verify sherpa-onnx native library is loaded.
- */
-export function testSherpaInit(): Promise<string> {
-  return SherpaOnnx.testSherpaInit();
-}
+import SherpaOnnx from './NativeSherpaOnnx';
+import type { AccelerationSupport } from './NativeSherpaOnnx';
+
+// Export common types and utilities
+export type { AccelerationSupport } from './NativeSherpaOnnx';
+export type { ModelPathConfig } from './types';
+export {
+  assetModelPath,
+  autoModelPath,
+  fileModelPath,
+  getAssetPackPath,
+  getDefaultModelPath,
+  getPlayAssetDeliveryModelsPath,
+  listAssetModels,
+  listModelsAtPath,
+  resolveModelPath,
+} from './utils';
+
+// Note: Feature-specific exports are available via subpath imports:
+// - import { ... } from 'react-native-sherpa-onnx/stt'
+// - import { ... } from 'react-native-sherpa-onnx/tts'
+// - import { ... } from 'react-native-sherpa-onnx/download'
+// - import { ... } from 'react-native-sherpa-onnx/vad' (planned)
+// - import { ... } from 'react-native-sherpa-onnx/diarization' (planned)
+// - import { ... } from 'react-native-sherpa-onnx/enhancement' (planned)
+// - import { ... } from 'react-native-sherpa-onnx/separation' (planned)
+
+/**
+ * Test method to verify sherpa-onnx native library is loaded.
+ */
+export function testSherpaInit(): Promise<string> {
+  return SherpaOnnx.testSherpaInit();
+}
+
+/**
+ * QNN support (Android). Optional modelBase64 for canInit (session test); if omitted, SDK uses embedded test model.
+ */
+export function getQnnSupport(
+  modelBase64?: string
+): Promise<AccelerationSupport> {
+  return SherpaOnnx.getQnnSupport(modelBase64);
+}
+
+/**
+ * Return the list of available ONNX Runtime execution providers
+ * (e.g. "CPU", "NNAPI", "QNN", "XNNPACK").
+ * Requires the ORT Java bridge from the onnxruntime AAR.
+ */
+export function getAvailableProviders(): Promise<string[]> {
+  return SherpaOnnx.getAvailableProviders();
+}
+
+/**
+ * NNAPI support (Android). Optional modelBase64 for canInit (session test). On iOS returns all false.
+ */
+export function getNnapiSupport(
+  modelBase64?: string
+): Promise<AccelerationSupport> {
+  return SherpaOnnx.getNnapiSupport(modelBase64);
+}
+
+/**
+ * XNNPACK support. hasAccelerator = true when providerCompiled (CPU-optimized). Optional modelBase64 for canInit. On iOS returns all false.
+ */
+export function getXnnpackSupport(
+  modelBase64?: string
+): Promise<AccelerationSupport> {
+  return SherpaOnnx.getXnnpackSupport(modelBase64);
+}
+
+/**
+ * Core ML support (iOS). providerCompiled = true (Core ML on iOS 11+), hasAccelerator = Apple Neural Engine. Optional modelBase64 for canInit. On Android returns all false.
+ */
+export function getCoreMlSupport(
+  modelBase64?: string
+): Promise<AccelerationSupport> {
+  return SherpaOnnx.getCoreMlSupport(modelBase64);
+}

package/src/separation/index.ts

@@ -10,16 +10,18 @@
  * // Future usage:
  * import { initializeSeparation, separateSources } from 'react-native-sherpa-onnx/separation';
  *
- * await initializeSeparation({ modelPath: 'models/separation-model' });
+ * await initializeSeparation({ modelPath: { type: 'auto', path: 'models/separation-model' } });
  * const sources = await separateSources('path/to/mixed-audio.wav');
  * ```
  */
 
+import type { ModelPathConfig } from '../types';
+
 /**
  * Separation initialization options (placeholder)
  */
 export interface SeparationInitializeOptions {
-  modelPath: string;
+  modelPath: ModelPathConfig;
   // Additional separation-specific options will be added here
 }