react-native-sherpa-onnx 0.3.6 → 0.3.8

package/src/download/activeModelOperations.ts

@@ -0,0 +1,38 @@
+import type { ModelCategory } from './types';
+
+/** Ref-count map keyed by `category:modelId`. A key is "active" (protected
+ *  from bulk delete) as long as its count is > 0, which allows multiple
+ *  concurrent post-download operations on the same model to coexist safely. */
+const activePostProcessCounts = new Map<string, number>();
+
+export function makeModelOperationKey(
+  category: ModelCategory,
+  modelId: string
+): string {
+  return `${category}:${modelId}`;
+}
+
+export function registerActivePostProcess(
+  category: ModelCategory,
+  modelId: string
+): void {
+  const key = makeModelOperationKey(category, modelId);
+  activePostProcessCounts.set(key, (activePostProcessCounts.get(key) ?? 0) + 1);
+}
+
+export function unregisterActivePostProcess(
+  category: ModelCategory,
+  modelId: string
+): void {
+  const key = makeModelOperationKey(category, modelId);
+  const count = activePostProcessCounts.get(key) ?? 0;
+  if (count <= 1) {
+    activePostProcessCounts.delete(key);
+  } else {
+    activePostProcessCounts.set(key, count - 1);
+  }
+}
+
+export function getActivePostProcessKeys(): ReadonlySet<string> {
+  return new Set(activePostProcessCounts.keys());
+}

package/src/download/background-downloader-types.ts

@@ -0,0 +1,73 @@
+/**
+ * Compile-time shim for @kesha-antonov/react-native-background-downloader.
+ *
+ * The package currently ships TS sources without distributable .d.ts files.
+ * We route TS path resolution to this shim so the SDK can typecheck strictly
+ * without checking third-party TS internals.
+ */
+
+export interface BackgroundDownloaderNotificationTexts {
+  downloadTitle?: string;
+  downloadStarting?: string;
+  downloadProgress?: string;
+  downloadPaused?: string;
+  downloadFinished?: string;
+  groupTitle?: string;
+  groupText?: string | ((count: number) => string);
+}
+
+export type BackgroundDownloaderSetConfigOptions = {
+  showNotificationsEnabled?: boolean;
+  notificationsGrouping?: {
+    enabled?: boolean;
+    mode?: 'individual' | 'summaryOnly';
+    texts?: BackgroundDownloaderNotificationTexts;
+  };
+  headers?: Record<string, string>;
+  progressInterval?: number;
+  progressMinBytes?: number;
+  isLogsEnabled?: boolean;
+  maxParallelDownloads?: number;
+  allowsCellularAccess?: boolean;
+};
+
+export interface DownloadTask {
+  id: string;
+  start(): void;
+  stop(): void;
+  pause(): Promise<void>;
+  resume(): Promise<void>;
+  begin(
+    cb: (data: {
+      expectedBytes?: number;
+      headers?: Record<string, string>;
+    }) => void
+  ): DownloadTask;
+  progress(
+    cb: (data: { bytesDownloaded: number; bytesTotal: number }) => void
+  ): DownloadTask;
+  done(
+    cb: (data: {
+      location?: string;
+      bytesDownloaded: number;
+      bytesTotal: number;
+    }) => void
+  ): DownloadTask;
+  error(
+    cb: (data: { error?: string; errorCode?: number }) => void
+  ): DownloadTask;
+}
+
+export declare function setConfig(
+  options: BackgroundDownloaderSetConfigOptions
+): void;
+
+export declare function createDownloadTask(options: {
+  id: string;
+  url: string;
+  destination: string;
+  metadata?: Record<string, unknown>;
+}): DownloadTask;
+
+export declare function completeHandler(taskId: string): void;
+export declare function getExistingDownloadTasks(): Promise<DownloadTask[]>;

package/src/download/bulkPurge.ts

@@ -0,0 +1,102 @@
+import { exists, unlink } from '@dr.pogodin/react-native-fs';
+import { CATEGORY_CONFIG, getArchivePath } from './paths';
+import type { ModelCategory, ModelMetaBase } from './types';
+import { makeModelOperationKey } from './activeModelOperations';
+import { getProtectedModelKeysForBulkDelete } from './protectedModelKeys';
+import {
+  deleteModelByCategory,
+  listDownloadedModelsByCategory,
+} from './localModels';
+import {
+  deleteIncompleteDownload,
+  getIncompleteDownloads,
+} from './downloadTask';
+import {
+  deleteIncompleteExtraction,
+  getIncompleteExtractions,
+} from './modelExtraction';
+
+function allModelCategories(): ModelCategory[] {
+  return Object.keys(CATEGORY_CONFIG) as ModelCategory[];
+}
+
+export type PurgeDownloadedModelArtifactsResult = {
+  deletedComplete: number;
+  deletedIncompleteDownloads: number;
+  deletedIncompleteExtractions: number;
+  skippedProtected: number;
+};
+
+/**
+ * Deletes completed downloads, incomplete downloads, and incomplete extractions for every
+ * {@link ModelCategory}, except keys in `protectKeys` (or current {@link getProtectedModelKeysForBulkDelete}).
+ */
+export async function purgeDownloadedModelArtifacts(opts?: {
+  protectKeys?: ReadonlySet<string>;
+}): Promise<PurgeDownloadedModelArtifactsResult> {
+  const protect =
+    opts?.protectKeys ?? (await getProtectedModelKeysForBulkDelete());
+  const result: PurgeDownloadedModelArtifactsResult = {
+    deletedComplete: 0,
+    deletedIncompleteDownloads: 0,
+    deletedIncompleteExtractions: 0,
+    skippedProtected: 0,
+  };
+
+  const categories = allModelCategories();
+
+  for (const category of categories) {
+    const downloaded = await listDownloadedModelsByCategory<ModelMetaBase>(
+      category
+    );
+    for (const m of downloaded) {
+      const key = makeModelOperationKey(category, m.id);
+      if (protect.has(key)) {
+        result.skippedProtected += 1;
+        continue;
+      }
+      await deleteModelByCategory(category, m.id);
+      result.deletedComplete += 1;
+    }
+  }
+
+  for (const category of categories) {
+    const incomplete = await getIncompleteDownloads(category);
+    for (const s of incomplete) {
+      const key = makeModelOperationKey(category, s.modelId);
+      if (protect.has(key)) {
+        result.skippedProtected += 1;
+        continue;
+      }
+      await deleteIncompleteDownload(category, s.modelId);
+      result.deletedIncompleteDownloads += 1;
+    }
+  }
+
+  for (const category of categories) {
+    const extractions = await getIncompleteExtractions(category);
+    for (const e of extractions) {
+      const key = makeModelOperationKey(category, e.modelId);
+      if (protect.has(key)) {
+        result.skippedProtected += 1;
+        continue;
+      }
+      await deleteIncompleteExtraction(category, e.modelId);
+      try {
+        const archivePath = getArchivePath(
+          category,
+          e.modelId,
+          e.model.archiveExt
+        );
+        if (await exists(archivePath)) {
+          await unlink(archivePath);
+        }
+      } catch {
+        // non-fatal
+      }
+      result.deletedIncompleteExtractions += 1;
+    }
+  }
+
+  return result;
+}

package/src/download/checksumPrompt.ts

@@ -0,0 +1,25 @@
+import { Alert } from 'react-native';
+import type { ChecksumIssue } from './types';
+
+export function promptChecksumFallback(issue: ChecksumIssue): Promise<boolean> {
+  return new Promise((resolve) => {
+    const reasonText =
+      issue.reason === 'CHECKSUM_FAILED'
+        ? 'Failed to compute checksum.'
+        : 'Computed checksum does not match the expected value.';
+    const body = `${reasonText}\n\n${issue.message}\n\nDo you want to keep the file and continue?`;
+
+    Alert.alert('Checksum Problem', body, [
+      {
+        text: 'Delete and cancel',
+        style: 'destructive',
+        onPress: () => resolve(false),
+      },
+      {
+        text: 'Keep file',
+        style: 'default',
+        onPress: () => resolve(true),
+      },
+    ]);
+  });
+}

package/src/download/constants.ts

@@ -0,0 +1,5 @@
+export const RELEASE_API_BASE =
+  'https://api.github.com/repos/k2-fsa/sherpa-onnx/releases/tags';
+export const CACHE_TTL_MINUTES = 24 * 60;
+export const MODEL_ARCHIVE_EXT = '.tar.bz2';
+export const MODEL_ONNX_EXT = '.onnx';

package/src/download/downloadEvents.ts

@@ -0,0 +1,55 @@
+import type {
+  ModelCategory,
+  ModelMetaBase,
+  DownloadProgress,
+  DownloadProgressListener,
+  ModelsListUpdatedListener,
+} from './types';
+
+const downloadProgressListeners = new Set<DownloadProgressListener>();
+const modelsListUpdatedListeners = new Set<ModelsListUpdatedListener>();
+
+export const subscribeDownloadProgress = (
+  listener: DownloadProgressListener
+): (() => void) => {
+  downloadProgressListeners.add(listener);
+  return () => {
+    downloadProgressListeners.delete(listener);
+  };
+};
+
+export const subscribeModelsListUpdated = (
+  listener: ModelsListUpdatedListener
+): (() => void) => {
+  modelsListUpdatedListeners.add(listener);
+  return () => {
+    modelsListUpdatedListeners.delete(listener);
+  };
+};
+
+export function emitDownloadProgress(
+  category: ModelCategory,
+  modelId: string,
+  progress: DownloadProgress
+): void {
+  for (const listener of downloadProgressListeners) {
+    try {
+      listener(category, modelId, progress);
+    } catch (error) {
+      console.warn('Download progress listener error:', error);
+    }
+  }
+}
+
+export function emitModelsListUpdated(
+  category: ModelCategory,
+  models: ModelMetaBase[]
+): void {
+  for (const listener of modelsListUpdatedListeners) {
+    try {
+      listener(category, models);
+    } catch (error) {
+      console.warn('Models list listener error:', error);
+    }
+  }
+}