osu-play 1.2.0 → 1.3.0

package/dist/cli.js

@@ -409,6 +409,7 @@ __export(exports_mod, {
   getLazerDB: () => getLazerDB,
   getBeatmapSets: () => getBeatmapSets,
   formatLazerSchemaCompatibilityError: () => formatLazerSchemaCompatibilityError,
+  deleteBeatmapSet: () => deleteBeatmapSet,
   RealmUser: () => RealmUser,
   RealmNamedFileUsage: () => RealmNamedFileUsage,
   RealmFile: () => RealmFile,
@@ -424,6 +425,48 @@ function inspectLazerSchema(realm) {
 function getBeatmapSets(realm) {
   return realm.objects("BeatmapSet");
 }
+function queryBeatmapSet(realm, track) {
+  const beatmapSets = realm.objects("BeatmapSet");
+  if (track.beatmapSetId !== null && track.beatmapSetId !== undefined) {
+    const byId = realm.objectForPrimaryKey("BeatmapSet", track.beatmapSetId) ?? beatmapSets.filtered("ID == $0", track.beatmapSetId)[0];
+    if (byId) {
+      return byId;
+    }
+  }
+  if (track.beatmapSetHash) {
+    return beatmapSets.filtered("Hash == $0", track.beatmapSetHash)[0] ?? null;
+  }
+  return null;
+}
+async function deleteBeatmapSet(track, osuDataDir) {
+  const realmDBPath = getRealmDBPath({ osuDataDir });
+  if (!realmDBPath) {
+    throw new Error("Realm DB not found");
+  }
+  const realm = await Realm7.open({ path: realmDBPath });
+  try {
+    let markedForDeletion = false;
+    realm.write(() => {
+      const beatmapSet = queryBeatmapSet(realm, track);
+      if (!beatmapSet) {
+        throw new Error(`Beatmap set for "${track.title}" no longer exists.`);
+      }
+      if (beatmapSet.Protected) {
+        throw new Error(`"${track.title}" is protected and cannot be deleted.`);
+      }
+      if (beatmapSet.DeletePending) {
+        return;
+      }
+      beatmapSet.DeletePending = true;
+      markedForDeletion = true;
+    });
+    if (!markedForDeletion) {
+      throw new Error(`"${track.title}" is already pending deletion.`);
+    }
+  } finally {
+    realm.close();
+  }
+}
 var getLazerDB = async (realmDBPath) => {
   return Realm7.open({
     path: realmDBPath,
@@ -439,6 +482,7 @@ var getLazerDB = async (realmDBPath) => {
 };
 var init_mod3 = __esm(() => {
   init_compat();
+  init_mod();
   init_mod2();
   init_compat();
   init_mod();
@@ -473,6 +517,9 @@ function buildPlaylist(beatmapSets, osuDataDir) {
   const seenHashes = new Set;
   const playlist = [];
   for (const beatmapSet of beatmapSets) {
+    if (beatmapSet.DeletePending) {
+      continue;
+    }
     for (const beatmap of beatmapSet.Beatmaps) {
       const hash = getNamedFileHash(beatmap.Metadata.AudioFile ?? "", beatmapSet);
       if (!hash || seenHashes.has(hash)) {
@@ -480,6 +527,9 @@ function buildPlaylist(beatmapSets, osuDataDir) {
       }
       seenHashes.add(hash);
       playlist.push({
+        beatmapSetHash: beatmapSet.Hash ?? null,
+        beatmapSetId: beatmapSet.ID,
+        beatmapSetKey: String(beatmapSet.ID ?? hash),
         hash,
         path: hashedFilePath(hash, osuDataDir),
         title: formatTrackTitle(beatmap.Metadata)
@@ -588,11 +638,12 @@ class MpvPlayerBackend {
       });
       throw error;
     }
+    this.idleActive = false;
     this.snapshot = {
       ...this.snapshot,
       currentPath: filePath,
       errorMessage: null,
-      status: this.idleActive ? "stopped" : "playing",
+      status: "playing",
       timePositionSeconds: this.snapshot.timePositionSeconds ?? 0
     };
     this.emit({
@@ -785,17 +836,20 @@ ${detail}` : "";
       return;
     }
     if (response.event === "end-file") {
-      this.snapshot = {
-        ...this.snapshot,
-        status: "stopped",
-        timePositionSeconds: this.snapshot.durationSeconds
-      };
-      this.emit({
-        snapshot: this.snapshot,
-        type: "state"
-      });
+      const reason = response.reason ?? "unknown";
+      if (reason !== "stop" && reason !== "redirect") {
+        this.snapshot = {
+          ...this.snapshot,
+          status: "stopped",
+          timePositionSeconds: reason === "eof" ? this.snapshot.durationSeconds : this.snapshot.timePositionSeconds
+        };
+        this.emit({
+          snapshot: this.snapshot,
+          type: "state"
+        });
+      }
       this.emit({
-        reason: response.reason ?? "unknown",
+        reason,
         type: "ended"
       });
     }
@@ -927,14 +981,19 @@ class PlaylistPlayerSession {
   currentIndex = null;
   errorMessage = null;
   loop;
+  deleteTrack;
   playlist;
+  reloadPlaylist;
   searchQuery = "";
   selectedIndex = 0;
+  operationQueue = Promise.resolve();
   unsubscribeBackend;
   constructor(playlist, backend, options = {}) {
     this.backend = backend;
     this.playlist = playlist;
+    this.deleteTrack = options.deleteTrack;
     this.loop = options.loop ?? false;
+    this.reloadPlaylist = options.reloadPlaylist;
     this.unsubscribeBackend = backend.subscribe((event) => {
       this.handleBackendEvent(event);
     });
@@ -1028,61 +1087,113 @@ class PlaylistPlayerSession {
     this.emit();
   }
   async playSelected() {
-    await this.playIndex(this.selectedIndex);
+    const selectedIndex = this.selectedIndex;
+    await this.enqueueOperation(async () => {
+      await this.playIndex(selectedIndex);
+    });
   }
   async playNext() {
-    const nextIndex = this.getAdjacentIndex(1);
-    if (nextIndex === null) {
-      return;
-    }
-    await this.playIndex(nextIndex);
+    await this.enqueueOperation(async () => {
+      const nextIndex = this.getAdjacentIndex(1, true);
+      if (nextIndex === null) {
+        return;
+      }
+      await this.playIndex(nextIndex);
+    });
   }
   async playPrevious() {
-    const previousIndex = this.getAdjacentIndex(-1);
-    if (previousIndex === null) {
-      return;
-    }
-    await this.playIndex(previousIndex);
+    await this.enqueueOperation(async () => {
+      const previousIndex = this.getAdjacentIndex(-1, true);
+      if (previousIndex === null) {
+        return;
+      }
+      await this.playIndex(previousIndex);
+    });
   }
   async togglePause() {
-    if (this.playlist.length === 0) {
-      return;
-    }
-    const { status } = this.backend.getSnapshot();
-    if (status === "stopped") {
-      const restartIndex = this.currentIndex ?? this.selectedIndex;
-      await this.playIndex(restartIndex);
-      return;
-    }
-    try {
-      this.clearError();
-      await this.backend.togglePause();
-    } catch (error) {
-      this.reportError(error);
-    }
+    const selectedIndex = this.selectedIndex;
+    await this.enqueueOperation(async () => {
+      if (this.playlist.length === 0) {
+        return;
+      }
+      const { status } = this.backend.getSnapshot();
+      if (status === "stopped") {
+        const restartIndex = this.currentIndex ?? selectedIndex;
+        await this.playIndex(restartIndex);
+        return;
+      }
+      try {
+        this.clearError();
+        await this.backend.togglePause();
+      } catch (error) {
+        this.reportError(error);
+      }
+    });
   }
   async seekBy(seconds) {
-    if (seconds === 0) {
-      return;
-    }
-    const { status } = this.backend.getSnapshot();
-    if (status === "stopped") {
-      return;
-    }
-    try {
-      this.clearError();
-      await this.backend.seekBy(seconds);
-    } catch (error) {
-      this.reportError(error);
-    }
+    await this.enqueueOperation(async () => {
+      if (seconds === 0) {
+        return;
+      }
+      const { status } = this.backend.getSnapshot();
+      if (status === "stopped") {
+        return;
+      }
+      try {
+        this.clearError();
+        await this.backend.seekBy(seconds);
+      } catch (error) {
+        this.reportError(error);
+      }
+    });
   }
   async stop() {
-    try {
-      this.clearError();
-      await this.backend.stop();
-    } catch (error) {
-      this.reportError(error);
-    }
+    await this.enqueueOperation(async () => {
+      try {
+        this.clearError();
+        await this.backend.stop();
+      } catch (error) {
+        this.reportError(error);
+      }
+    });
+  }
+  async deleteSelectedTrack() {
+    const selectedIndex = this.selectedIndex;
+    await this.enqueueOperation(async () => {
+      const track = this.playlist[selectedIndex];
+      if (!track) {
+        return;
+      }
+      if (!this.deleteTrack || !this.reloadPlaylist) {
+        this.reportError(new Error("Beatmap deletion is unavailable in this session."));
+        return;
+      }
+      const currentTrack = this.currentIndex !== null ? this.playlist[this.currentIndex] ?? null : null;
+      const deletingCurrentTrack = currentTrack !== null && currentTrack.beatmapSetKey === track.beatmapSetKey;
+      try {
+        this.clearError();
+        if (deletingCurrentTrack) {
+          await this.backend.stop();
+          this.currentIndex = null;
+        }
+        await this.deleteTrack(track);
+        this.playlist = await this.reloadPlaylist();
+        this.selectedIndex = clampIndex(selectedIndex, this.playlist.length);
+        if (this.searchQuery) {
+          const matchedIndex = findTrackIndexByQuery(this.playlist, this.searchQuery);
+          if (matchedIndex !== -1) {
+            this.selectedIndex = matchedIndex;
+          }
+        }
+        if (!deletingCurrentTrack && currentTrack) {
+          const nextCurrentIndex = this.playlist.findIndex((playlistTrack) => playlistTrack.hash === currentTrack.hash);
+          this.currentIndex = nextCurrentIndex === -1 ? null : nextCurrentIndex;
+        }
+        this.emit();
+      } catch (error) {
+        this.reportError(error);
+      }
+    });
   }
   reportError(error) {
     this.errorMessage = error instanceof Error ? error.message : String(error);
@@ -1115,23 +1226,25 @@ class PlaylistPlayerSession {
       this.reportError(error);
       return;
     }
+    this.selectedIndex = index;
     this.emit();
   }
-  getAdjacentIndex(delta) {
+  getAdjacentIndex(delta, wrap = false) {
     if (this.playlist.length === 0) {
       return null;
     }
     const baseIndex = this.currentIndex ?? this.selectedIndex;
     const nextIndex = baseIndex + delta;
+    const shouldWrap = wrap || this.loop;
     if (nextIndex < 0) {
-      return this.loop ? this.playlist.length - 1 : null;
+      return shouldWrap ? this.playlist.length - 1 : null;
     }
     if (nextIndex >= this.playlist.length) {
-      return this.loop ? 0 : null;
+      return shouldWrap ? 0 : null;
     }
     return nextIndex;
   }
-  async handleBackendEvent(event) {
+  handleBackendEvent(event) {
     switch (event.type) {
       case "state":
         this.emit();
@@ -1140,16 +1253,23 @@ class PlaylistPlayerSession {
         this.reportError(event.error);
         return;
       case "ended":
-        if (event.reason === "eof") {
-          const nextIndex = this.getAdjacentIndex(1);
-          if (nextIndex !== null) {
-            await this.playIndex(nextIndex);
-            return;
+        this.enqueueOperation(async () => {
+          if (event.reason === "eof") {
+            const nextIndex = this.getAdjacentIndex(1);
+            if (nextIndex !== null) {
+              await this.playIndex(nextIndex);
+              return;
+            }
           }
-        }
-        this.emit();
+          this.emit();
+        });
     }
   }
+  enqueueOperation(operation) {
+    const queuedOperation = this.operationQueue.then(operation, operation);
+    this.operationQueue = queuedOperation.catch(() => {});
+    return queuedOperation;
+  }
   syncSelectionToSearch() {
     const matchedIndex = findTrackIndexByQuery(this.playlist, this.searchQuery);
     if (matchedIndex !== -1) {
@@ -1169,15 +1289,27 @@ var RESET = "\x1B[0m";
 var DIM = "\x1B[2m";
 var RED = "\x1B[31m";
 var CYAN = "\x1B[36m";
+var BOLD = "\x1B[1m";
 var INVERSE = "\x1B[7m";
 var MIN_LIST_ROWS = 4;
-var RESERVED_ROWS = 6;
+var RESERVED_ROWS = 5;
 var PAGE_SIZE = 10;
 var PENDING_G_TIMEOUT_MS = 400;
 var SEEK_SECONDS = 5;
+var STATUS_GLYPH = {
+  paused: "⏸",
+  playing: "▶",
+  stopped: "■"
+};
 function style(text, code) {
   return `${code}${text}${RESET}`;
 }
+function progressBar(position, duration, width) {
+  const span = Math.max(4, width);
+  const ratio = duration && duration > 0 && position !== null ? Math.max(0, Math.min(position / duration, 1)) : 0;
+  const filled = Math.round(ratio * span);
+  return style("━".repeat(filled), CYAN) + style("─".repeat(span - filled), DIM);
+}
 function padIndex(index, total) {
   const width = String(Math.max(total, 1)).length;
   return String(index + 1).padStart(width, " ");
@@ -1217,6 +1349,7 @@ function getVisibleTrackRange(selectedIndex, totalTracks, maxVisible) {
 class PlaylistPlayerScreen {
   session;
   getViewportHeight;
+  deleteConfirmationTrackKey = null;
   pendingGoToTop = false;
   pendingGoToTopTimer = null;
   searchMode = false;
@@ -1232,6 +1365,10 @@ class PlaylistPlayerScreen {
   }
   invalidate() {}
   handleInput(data) {
+    if (this.deleteConfirmationTrackKey !== null) {
+      this.handleDeleteConfirmationInput(data);
+      return;
+    }
     if (this.searchMode) {
       this.handleSearchInput(data);
       return;
@@ -1302,6 +1439,10 @@ class PlaylistPlayerScreen {
       this.session.playSelected();
       return;
     }
+    if (matchesKey(data, "d")) {
+      this.armDeleteConfirmation();
+      return;
+    }
     if (matchesKey(data, Key.space)) {
       this.session.togglePause();
       return;
@@ -1336,15 +1477,24 @@ class PlaylistPlayerScreen {
     const viewportHeight = Math.max(this.getViewportHeight(), RESERVED_ROWS);
     const listHeight = this.getListHeight(viewportHeight);
     const { start, end } = getVisibleTrackRange(this.snapshot.selectedIndex, playlist.length, listHeight);
+    const position = formatSeconds(this.snapshot.timePositionSeconds);
+    const duration = formatSeconds(this.snapshot.durationSeconds);
+    const glyph = STATUS_GLYPH[this.snapshot.status] ?? "·";
+    const isIdle = this.snapshot.currentTrack === null;
+    const nowPlaying = `${glyph}  ${this.snapshot.currentTrack?.title ?? "nothing playing"}`;
+    const barWidth = Math.max(4, width - position.length - duration.length - 2);
     const lines = [
-      truncateToWidth(`osu-play | tracks ${playlist.length} | backend ${this.snapshot.backendName} | loop ${this.snapshot.loop ? "on" : "off"}`, width),
-      truncateToWidth(style(`now ${this.snapshot.status}: ${this.snapshot.currentTrack?.title ?? "nothing selected"}`, CYAN), width),
-      truncateToWidth(style(`${formatSeconds(this.snapshot.timePositionSeconds)} / ${formatSeconds(this.snapshot.durationSeconds)} | selected ${this.snapshot.selectedIndex + 1}/${Math.max(playlist.length, 1)}${this.snapshot.searchQuery ? ` | search "${this.snapshot.searchQuery}"${this.searchMode ? " [input]" : ""}` : this.searchMode ? " | search [input]" : ""}`, DIM), width)
+      truncateToWidth(isIdle ? style(nowPlaying, DIM) : style(nowPlaying, BOLD + CYAN), width),
+      truncateToWidth(`${style(position, DIM)} ${progressBar(this.snapshot.timePositionSeconds, this.snapshot.durationSeconds, barWidth)} ${style(duration, DIM)}`, width)
     ];
     if (this.snapshot.errorMessage) {
-      lines.push(truncateToWidth(style(`error: ${this.snapshot.errorMessage}`, RED), width));
+      lines.push(truncateToWidth(style(`✗  ${this.snapshot.errorMessage}`, RED), width));
+    } else if (this.deleteConfirmationTrackKey !== null) {
+      lines.push(truncateToWidth(style("delete this beatmap set?  enter/d/y confirm · any key cancel", RED), width));
+    } else if (this.searchMode || this.snapshot.searchQuery) {
+      lines.push(truncateToWidth(style(`/ ${this.snapshot.searchQuery}${this.searchMode ? "▏" : ""}`, CYAN), width));
     } else {
-      lines.push("");
+      lines.push(truncateToWidth(style(`${this.snapshot.selectedIndex + 1}/${Math.max(playlist.length, 1)} · loop ${this.snapshot.loop ? "on" : "off"} · ${this.snapshot.backendName}`, DIM), width));
     }
     if (playlist.length === 0) {
       lines.push(truncateToWidth("No tracks were found in your osu!lazer library.", width));
@@ -1356,15 +1506,15 @@ class PlaylistPlayerScreen {
         }
         const isCurrent = index === this.snapshot.currentIndex;
         const isSelected = index === this.snapshot.selectedIndex;
-        const prefix = `${isSelected ? ">" : " "} ${isCurrent ? "*" : " "} `;
-        const line = `${prefix}${padIndex(index, playlist.length)}. ${track.title}`;
-        lines.push(truncateToWidth(isSelected ? style(line, INVERSE) : line, width));
+        const marker = isCurrent ? "▶" : " ";
+        const line = ` ${marker}  ${padIndex(index, playlist.length)}  ${track.title}`;
+        lines.push(truncateToWidth(isSelected ? style(line, INVERSE) : isCurrent ? style(line, CYAN) : line, width));
       }
     }
     while (lines.length < viewportHeight - 1) {
       lines.push("");
     }
-    lines.push(truncateToWidth(style(this.searchMode ? "/ search | type to jump | backspace edit | enter keep | esc leave" : "h/l seek | j/k wrap | gg/G bounds | C-u/C-d page | H/M/L viewport | n/p track | r loop | / search", DIM), width));
+    lines.push(truncateToWidth(style(this.searchMode ? "type to jump · backspace edit · enter keep · esc leave" : "j/k move · ⏎ play · space pause · n/p track · h/l seek · r loop · d delete · / search · q quit", DIM), width));
     return lines;
   }
   armPendingGoToTop() {
@@ -1381,6 +1531,24 @@ class PlaylistPlayerScreen {
     }
     this.pendingGoToTop = false;
   }
+  armDeleteConfirmation() {
+    const selectedTrack = this.snapshot.playlist[this.snapshot.selectedIndex];
+    if (!selectedTrack) {
+      return;
+    }
+    this.deleteConfirmationTrackKey = selectedTrack.beatmapSetKey;
+  }
+  clearDeleteConfirmation() {
+    this.deleteConfirmationTrackKey = null;
+  }
+  handleDeleteConfirmationInput(data) {
+    if (matchesKey(data, Key.enter) || matchesKey(data, "d") || matchesKey(data, "y")) {
+      this.clearDeleteConfirmation();
+      this.session.deleteSelectedTrack();
+      return;
+    }
+    this.clearDeleteConfirmation();
+  }
   handleSearchInput(data) {
     if (matchesKey(data, Key.ctrl("c"))) {
       this.onQuit?.();
@@ -1506,9 +1674,17 @@ async function createPlaylist(osuDataDir) {
     realm.close();
   }
 }
-async function runTuiPlayer(playlist, loop) {
+async function deleteTrackFromCollection(track, osuDataDir) {
+  const { deleteBeatmapSet: deleteBeatmapSet2 } = await loadRealmDependencies();
+  await deleteBeatmapSet2(track, osuDataDir);
+}
+async function runTuiPlayer(playlist, osuDataDir, loop) {
   const backend = new MpvPlayerBackend;
-  const session = new PlaylistPlayerSession(playlist, backend, { loop });
+  const session = new PlaylistPlayerSession(playlist, backend, {
+    deleteTrack: (track) => deleteTrackFromCollection(track, osuDataDir),
+    loop,
+    reloadPlaylist: () => createPlaylist(osuDataDir)
+  });
   const terminal = new ProcessTerminal;
   const tui = new TUI(terminal);
   const screen = new PlaylistPlayerScreen(session, () => terminal.rows);
@@ -1555,7 +1731,7 @@ async function main() {
     console.log(`[INFO] Use something like \`mpv --playlist=${path3.resolve(argv.exportPlaylist)}\` to play the playlist.`);
     return;
   }
-  await runTuiPlayer(playlist, argv.loop);
+  await runTuiPlayer(playlist, argv.osuDataDir, argv.loop);
 }
 
 // src/cli.ts
@@ -1566,4 +1742,4 @@ main().then(() => {
   process.exit(1);
 });
 
-//# debugId=FF1120811E982FF064756E2164756E21
+//# debugId=CC4EB1080D57FADD64756E2164756E21