@vidtreo/recorder 1.7.1 → 1.7.3

package/dist/index.d.ts

@@ -1,3 +1,9 @@
+export type RecoverPendingUploadOptions = {
+    match: PendingUploadMatch;
+    onProgress?: (progress: number) => void;
+};
+export declare function recoverPendingUpload(options: RecoverPendingUploadOptions): Promise<VideoUploadResult | null>;
+
 export type VideoUploadOptions = {
     apiKey: string;
     backendUrl: string;
@@ -35,6 +41,10 @@ type UploadCallbacks = {
     onUploadComplete?: (id: string, result: VideoUploadResult) => void;
     onUploadError?: (id: string, error: Error) => void;
 };
+export type PendingUploadMatch = {
+    metadata?: Record<string, unknown>;
+    userMetadata?: Record<string, unknown>;
+};
 export declare class UploadQueueManager {
     private readonly storageService;
     private readonly uploadService;
@@ -50,6 +60,7 @@ export declare class UploadQueueManager {
     queueUpload(upload: Omit<PendingUpload, "id" | "createdAt" | "updatedAt" | "status" | "retryCount">): Promise<string>;
     processQueue(): Promise<void>;
     getPendingUploads(): Promise<PendingUpload[]>;
+    processMatchingUpload(match: PendingUploadMatch): Promise<VideoUploadResult | null>;
     getStats(): Promise<{
         pending: number;
         uploading: number;
@@ -58,6 +69,10 @@ export declare class UploadQueueManager {
     }>;
     private getOldestUpload;
     private getOldestFailedUpload;
+    private recoverStaleUploads;
+    private getOldestMatchingUpload;
+    private canProcessMatchingUpload;
+    private matchesMetadata;
     private processUpload;
     private calculateRetryDelay;
     private scheduleRetry;
@@ -1936,6 +1951,7 @@ type AudioCodecCheckOptions = {
     sampleRate?: number;
 };
 type MediabunnyModule = {
+    canEncodeAudio?: (codec: AudioCodec, options: AudioCodecCheckOptions) => Promise<boolean>;
     canEncodeVideo?: (codec: VideoCodec, options: VideoCodecCheckOptions) => Promise<boolean>;
     getFirstEncodableAudioCodec?: (codecs: AudioCodec[], options: AudioCodecCheckOptions) => Promise<string | null>;
 };

package/dist/index.js

@@ -1762,15 +1762,17 @@ async function resolveVideoCodecFromPolicy(options) {
   }
   throw createVideoCodecUnavailableError(options.format, candidates, probeErrors);
 }
+function resolveUnavailableAudioCodec(options) {
+  if (options.shouldThrowIfNoCodecAvailable) {
+    throw new Error(`No encodable audio codec available for format: ${options.format}`);
+  }
+  return options.policy.preferredAudioCodec;
+}
 async function resolveAudioCodecFromPolicy(options) {
   const dependencies = resolveCodecPolicyResolverDependencies(options.dependencies);
   const mediabunnyModule = await dependencies.loadMediabunnyModule();
   if (mediabunnyModule === null) {
-    return options.policy.preferredAudioCodec;
-  }
-  const getFirstEncodableAudioCodec = mediabunnyModule.getFirstEncodableAudioCodec;
-  if (typeof getFirstEncodableAudioCodec !== "function") {
-    return options.policy.preferredAudioCodec;
+    return resolveUnavailableAudioCodec(options);
   }
   const candidates = buildAudioCandidates(options.overrideCodec, options.policy);
   const audioCodecOptions = {};
@@ -1783,28 +1785,40 @@ async function resolveAudioCodecFromPolicy(options) {
   if (options.sampleRate !== undefined) {
     audioCodecOptions.sampleRate = options.sampleRate;
   }
+  const canEncodeAudio = mediabunnyModule.canEncodeAudio;
+  if (typeof canEncodeAudio === "function") {
+    for (const candidate of candidates) {
+      const candidateProbeResults = await Promise.allSettled([
+        canEncodeAudio(candidate, audioCodecOptions)
+      ]);
+      const candidateProbeResult = candidateProbeResults[FIRST_RESULT_INDEX];
+      const isCandidateSupported = candidateProbeResult.status === "fulfilled" && candidateProbeResult.value;
+      if (isCandidateSupported) {
+        return candidate;
+      }
+    }
+    return resolveUnavailableAudioCodec(options);
+  }
+  const getFirstEncodableAudioCodec = mediabunnyModule.getFirstEncodableAudioCodec;
+  if (typeof getFirstEncodableAudioCodec !== "function") {
+    return resolveUnavailableAudioCodec(options);
+  }
   const probeResults = await Promise.allSettled([
     getFirstEncodableAudioCodec(candidates, audioCodecOptions)
   ]);
   const firstProbeResult = probeResults[FIRST_RESULT_INDEX];
   if (firstProbeResult.status === "rejected") {
-    return options.policy.preferredAudioCodec;
+    return resolveUnavailableAudioCodec(options);
   }
   const resolvedCodec = firstProbeResult.value;
   if (resolvedCodec === null) {
-    if (options.shouldThrowIfNoCodecAvailable) {
-      throw new Error(`No encodable audio codec available for format: ${options.format}`);
-    }
-    return options.policy.preferredAudioCodec;
+    return resolveUnavailableAudioCodec(options);
   }
   const canUseResolvedCodec = candidates.includes(resolvedCodec);
   if (canUseResolvedCodec) {
     return resolvedCodec;
   }
-  if (options.shouldThrowIfNoCodecAvailable) {
-    throw new Error(`No encodable audio codec available for format: ${options.format}`);
-  }
-  return options.policy.preferredAudioCodec;
+  return resolveUnavailableAudioCodec(options);
 }
 
 // src/core/transcode/output-format.ts
@@ -6305,7 +6319,7 @@ function resolveDeviceError(input) {
 // package.json
 var package_default = {
   name: "@vidtreo/recorder",
-  version: "1.7.1",
+  version: "1.7.3",
   type: "module",
   description: "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   main: "./dist/index.js",
@@ -7056,13 +7070,7 @@ class UploadQueueManager {
       if (!this.storageService.isInitialized()) {
         throw new Error("Database not initialized");
       }
-      if (!this.hasRecoveredStaleUploads) {
-        const staleUploads = await this.storageService.getPendingUploads("uploading");
-        await Promise.all(staleUploads.map((upload) => this.storageService.updateUploadStatus(upload.id, {
-          status: "pending"
-        })));
-        this.hasRecoveredStaleUploads = true;
-      }
+      await this.recoverStaleUploads();
       const pendingUploads = await this.storageService.getPendingUploads("pending");
       if (pendingUploads.length > 0) {
         const upload = this.getOldestUpload(pendingUploads);
@@ -7096,6 +7104,27 @@ class UploadQueueManager {
   getPendingUploads() {
     return this.storageService.getPendingUploads();
   }
+  async processMatchingUpload(match) {
+    if (this.isProcessing) {
+      return null;
+    }
+    this.isProcessing = true;
+    try {
+      await this.recoverStaleUploads();
+      const uploads = await this.storageService.getPendingUploads();
+      const matchingUpload = this.getOldestMatchingUpload(uploads, match);
+      if (!matchingUpload) {
+        this.isProcessing = false;
+        return null;
+      }
+      const result = await this.processUpload(matchingUpload, true);
+      this.isProcessing = false;
+      return result;
+    } catch (error) {
+      this.isProcessing = false;
+      throw new Error(`Error processing matching upload: ${extractErrorMessage(error)}`);
+    }
+  }
   async getStats() {
     const all = await this.storageService.getPendingUploads();
     const stats = {
@@ -7127,7 +7156,45 @@ class UploadQueueManager {
     }
     return uploads.sort((a, b) => a.updatedAt - b.updatedAt)[0];
   }
-  async processUpload(upload) {
+  async recoverStaleUploads() {
+    if (this.hasRecoveredStaleUploads) {
+      return;
+    }
+    const staleUploads = await this.storageService.getPendingUploads("uploading");
+    await Promise.all(staleUploads.map((upload) => this.storageService.updateUploadStatus(upload.id, {
+      status: "pending"
+    })));
+    this.hasRecoveredStaleUploads = true;
+  }
+  getOldestMatchingUpload(uploads, match) {
+    const matchingUploads = uploads.filter((upload) => this.canProcessMatchingUpload(upload, match));
+    if (matchingUploads.length === 0) {
+      return null;
+    }
+    return matchingUploads.sort((a, b) => a.createdAt - b.createdAt)[0];
+  }
+  canProcessMatchingUpload(upload, match) {
+    if (upload.status === "completed") {
+      return false;
+    }
+    if (upload.status === "failed" && upload.retryCount >= MAX_RETRIES2) {
+      return false;
+    }
+    if (!this.matchesMetadata(upload.metadata, match.metadata)) {
+      return false;
+    }
+    return this.matchesMetadata(upload.userMetadata, match.userMetadata);
+  }
+  matchesMetadata(actual, expected) {
+    if (!expected || Object.keys(expected).length === 0) {
+      return true;
+    }
+    if (!actual) {
+      return false;
+    }
+    return Object.entries(expected).every(([key, value]) => actual[key] === value);
+  }
+  async processUpload(upload, shouldThrowOnError = false) {
     try {
       await this.storageService.updateUploadStatus(upload.id, {
         status: "uploading"
@@ -7145,6 +7212,7 @@ class UploadQueueManager {
       });
       await this.storageService.deleteUpload(upload.id);
       this.callbacks.onUploadComplete?.(upload.id, result);
+      return result;
     } catch (error) {
       const errorMessage = extractErrorMessage(error);
       const retryCount = upload.retryCount + 1;
@@ -7159,6 +7227,10 @@ class UploadQueueManager {
         const delay2 = this.calculateRetryDelay(retryCount);
         this.scheduleRetry(delay2);
       }
+      if (shouldThrowOnError) {
+        throw new Error(errorMessage);
+      }
+      return null;
     }
   }
   calculateRetryDelay(retryCount) {
@@ -21742,7 +21814,8 @@ class WorkerProcessor {
       policy,
       bitrate: audioBitrate,
       numberOfChannels: audioConfig?.numberOfChannels,
-      sampleRate: audioConfig?.sampleRate
+      sampleRate: audioConfig?.sampleRate,
+      shouldThrowIfNoCodecAvailable: audioConfig !== null
     });
   }
   async resolveVideoCodec(config, format, policy) {
@@ -23899,6 +23972,23 @@ class QuotaManager {
     return quota.percentage >= threshold;
   }
 }
+// src/core/upload/pending-upload-recovery.ts
+async function recoverPendingUpload(options) {
+  const storageService = new VideoStorageService;
+  await storageService.init();
+  const uploadService = new VideoUploadService;
+  const uploadQueueManager = new UploadQueueManager(storageService, uploadService);
+  uploadQueueManager.setCallbacks({
+    onUploadProgress: (_id, progress) => {
+      options.onProgress?.(progress);
+    }
+  });
+  try {
+    return await uploadQueueManager.processMatchingUpload(options.match);
+  } finally {
+    uploadQueueManager.destroy();
+  }
+}
 // src/core/utils/audio-utils.ts
 function calculateBarColor(position) {
   if (position < 0.25) {
@@ -24294,6 +24384,7 @@ export {
   requireInitialized,
   requireDefined,
   requireActive,
+  recoverPendingUpload,
   parseBrowserErrorLinkContent,
   mapPresetToConfig,
   logger,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vidtreo/recorder",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "type": "module",
   "description": "Vidtreo SDK for browser-based video recording and transcoding. Features include camera/screen recording, real-time MP4 transcoding, audio level analysis, mute/pause controls, source switching, device selection, and automatic backend uploads. Similar to Ziggeo and Addpipe, Vidtreo provides enterprise-grade video processing capabilities for web applications.",
   "main": "./dist/index.js",