react-native-sherpa-onnx 0.3.5 → 0.3.6

package/src/NativeSherpaOnnx.ts

@@ -552,6 +552,62 @@ export interface Spec extends TurboModule {
    */
   cancelExtractTarBz2(): Promise<void>;
 
+  /**
+   * Extract a .tar.zst (or .zst) archive to a target folder.
+   * Returns { success, path } or { success, reason }.
+   */
+  extractTarZst(
+    sourcePath: string,
+    targetPath: string,
+    force: boolean
+  ): Promise<{
+    success: boolean;
+    path?: string;
+    sha256?: string;
+    reason?: string;
+  }>;
+
+  /**
+   * Cancel any in-progress tar.zst extraction.
+   */
+  cancelExtractTarZst(): Promise<void>;
+
+  /**
+   * List asset paths of .tar.zst and .tar.bz2 archives in a PAD pack when stored as APK_ASSETS.
+   * Android only; returns [] when pack is not available or not APK_ASSETS. Used by getBundledArchives.
+   */
+  listBundledArchiveAssetPaths(packName: string): Promise<string[]>;
+
+  /**
+   * Extract a .tar.zst archive from Android assets (AssetManager) to a target folder. Android only.
+   * Streams from asset; no copy of the archive to disk. Used when PAD pack is APK_ASSETS.
+   */
+  extractTarZstFromAsset(
+    assetPath: string,
+    targetPath: string,
+    force: boolean
+  ): Promise<{
+    success: boolean;
+    path?: string;
+    sha256?: string;
+    reason?: string;
+  }>;
+
+  /**
+   * Extract a .tar.bz2 archive from Android assets (AssetManager) to a target folder. Android only.
+   * Streams from asset; no copy of the archive to disk. Used when PAD pack is APK_ASSETS.
+   */
+  extractTarBz2FromAsset(
+    assetPath: string,
+    targetPath: string,
+    force: boolean
+  ): Promise<{
+    success: boolean;
+    path?: string;
+    sha256?: string;
+    reason?: string;
+  }>;
+
   /**
    * Compute SHA-256 of a file and return the hex digest.
    */

package/src/download/extractTarZst.ts

@@ -0,0 +1,77 @@
+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 extractTarZst(
+  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(
+      'extractTarZstProgress',
+      (event: ExtractProgressEvent & { sourcePath?: string }) => {
+        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.cancelExtractTarZst();
+      } catch {
+        // Ignore cancel errors to avoid crashing on abort.
+      }
+    };
+    signal.addEventListener('abort', onAbort);
+    removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+  }
+
+  try {
+    const result = await SherpaOnnx.extractTarZst(
+      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

@@ -1,5 +1,7 @@
 export { extractTarBz2 } from './extractTarBz2';
 export type { ExtractProgressEvent } from './extractTarBz2';
+export { extractTarZst } from './extractTarZst';
+export type { ExtractProgressEvent as ExtractZstProgressEvent } from './extractTarZst';
 export {
   listModelsByCategory,
   refreshModelsByCategory,

package/src/extraction/index.ts

@@ -0,0 +1,273 @@
+/**
+ * Extraction subpath: list and extract compressed model archives (.tar.zst / .tar.bz2).
+ *
+ * Three entry points:
+ *  - getBundledArchives(packName)    – Android PAD packs (STORAGE_FILES or APK_ASSETS)
+ *  - listBundledArchives(dirPath)    – any filesystem directory (cross-platform)
+ *  - extractArchive(archive, target) – unified extraction (auto-selects path or asset-stream)
+ *
+ * After extraction, use listModelsAtPath / autoModelPath from the main package.
+ */
+
+import { DeviceEventEmitter, Platform } from 'react-native';
+import { readDir, stat, exists } from '@dr.pogodin/react-native-fs';
+import SherpaOnnx from '../NativeSherpaOnnx';
+import { extractTarZst } from '../download/extractTarZst';
+import { extractTarBz2 } from '../download/extractTarBz2';
+import type {
+  BundledArchive,
+  ExtractArchiveOptions,
+  ExtractResult,
+  ExtractProgressEvent,
+} from './types';
+
+export type {
+  BundledArchive,
+  ExtractArchiveOptions,
+  ExtractResult,
+  ExtractProgressEvent,
+} from './types';
+
+// ── Constants & helpers ───────────────────────────────────────────
+
+const TAR_ZST = '.tar.zst';
+const TAR_BZ2 = '.tar.bz2';
+
+function formatFromFilename(name: string): 'tar.zst' | 'tar.bz2' | null {
+  if (name.endsWith(TAR_ZST)) return 'tar.zst';
+  if (name.endsWith(TAR_BZ2)) return 'tar.bz2';
+  return null;
+}
+
+function modelIdFromFilename(filename: string): string {
+  if (filename.endsWith(TAR_ZST)) return filename.slice(0, -TAR_ZST.length);
+  if (filename.endsWith(TAR_BZ2)) return filename.slice(0, -TAR_BZ2.length);
+  return filename;
+}
+
+/**
+ * Scan a filesystem directory for .tar.zst / .tar.bz2 entries.
+ * Shared by getBundledArchives (STORAGE_FILES) and listBundledArchives.
+ */
+async function scanDirectoryForArchives(
+  directoryPath: string
+): Promise<BundledArchive[]> {
+  const dirExists = await exists(directoryPath);
+  if (!dirExists) return [];
+
+  const entries = await readDir(directoryPath);
+  const archives: BundledArchive[] = [];
+
+  for (const entry of entries) {
+    const format = formatFromFilename(entry.name);
+    if (!format || !entry.isFile()) continue;
+
+    let fileSize = 0;
+    try {
+      const s = await stat(entry.path);
+      fileSize = s.size ?? 0;
+    } catch {
+      // stat may fail on some filesystems; fileSize stays 0
+    }
+
+    archives.push({
+      modelId: modelIdFromFilename(entry.name),
+      archivePath: entry.path,
+      format,
+      fileSize,
+    });
+  }
+
+  return archives;
+}
+
+// ── Public API ────────────────────────────────────────────────────
+
+/**
+ * List compressed archives delivered via a **Play Asset Delivery** pack.
+ *
+ * - **STORAGE_FILES** packs: scans the pack directory on the filesystem.
+ * - **APK_ASSETS** packs: queries the Android AssetManager for embedded archive paths.
+ *   Archives returned with `fromAsset: true` are extracted by streaming from the APK
+ *   (no temp copy needed).
+ * - **iOS / unavailable pack**: returns `null`.
+ *
+ * @param packName  Name of the PAD asset pack (e.g. `"sherpa_models"`)
+ */
+export async function getBundledArchives(
+  packName: string
+): Promise<BundledArchive[] | null> {
+  if (Platform.OS !== 'android') {
+    return null;
+  }
+
+  const packPath = await SherpaOnnx.getAssetPackPath(packName);
+
+  if (packPath != null && packPath.length > 0) {
+    const archives = await scanDirectoryForArchives(packPath);
+    return archives.length > 0 ? archives : null;
+  }
+
+  const assetPaths = await SherpaOnnx.listBundledArchiveAssetPaths(packName);
+  if (assetPaths.length === 0) return null;
+
+  return assetPaths.map((archivePath) => {
+    const filename = archivePath.split('/').pop() ?? archivePath;
+    const format = formatFromFilename(filename) ?? 'tar.zst';
+    return {
+      modelId: modelIdFromFilename(filename),
+      archivePath,
+      format,
+      fromAsset: true,
+    };
+  });
+}
+
+/**
+ * List `.tar.zst` and `.tar.bz2` archives in a filesystem directory.
+ *
+ * Works on **all platforms** — use for:
+ * - iOS main-bundle archives (`MainBundlePath + '/models'`)
+ * - Archives downloaded to the documents directory
+ * - Any other folder containing compressed model archives
+ *
+ * @param directoryPath  Absolute path to the directory to scan
+ */
+export async function listBundledArchives(
+  directoryPath: string
+): Promise<BundledArchive[]> {
+  return scanDirectoryForArchives(directoryPath);
+}
+
+/**
+ * Extract a single archive to the target directory.
+ *
+ * Handles both source types transparently:
+ * - **Filesystem archives** (from `listBundledArchives` or PAD STORAGE_FILES) —
+ *   uses the regular path-based extraction.
+ * - **APK asset archives** (`fromAsset: true`, from PAD APK_ASSETS) —
+ *   streams directly from the APK without copying the archive to disk first.
+ *
+ * @param archive    Descriptor returned by `getBundledArchives` or `listBundledArchives`
+ * @param targetPath Directory to extract into (e.g. `DocumentDirectoryPath + '/models'`)
+ * @param options    `force` (default `true`), `onProgress`, `signal` (AbortSignal)
+ */
+export async function extractArchive(
+  archive: BundledArchive,
+  targetPath: string,
+  options?: ExtractArchiveOptions
+): Promise<ExtractResult> {
+  const force = options?.force !== false;
+  const onProgress = options?.onProgress;
+  const signal = options?.signal;
+
+  if (signal?.aborted) {
+    const err = new Error('Extraction aborted');
+    err.name = 'AbortError';
+    throw err;
+  }
+
+  const useAssetStream =
+    Platform.OS === 'android' &&
+    (archive.fromAsset === true ||
+      archive.archivePath.startsWith('asset_packs/'));
+
+  if (useAssetStream) {
+    return extractFromAsset(archive, targetPath, force, onProgress, signal);
+  }
+
+  if (archive.format === 'tar.zst') {
+    return extractTarZst(
+      archive.archivePath,
+      targetPath,
+      force,
+      onProgress,
+      signal
+    );
+  }
+  return extractTarBz2(
+    archive.archivePath,
+    targetPath,
+    force,
+    onProgress,
+    signal
+  );
+}
+
+// ── Internal: asset-stream extraction (Android APK_ASSETS) ───────
+
+async function extractFromAsset(
+  archive: BundledArchive,
+  targetPath: string,
+  force: boolean,
+  onProgress?: (event: ExtractProgressEvent) => void,
+  signal?: AbortSignal
+): Promise<ExtractResult> {
+  const eventName =
+    archive.format === 'tar.zst'
+      ? 'extractTarZstProgress'
+      : 'extractTarBz2Progress';
+
+  let subscription: { remove: () => void } | null = null;
+  let removeAbortListener: (() => void) | null = null;
+
+  if (onProgress) {
+    subscription = DeviceEventEmitter.addListener(
+      eventName,
+      (event: ExtractProgressEvent & { sourcePath?: string }) => {
+        if (
+          event.sourcePath != null &&
+          event.sourcePath !== archive.archivePath
+        ) {
+          return;
+        }
+        const safePercent = Math.max(0, Math.min(100, event.percent));
+        onProgress({ ...event, percent: safePercent });
+      }
+    );
+  }
+
+  if (signal) {
+    const cancel =
+      archive.format === 'tar.zst'
+        ? SherpaOnnx.cancelExtractTarZst
+        : SherpaOnnx.cancelExtractTarBz2;
+    const onAbort = () => {
+      try {
+        cancel();
+      } catch {
+        // ignore
+      }
+    };
+    signal.addEventListener('abort', onAbort);
+    removeAbortListener = () => signal.removeEventListener('abort', onAbort);
+  }
+
+  try {
+    const result =
+      archive.format === 'tar.zst'
+        ? await SherpaOnnx.extractTarZstFromAsset(
+            archive.archivePath,
+            targetPath,
+            force
+          )
+        : await SherpaOnnx.extractTarBz2FromAsset(
+            archive.archivePath,
+            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/extraction/types.ts

@@ -0,0 +1,63 @@
+/**
+ * Types for the extraction subpath.
+ *
+ * A BundledArchive describes a compressed model archive (.tar.zst or .tar.bz2)
+ * that can come from two distinct sources:
+ *
+ *  1. **Filesystem** — a regular file on disk (PAD STORAGE_FILES, iOS bundle,
+ *     downloaded archive, etc.). `fromAsset` is absent or `false`.
+ *  2. **Android APK asset** — embedded in the APK via PAD APK_ASSETS.
+ *     `fromAsset` is `true`; extraction streams directly from the APK.
+ *
+ * The consumer does not need to distinguish between the two:
+ * `extractArchive()` handles both transparently.
+ */
+
+/** Describes one compressed model archive. */
+export type BundledArchive = {
+  /** Identifier derived from the archive filename (filename minus the extension). */
+  modelId: string;
+  /**
+   * Path to the archive.
+   * - Filesystem archives: absolute path (e.g. `/data/.../models/whisper-tiny.tar.zst`).
+   * - APK assets: asset path (e.g. `asset_packs/sherpa_models/assets/whisper-tiny.tar.zst`).
+   */
+  archivePath: string;
+  /** Compression format. */
+  format: 'tar.zst' | 'tar.bz2';
+  /** File size in bytes (available for filesystem archives; 0 or absent for APK assets). */
+  fileSize?: number;
+  /** `true` when the archive lives inside the APK (APK_ASSETS). Absent for filesystem archives. */
+  fromAsset?: boolean;
+};
+
+/** Progress event emitted during extraction. */
+export type ExtractProgressEvent = {
+  /** Bytes extracted so far. */
+  bytes: number;
+  /** Total bytes of the archive (may be 0 when unknown). */
+  totalBytes: number;
+  /** Progress percentage 0–100. */
+  percent: number;
+};
+
+/** Result returned by `extractArchive`. */
+export type ExtractResult = {
+  success: boolean;
+  /** Absolute path to the extracted directory (on success). */
+  path?: string;
+  /** SHA-256 hex digest of the source archive (when available). */
+  sha256?: string;
+  /** Error description (on failure). */
+  reason?: string;
+};
+
+/** Options for `extractArchive`. */
+export type ExtractArchiveOptions = {
+  /** Overwrite existing files. Defaults to `true`. */
+  force?: boolean;
+  /** Callback for extraction progress. */
+  onProgress?: (event: ExtractProgressEvent) => void;
+  /** AbortSignal to cancel the extraction. */
+  signal?: AbortSignal;
+};

package/src/index.tsx

@@ -22,6 +22,7 @@ export { copyFileToContentUri } from './tts';
 // - import { createSTT, createStreamingSTT, ... } from 'react-native-sherpa-onnx/stt'
 // - import { createTTS, ... } from 'react-native-sherpa-onnx/tts'
 // - import { ... } from 'react-native-sherpa-onnx/download'
+// - import { getBundledArchives, listBundledArchives, extractArchive } from 'react-native-sherpa-onnx/extraction'
 // - import { ... } from 'react-native-sherpa-onnx/vad' (planned)
 // - import { ... } from 'react-native-sherpa-onnx/diarization' (planned)
 // - import { ... } from 'react-native-sherpa-onnx/enhancement' (planned)

package/third_party/libarchive_prebuilt/ANDROID_RELEASE_TAG

@@ -1 +1 @@
-libarchive-android-v3.8.5-1
+libarchive-android-v3.8.5-2

package/third_party/libarchive_prebuilt/IOS_RELEASE_TAG

@@ -1 +1 @@
-libarchive-ios-v3.8.5-1
+libarchive-ios-v3.8.5-2