make-pretty

Author: NellowTCS

Build/src/core/engine/engine.ts

@@ -9,7 +9,11 @@ import type {
 } from "./types";
 import { KomorebiEvents } from "./events";
 import { StateMachine } from "./state";
-import { QueueManager, type WeightedRandomizer, type ShuffleMode } from "./queue";
+import {
+  QueueManager,
+  type WeightedRandomizer,
+  type ShuffleMode,
+} from "./queue";
 import { Scheduler } from "./scheduler";
 import type { IAudioBackend } from "../../platform/audio";
 
@@ -125,7 +129,7 @@ export class KomorebiEngine {
     }
 
     this.queue.setCurrentIndex(
-      this.queue.getTracks().findIndex((t) => t.id === track.id)
+      this.queue.getTracks().findIndex((t) => t.id === track.id),
     );
 
     this.stateMachine.transition("loading");
@@ -209,7 +213,9 @@ export class KomorebiEngine {
     const nextTrack = this.queue.getNextTrack(this.settings.smartShuffle);
     if (nextTrack) {
       const currentTrack = this.queue.getCurrentTrack();
-      this.queue.setCurrentIndex(this.queue.getNextIndex(this.settings.smartShuffle));
+      this.queue.setCurrentIndex(
+        this.queue.getNextIndex(this.settings.smartShuffle),
+      );
 
       if (this.stateMachine.isPlaying()) {
         this.loadAndPlay(nextTrack);
@@ -239,7 +245,9 @@ export class KomorebiEngine {
     const prevTrack = this.queue.getPreviousTrack(this.settings.smartShuffle);
     if (prevTrack) {
       const currentTrack = this.queue.getCurrentTrack();
-      this.queue.setCurrentIndex(this.queue.getPreviousIndex(this.settings.smartShuffle));
+      this.queue.setCurrentIndex(
+        this.queue.getPreviousIndex(this.settings.smartShuffle),
+      );
 
       if (this.stateMachine.isPlaying()) {
         this.loadAndPlay(prevTrack);
@@ -300,8 +308,11 @@ export class KomorebiEngine {
 
   toggleRepeat(): void {
     const current = this.settings.repeat;
-    this.settings.repeat = current === "off" ? "all" : current === "all" ? "one" : "off";
-    this.events.emit("settingschange", { settings: { repeat: this.settings.repeat } });
+    this.settings.repeat =
+      current === "off" ? "all" : current === "all" ? "one" : "off";
+    this.events.emit("settingschange", {
+      settings: { repeat: this.settings.repeat },
+    });
   }
 
   setCrossfade(duration: number): void {
@@ -313,7 +324,9 @@ export class KomorebiEngine {
   setGapless(enabled: boolean): void {
     this.settings.gaplessPlayback = enabled;
     this.scheduler.setGaplessConfig({ enabled });
-    this.events.emit("settingschange", { settings: { gaplessPlayback: enabled } });
+    this.events.emit("settingschange", {
+      settings: { gaplessPlayback: enabled },
+    });
   }
 
   updateSettings(newSettings: Partial<EngineSettings>): void {
@@ -372,14 +385,14 @@ export class KomorebiEngine {
 
   on<E extends keyof EngineEventMap>(
     event: E,
-    callback: (data: EngineEventMap[E]) => void
+    callback: (data: EngineEventMap[E]) => void,
   ): void {
     this.events.on(event, callback);
   }
 
   off<E extends keyof EngineEventMap>(
     event: E,
-    callback: (data: EngineEventMap[E]) => void
+    callback: (data: EngineEventMap[E]) => void,
   ): void {
     this.events.off(event, callback);
   }
@@ -396,17 +409,18 @@ export class KomorebiEngine {
     return new Promise((resolve, reject) => {
       const onEndedHandler = () => {
         this.backend?.offEnded(onEndedHandler);
-        this.play()
-          .then(resolve)
-          .catch(reject);
+        this.play().then(resolve).catch(reject);
       };
 
       this.backend?.onEnded(onEndedHandler);
       this.load(track);
     });
   }
 
-  private async waitForState(targetState: PlayerState, timeout = 5000): Promise<void> {
+  private async waitForState(
+    targetState: PlayerState,
+    timeout = 5000,
+  ): Promise<void> {
     return new Promise((resolve, reject) => {
       const checkState = () => {
         if (this.stateMachine.getState() === targetState) {
@@ -465,7 +479,8 @@ export class KomorebiEngine {
     const nextTrack = this.queue.getNextTrack(this.settings.smartShuffle);
     if (!nextTrack) return;
 
-    const delay = this.scheduler.getMode() === "gapless" ? 100 : this.settings.crossfade;
+    const delay =
+      this.scheduler.getMode() === "gapless" ? 100 : this.settings.crossfade;
 
     this.scheduledTransitionId = window.setTimeout(() => {
       this.scheduledTransitionId = null;
@@ -475,7 +490,9 @@ export class KomorebiEngine {
 
   private executeTransition(nextTrack: Track): void {
     const currentTrack = this.queue.getCurrentTrack();
-    this.queue.setCurrentIndex(this.queue.getNextIndex(this.settings.smartShuffle));
+    this.queue.setCurrentIndex(
+      this.queue.getNextIndex(this.settings.smartShuffle),
+    );
 
     this.load(nextTrack);
     this.play();
@@ -544,15 +561,21 @@ export class KomorebiEngine {
   private emitStateChange(): void {
     const prevState = this.stateMachine.getPreviousState();
     const newState = this.stateMachine.getState();
-    this.events.emit("statechange", { oldState: prevState ?? "idle", newState });
+    this.events.emit("statechange", {
+      oldState: prevState ?? "idle",
+      newState,
+    });
   }
 
   private emitTrackChange(from: Track | null, to: Track | null): void {
     this.events.emit("trackchange", { from, to });
   }
 
   private emitTimeUpdate(): void {
-    this.events.emit("timeupdate", { currentTime: this.currentTime, duration: this.duration });
+    this.events.emit("timeupdate", {
+      currentTime: this.currentTime,
+      duration: this.duration,
+    });
   }
 
   private emitError(code: string, message: string, track?: Track): void {
@@ -561,4 +584,4 @@ export class KomorebiEngine {
     this.events.emit("error", { error: this.currentError });
     this.emitStateChange();
   }
-}
+}

Build/src/core/engine/events.ts

@@ -5,14 +5,20 @@ type EventCallback<T> = (data: T) => void;
 export class KomorebiEvents {
   private listeners: Map<EngineEvent, Set<EventCallback<unknown>>> = new Map();
 
-  on<E extends EngineEvent>(event: E, callback: EventCallback<EngineEventMap[E]>): void {
+  on<E extends EngineEvent>(
+    event: E,
+    callback: EventCallback<EngineEventMap[E]>,
+  ): void {
     if (!this.listeners.has(event)) {
       this.listeners.set(event, new Set());
     }
     this.listeners.get(event)!.add(callback as EventCallback<unknown>);
   }
 
-  off<E extends EngineEvent>(event: E, callback: EventCallback<EngineEventMap[E]>): void {
+  off<E extends EngineEvent>(
+    event: E,
+    callback: EventCallback<EngineEventMap[E]>,
+  ): void {
     const callbacks = this.listeners.get(event);
     if (callbacks) {
       callbacks.delete(callback as EventCallback<unknown>);
@@ -26,7 +32,10 @@ export class KomorebiEvents {
     }
   }
 
-  once<E extends EngineEvent>(event: E, callback: EventCallback<EngineEventMap[E]>): void {
+  once<E extends EngineEvent>(
+    event: E,
+    callback: EventCallback<EngineEventMap[E]>,
+  ): void {
     const wrapper: EventCallback<EngineEventMap[E]> = (data) => {
       this.off(event, wrapper);
       callback(data);
@@ -45,4 +54,4 @@ export class KomorebiEvents {
   listenerCount(event: EngineEvent): number {
     return this.listeners.get(event)?.size ?? 0;
   }
-}
+}

Build/src/core/engine/index.ts

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

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

@@ -44,15 +44,23 @@ export class QueueManager {
 
     const tracks = [...playlist.songs];
     const currentTrack = preserveCurrent ? this.getCurrentTrack() : null;
-    const newIndex = currentTrack ? tracks.findIndex((t) => t.id === currentTrack.id) : -1;
+    const newIndex = currentTrack
+      ? tracks.findIndex((t) => t.id === currentTrack.id)
+      : -1;
 
     this.state.tracks = tracks;
-    this.state.shuffleOrder = this.generateShuffleOrder(tracks.length, newIndex);
+    this.state.shuffleOrder = this.generateShuffleOrder(
+      tracks.length,
+      newIndex,
+    );
     this.state.currentIndex = newIndex >= 0 ? newIndex : -1;
   }
 
   getCurrentTrack(): Track | null {
-    if (this.state.currentIndex < 0 || this.state.currentIndex >= this.state.tracks.length) {
+    if (
+      this.state.currentIndex < 0 ||
+      this.state.currentIndex >= this.state.tracks.length
+    ) {
       return null;
     }
     return this.state.tracks[this.state.currentIndex];
@@ -129,21 +137,24 @@ export class QueueManager {
 
   shuffle(preserveCurrent = true): void {
     this.state.shuffled = true;
-    
+
     if (this.shuffleMode === "smart" && this.weightedRandomizer) {
       this.state.shuffleOrder = this.generateSmartShuffleOrder(
         this.state.tracks.length,
-        preserveCurrent ? this.state.currentIndex : -1
+        preserveCurrent ? this.state.currentIndex : -1,
       );
     } else {
       this.state.shuffleOrder = this.generateShuffleOrder(
         this.state.tracks.length,
-        preserveCurrent ? this.state.currentIndex : -1
+        preserveCurrent ? this.state.currentIndex : -1,
       );
     }
   }
 
-  private generateSmartShuffleOrder(length: number, preserveIndex: number): number[] {
+  private generateSmartShuffleOrder(
+    length: number,
+    preserveIndex: number,
+  ): number[] {
     if (length === 0) return [];
 
     const trackIds = this.state.tracks.map((t) => t.id);
@@ -152,16 +163,17 @@ export class QueueManager {
 
     while (availableIndices.length > 0) {
       const availableTrackIds = availableIndices.map((i) => trackIds[i]);
-      const selectedId = this.weightedRandomizer!.getWeightedRandomTrack(availableTrackIds);
-      
+      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);
     }
@@ -187,7 +199,10 @@ export class QueueManager {
     return this.state.shuffled;
   }
 
-  private generateShuffleOrder(length: number, preserveIndex: number): number[] {
+  private generateShuffleOrder(
+    length: number,
+    preserveIndex: number,
+  ): number[] {
     if (length === 0) return [];
 
     const indices = Array.from({ length }, (_, i) => i);
@@ -200,7 +215,10 @@ export class QueueManager {
     if (preserveIndex >= 0 && preserveIndex < length) {
       const currentInShuffle = indices.indexOf(preserveIndex);
       if (currentInShuffle > 0) {
-        [indices[0], indices[currentInShuffle]] = [indices[currentInShuffle], indices[0]];
+        [indices[0], indices[currentInShuffle]] = [
+          indices[currentInShuffle],
+          indices[0],
+        ];
       }
     }
 
@@ -221,8 +239,9 @@ export class QueueManager {
     }
 
     if (this.history.size > this.maxHistorySize) {
-      const sorted = Array.from(this.history.values())
-        .sort((a, b) => a.lastPlayed - b.lastPlayed);
+      const sorted = Array.from(this.history.values()).sort(
+        (a, b) => a.lastPlayed - b.lastPlayed,
+      );
       const toRemove = sorted.slice(0, this.history.size - this.maxHistorySize);
       toRemove.forEach((h) => this.history.delete(h.trackId));
     }
@@ -249,7 +268,8 @@ export class QueueManager {
     if (this.state.shuffled) {
       const newIndex = this.state.tracks.length - 1;
       this.state.shuffleOrder.push(newIndex);
-      const insertPos = Math.floor(Math.random() * (this.state.shuffleOrder.length - 1)) + 1;
+      const insertPos =
+        Math.floor(Math.random() * (this.state.shuffleOrder.length - 1)) + 1;
       this.state.shuffleOrder.splice(insertPos, 0, newIndex);
     }
   }
@@ -276,4 +296,4 @@ export class QueueManager {
     this.state.currentIndex = -1;
     this.state.shuffleOrder = [];
   }
-}
+}