@remotion/whisper-web 4.0.302

package/dist/db/put-object.js

@@ -0,0 +1,18 @@
+import { openDb } from './open-db';
+export const putObject = async ({ key, value, }) => {
+    const objectStore = await openDb('readwrite');
+    return new Promise((resolve, reject) => {
+        try {
+            const putRq = objectStore.put(value, key);
+            putRq.onsuccess = () => {
+                resolve();
+            };
+            putRq.onerror = () => {
+                reject(new Error(`Failed to store "${key}" in IndexedDB`));
+            };
+        }
+        catch (e) {
+            reject(new Error(`Failed to store "${key}" in IndexedDB: ${e}`));
+        }
+    });
+};

package/dist/delete-model.d.ts

@@ -0,0 +1,2 @@
+import type { WhisperWebModel } from './constants';
+export declare const deleteModel: (model: WhisperWebModel) => Promise<void>;

package/dist/delete-model.js

@@ -0,0 +1,6 @@
+import { deleteObject } from './db/delete-object';
+import { getModelUrl } from './get-model-url';
+export const deleteModel = async (model) => {
+    const url = getModelUrl(model);
+    await deleteObject({ key: url });
+};

package/dist/download-model.d.ts

@@ -0,0 +1,5 @@
+export declare const fetchRemote: ({ url, onProgress, expectedLength, }: {
+    url: string;
+    onProgress: (progress: number) => void;
+    expectedLength: number;
+}) => Promise<Uint8Array<ArrayBuffer>>;

package/dist/download-model.js

@@ -0,0 +1,32 @@
+export const fetchRemote = async ({ url, onProgress, expectedLength, }) => {
+    //  start the fetch
+    const response = await fetch(url, { method: 'get' });
+    if (!response.ok || !response.body) {
+        throw new Error(`failed to fetch: ${url}`);
+    }
+    const contentLength = response.headers.get('content-length');
+    //  hugging face servers do include this header
+    const total = parseInt(contentLength, 10);
+    if (total !== expectedLength) {
+        throw new Error(`Content-Length header is ${total} for ${url} but expected ${expectedLength}`);
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let receivedLength = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        chunks.push(value);
+        receivedLength += value.length;
+        onProgress(receivedLength);
+    }
+    let position = 0;
+    const chunksAll = new Uint8Array(receivedLength);
+    for (const chunk of chunks) {
+        chunksAll.set(chunk, position);
+        position += chunk.length;
+    }
+    return chunksAll;
+};

package/dist/download-whisper-model.d.ts

@@ -0,0 +1,15 @@
+import { type WhisperWebModel } from './constants';
+export type DownloadWhisperModelProgress = {
+    downloadedBytes: number;
+    totalBytes: number;
+    progress: number;
+};
+export type DownloadWhisperModelOnProgress = (progress: DownloadWhisperModelProgress) => void;
+export interface DownloadWhisperModelParams {
+    model: WhisperWebModel;
+    onProgress: DownloadWhisperModelOnProgress;
+}
+export type DownloadWhisperModelResult = {
+    alreadyDownloaded: boolean;
+};
+export declare const downloadWhisperModel: ({ model, onProgress, }: DownloadWhisperModelParams) => Promise<DownloadWhisperModelResult>;

package/dist/download-whisper-model.js

@@ -0,0 +1,48 @@
+import { canUseWhisperWeb } from './can-use-whisper-web';
+import { MODELS, SIZES } from './constants';
+import { getObject } from './db/get-object-from-db';
+import { putObject } from './db/put-object';
+import { fetchRemote } from './download-model';
+import { getModelUrl } from './get-model-url';
+export const downloadWhisperModel = async ({ model, onProgress, }) => {
+    if (!model || !MODELS.includes(model)) {
+        throw new Error(`Invalid model name: ${model}. Supported models: ${MODELS.join(', ')}.`);
+    }
+    const usabilityCheck = await canUseWhisperWeb(model);
+    if (!usabilityCheck.supported) {
+        return Promise.reject(new Error(`Whisper.wasm is not supported in this environment. Reason: ${usabilityCheck.detailedReason}`));
+    }
+    const url = getModelUrl(model);
+    const modelSize = SIZES[model];
+    const existingModel = await getObject({ key: url });
+    if (existingModel) {
+        onProgress({
+            downloadedBytes: modelSize,
+            totalBytes: modelSize,
+            progress: 1,
+        });
+        return {
+            alreadyDownloaded: true,
+        };
+    }
+    const data = await fetchRemote({
+        url,
+        onProgress: (bytes) => {
+            onProgress({
+                downloadedBytes: bytes,
+                progress: bytes / modelSize,
+                totalBytes: modelSize,
+            });
+        },
+        expectedLength: modelSize,
+    });
+    onProgress({
+        downloadedBytes: modelSize,
+        totalBytes: modelSize,
+        progress: 1,
+    });
+    await putObject({ key: url, value: data });
+    return {
+        alreadyDownloaded: false,
+    };
+};