So much moreeeeeee

Author: NellowTCS

Build/jest.config.js Build/jest.config.cjsBuild/jest.config.js renamed to Build/jest.config.cjs

@@ -71,8 +71,6 @@
     "zustand": "^5.0.12"
   },
   "devDependencies": {
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
     "@tauri-apps/cli": "^2.10.1",
     "@types/jasmine": "^6.0.0",
     "@types/jest": "^30.0.0",
@@ -88,8 +86,10 @@
     "cross-env": "^10.1.0",
     "eslint": "^9.39.4",
     "eslint-plugin-react": "^7.37.5",
+    "jest": "^29.7.0",
     "npm-check-updates": "^19.6.3",
     "prettier": "^3.8.1",
+    "ts-jest": "^29.1.2",
     "vite": "^7.3.1",
     "vite-plugin-pwa": "^1.2.0",
     "vite-plugin-top-level-await": "^1.6.0",

Build/package-lock.json

@@ -9,24 +9,9 @@ import type {
 } from "./types";
 import { KomorebiEvents } from "./events";
 import { StateMachine } from "./state";
-import { QueueManager } from "./queue";
-import { Scheduler, CrossfadeScheduler, GaplessScheduler } from "./scheduler";
-
-export interface IAudioBackend {
-  load(url: string): Promise<void>;
-  play(): Promise<void>;
-  pause(): void;
-  stop(): void;
-  seek(time: number): void;
-  setVolume(volume: number): void;
-  setPlaybackRate(rate: number): void;
-  getCurrentTime(): number;
-  getDuration(): number;
-  onTimeUpdate(callback: (time: number) => void): void;
-  onEnded(callback: () => void): void;
-  onError(callback: (error: Error) => void): void;
-  dispose(): void;
-}
+import { QueueManager, type WeightedRandomizer, type ShuffleMode } from "./queue";
+import { Scheduler } from "./scheduler";
+import type { IAudioBackend } from "../../platform/audio";
 
 export interface IAudioEngineConfig {
   crossfade: {
@@ -113,6 +98,22 @@ export class KomorebiEngine {
     });
   }
 
+  setWeightedRandomizer(randomizer: WeightedRandomizer | null): void {
+    this.queue.setWeightedRandomizer(randomizer);
+    if (this.settings.smartShuffle) {
+      this.queue.setShuffleMode("smart");
+    }
+  }
+
+  setShuffleMode(mode: ShuffleMode): void {
+    this.queue.setShuffleMode(mode);
+    this.settings.smartShuffle = mode === "smart";
+  }
+
+  getShuffleMode(): ShuffleMode {
+    return this.queue.getShuffleMode();
+  }
+
   load(track: Track, playlist?: Playlist): void {
     if (!this.backend) {
       this.emitError("NO_BACKEND", "No audio backend configured");
@@ -390,14 +391,14 @@ export class KomorebiEngine {
 
   private async loadAndPlay(track: Track): Promise<void> {
     return new Promise((resolve, reject) => {
-      const onLoad = () => {
-        this.backend?.off("ended", onLoad);
+      const onEndedHandler = () => {
+        this.backend?.offEnded(onEndedHandler);
         this.play()
           .then(resolve)
           .catch(reject);
       };
 
-      this.backend?.on("ended", onLoad);
+      this.backend?.onEnded(onEndedHandler);
       this.load(track);
     });
   }
@@ -452,7 +453,7 @@ export class KomorebiEngine {
     }
   }
 
-  private scheduleTransition(track: Track): void {
+  private scheduleTransition(_track: Track): void {
     if (this.scheduledTransitionId !== null) return;
 
     this.stateMachine.transition("transitioning");

Build/package.json

@@ -4,7 +4,7 @@ export * from "./engine";
 export { StateMachine } from "./state";
 export { QueueManager } from "./queue";
 export { Scheduler, CrossfadeScheduler, GaplessScheduler } from "./scheduler";
-export type { IAudioBackend } from "./engine";
+export type { IAudioBackend } from "../../platform/audio";
 export type {
   ScheduledTransition,
   TransitionCurve,

Build/src/core/engine/engine.ts

@@ -1,5 +1,11 @@
 import type { Track, Playlist, QueueState, PlayHistory } from "../types";
 
+export type ShuffleMode = "random" | "smart";
+
+export interface WeightedRandomizer {
+  getWeightedRandomTrack(trackIds: string[]): string | null;
+}
+
 export class QueueManager {
   private state: QueueState = {
     tracks: [],
@@ -10,6 +16,20 @@ export class QueueManager {
 
   private history: Map<string, PlayHistory> = new Map();
   private maxHistorySize = 1000;
+  private weightedRandomizer: WeightedRandomizer | null = null;
+  private shuffleMode: ShuffleMode = "random";
+
+  setWeightedRandomizer(randomizer: WeightedRandomizer | null): void {
+    this.weightedRandomizer = randomizer;
+  }
+
+  getShuffleMode(): ShuffleMode {
+    return this.shuffleMode;
+  }
+
+  setShuffleMode(mode: ShuffleMode): void {
+    this.shuffleMode = mode;
+  }
 
   setPlaylist(playlist: Playlist | null, preserveCurrent = true): void {
     if (!playlist) {
@@ -59,7 +79,7 @@ export class QueueManager {
     return [...this.state.shuffleOrder];
   }
 
-  getNextIndex(smartShuffle: boolean): number {
+  getNextIndex(_smartShuffle: boolean): number {
     const order = this.getPlayOrder();
     const currentPos = order.indexOf(this.state.currentIndex);
 
@@ -75,7 +95,7 @@ export class QueueManager {
     return order[nextPos];
   }
 
-  getPreviousIndex(smartShuffle: boolean): number {
+  getPreviousIndex(_smartShuffle: boolean): number {
     const order = this.getPlayOrder();
     const currentPos = order.indexOf(this.state.currentIndex);
 
@@ -109,10 +129,53 @@ export class QueueManager {
 
   shuffle(preserveCurrent = true): void {
     this.state.shuffled = true;
-    this.state.shuffleOrder = this.generateShuffleOrder(
-      this.state.tracks.length,
-      preserveCurrent ? this.state.currentIndex : -1
-    );
+    
+    if (this.shuffleMode === "smart" && this.weightedRandomizer) {
+      this.state.shuffleOrder = this.generateSmartShuffleOrder(
+        this.state.tracks.length,
+        preserveCurrent ? this.state.currentIndex : -1
+      );
+    } else {
+      this.state.shuffleOrder = this.generateShuffleOrder(
+        this.state.tracks.length,
+        preserveCurrent ? this.state.currentIndex : -1
+      );
+    }
+  }
+
+  private generateSmartShuffleOrder(length: number, preserveIndex: number): number[] {
+    if (length === 0) return [];
+
+    const trackIds = this.state.tracks.map((t) => t.id);
+    const selectedIds: string[] = [];
+    const availableIndices = Array.from({ length }, (_, i) => i);
+
+    while (availableIndices.length > 0) {
+      const availableTrackIds = availableIndices.map((i) => trackIds[i]);
+      const selectedId = this.weightedRandomizer!.getWeightedRandomTrack(availableTrackIds);
+      
+      if (!selectedId) break;
+      
+      const selectedIndex = trackIds.indexOf(selectedId);
+      if (selectedIndex === -1) break;
+      
+      const actualIndex = availableIndices.indexOf(selectedIndex);
+      if (actualIndex === -1) break;
+      
+      selectedIds.push(selectedId);
+      availableIndices.splice(actualIndex, 1);
+    }
+
+    if (preserveIndex >= 0 && preserveIndex < length) {
+      const preserveId = trackIds[preserveIndex];
+      const idxInSelected = selectedIds.indexOf(preserveId);
+      if (idxInSelected > 0) {
+        selectedIds.splice(idxInSelected, 1);
+        selectedIds.unshift(preserveId);
+      }
+    }
+
+    return selectedIds.map((id) => trackIds.indexOf(id)).filter((i) => i >= 0);
   }
 
   unshuffle(): void {

Build/src/core/engine/index.ts

@@ -12,6 +12,7 @@ export interface Track {
   embeddedLyrics?: EmbeddedLyrics[];
   encoding?: EncodingDetails;
   gapless?: GaplessInfo;
+  replayGain?: ReplayGainInfo;
 }
 
 export interface EmbeddedLyrics {
@@ -43,6 +44,14 @@ export interface GaplessInfo {
   encoderPadding?: number;
 }
 
+export interface ReplayGainInfo {
+  trackGain?: number;
+  trackPeak?: number;
+  albumGain?: number;
+  albumPeak?: number;
+  referenceLoudness?: number;
+}
+
 export interface Playlist {
   id: string;
   name: string;

Build/src/core/engine/queue/index.ts

@@ -0,0 +1,59 @@
+import type { IAudioBackend } from "../../audio/index";
+
+export abstract class BaseAudioBackend implements IAudioBackend {
+  protected timeUpdateCallbacks: Set<(time: number) => void> = new Set();
+  protected endedCallbacks: Set<() => void> = new Set();
+  protected errorCallbacks: Set<(error: Error) => void> = new Set();
+
+  abstract load(url: string): Promise<void>;
+  abstract play(): Promise<void>;
+  abstract pause(): void;
+  abstract stop(): void;
+  abstract seek(time: number): void;
+  abstract setVolume(volume: number): void;
+  abstract setPlaybackRate(rate: number): void;
+  abstract getCurrentTime(): number;
+  abstract getDuration(): number;
+
+  dispose(): void {
+    this.timeUpdateCallbacks.clear();
+    this.endedCallbacks.clear();
+    this.errorCallbacks.clear();
+  }
+
+  onTimeUpdate(callback: (time: number) => void): void {
+    this.timeUpdateCallbacks.add(callback);
+  }
+
+  offTimeUpdate(callback: (time: number) => void): void {
+    this.timeUpdateCallbacks.delete(callback);
+  }
+
+  onEnded(callback: () => void): void {
+    this.endedCallbacks.add(callback);
+  }
+
+  offEnded(callback: () => void): void {
+    this.endedCallbacks.delete(callback);
+  }
+
+  onError(callback: (error: Error) => void): void {
+    this.errorCallbacks.add(callback);
+  }
+
+  offError(callback: (error: Error) => void): void {
+    this.errorCallbacks.delete(callback);
+  }
+
+  protected emitTimeUpdate(time: number): void {
+    this.timeUpdateCallbacks.forEach((cb) => cb(time));
+  }
+
+  protected emitEnded(): void {
+    this.endedCallbacks.forEach((cb) => cb());
+  }
+
+  protected emitError(error: Error): void {
+    this.errorCallbacks.forEach((cb) => cb(error));
+  }
+}