more fixes

Author: NellowTCS

Build/src/helpers/filePickerHelper.tsx

@@ -502,7 +502,8 @@ export async function extractAudioMetadata(file: File): Promise<AudioMetadata> {
       // Process album art if available
       let albumArt: string | undefined = undefined;
       if (cover && cover.data && cover.data.length > 0) {
-        const blob = new Blob([cover.data], { type: cover.mime_type });
+        const uint8Array = new Uint8Array(cover.data);
+        const blob = new Blob([uint8Array], { type: cover.mime_type });
         albumArt = await new Promise<string>((resolve, reject) => {
           const reader = new FileReader();
           reader.onloadend = () => resolve(reader.result as string);
@@ -569,14 +570,14 @@ export async function extractAudioMetadata(file: File): Promise<AudioMetadata> {
     }
   }
   // Fallback to original (music-metadata) for all other formats
-  let MetadataWorkerType: typeof Worker;
+  let MetadataWorkerType: new () => Worker;
   if (typeof __IS_SINGLE_FILE__ !== "undefined" && __IS_SINGLE_FILE__) {
     MetadataWorkerType = (
       await import("../workers/metadataWorker.ts?worker&inline")
-    ).default;
+    ).default as new () => Worker;
   } else {
-    MetadataWorkerType = (await import("../workers/metadataWorker.ts?worker"))
-      .default;
+    MetadataWorkerType = ((await import("../workers/metadataWorker.ts?worker"))
+      .default as new () => Worker);
   }
   const worker = new MetadataWorkerType();
 

Build/src/helpers/importAudioFiles.tsx

@@ -46,7 +46,8 @@ export async function importAudioFiles(
               // Safari: Pre-decode to WAV for compatibility
               const { decodeFloToWav } = await import("./refloWavHelper");
               const wavBytes = await decodeFloToWav(arrayBuffer);
-              const wavBlob = new Blob([wavBytes], { type: "audio/wav" });
+              const wavArray = new Uint8Array(wavBytes);
+              const wavBlob = new Blob([wavArray], { type: "audio/wav" });
               processedFile = new File(
                 [wavBlob],
                 file.name.replace(/\.flo$/i, ".wav"),

Build/tests/__mocks__/browser.ts

@@ -1,67 +1,100 @@
-class MockGainNode {
-  gain = { value: 1 };
-  disconnect() {}
-  connect() {
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+declare const global: any;
+
+const MockGainNode: any = {
+  gain: { value: 1 },
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  connect(..._args: any[]): any {
     return this;
-  }
-}
+  },
+  disconnect(): void {},
+};
 
-class MockAudioContext {
-  sampleRate = 44100;
-  baseLatency = 0;
-  close() {
-    return Promise.resolve();
-  }
-  createGain() {
-    return new MockGainNode();
-  }
-  createBufferSource() {
-    return {
-      buffer: null,
-      connect: () => {},
-      start: () => {},
-      stop: () => {},
-      onended: null,
-      disconnect: () => {},
-    };
-  }
-  createBuffer(channels: number, length: number, sampleRate: number) {
-    return {
-      numberOfChannels: channels,
-      length,
-      sampleRate,
-      duration: length / sampleRate,
-      getChannelData: () => new Float32Array(length),
-    };
-  }
-  decodeAudioData(buffer: ArrayBuffer) {
-    return Promise.resolve(this.createBuffer(2, 44100, 44100));
-  }
-  destination = {};
+function MockAudioContext(this: any): void {
+  this.sampleRate = 44100;
+  this.baseLatency = 0;
+  this.destination = {};
 }
 
-class MockAudio {
-  src = "";
-  currentTime = 0;
-  duration = 0;
-  paused = true;
-  volume = 1;
-  playbackRate = 1;
-  readyState = 4;
-  HAVE_ENOUGH_DATA = 4;
+MockAudioContext.prototype.close = function(): Promise<void> {
+  return Promise.resolve();
+};
+
+MockAudioContext.prototype.createGain = function(): any {
+  return MockGainNode;
+};
+
+MockAudioContext.prototype.createBuffer = function(
+  channels: number,
+  length: number,
+  sampleRate: number
+): any {
+  return {
+    numberOfChannels: channels,
+    length,
+    sampleRate,
+    duration: length / sampleRate,
+    getChannelData: () => new Float32Array(length),
+  };
+};
+
+MockAudioContext.prototype.createBufferSource = function(): any {
+  return {
+    buffer: null,
+    connect: () => {},
+    disconnect: () => {},
+    start: () => {},
+    stop: () => {},
+  };
+};
 
-  play() {
-    return Promise.resolve();
-  }
-  pause() {}
-  load() {}
-  addEventListener(_event: string, _callback: () => void) {}
-  removeEventListener(_event: string, _callback: () => void) {}
-  dispatchEvent(_event: unknown) {
-    return true;
-  }
+MockAudioContext.prototype.decodeAudioData = function(
+  buffer: ArrayBuffer,
+  successCallback?: (decoded: any) => void,
+  errorCallback?: (error: any) => void
+): Promise<any> {
+  const decoded = this.createBuffer(2, 44100, 44100);
+  successCallback?.(decoded);
+  return Promise.resolve(decoded).catch((err) => {
+    errorCallback?.(err);
+    throw err;
+  });
+};
+
+const listeners = new Map<string, Set<any>>();
+
+function MockAudio(this: any): void {
+  this.src = "";
+  this.currentTime = 0;
+  this.duration = 0;
+  this.paused = true;
+  this.volume = 1;
+  this.playbackRate = 1;
+  this.readyState = 4;
+  this.HAVE_ENOUGH_DATA = 4;
 }
 
-(global as unknown as { AudioContext: typeof AudioContext }).AudioContext = MockAudioContext as unknown as typeof AudioContext;
-(global as unknown as { webkitAudioContext: typeof AudioContext }).webkitAudioContext = MockAudioContext as unknown as typeof AudioContext;
-(global as unknown as { Audio: typeof Audio }).Audio = MockAudio as unknown as typeof Audio;
+MockAudio.prototype.play = function(): Promise<void> {
+  return Promise.resolve();
+};
+MockAudio.prototype.pause = function(): void {};
+MockAudio.prototype.load = function(): void {};
+
+MockAudio.prototype.addEventListener = function(event: string, callback: any): void {
+  if (!listeners.has(event)) listeners.set(event, new Set());
+  listeners.get(event)!.add(callback);
+};
+
+MockAudio.prototype.removeEventListener = function(event: string, callback: any): void {
+  listeners.get(event)?.delete(callback);
+};
+
+MockAudio.prototype.dispatchEvent = function(event: any): boolean {
+  listeners.get(event.type)?.forEach((listener) => listener());
+  return true;
+};
+
+(global as any).AudioContext = MockAudioContext;
+(global as any).webkitAudioContext = MockAudioContext;
+(global as any).Audio = MockAudio;