Merge remote-tracking branch 'origin/dev' into feature/traktor-nml-export

Author: Radexito

renderer/src/Sidebar.jsx

@@ -98,7 +98,8 @@ function Sidebar({
 
     setImportProgress({ total: files.length, completed: 0 });
     await window.api.importAudioFiles(files, playlistId);
-    setImportProgress({ total: 0, completed: 0 });
+    // Small delay so the user sees 100% before the bar disappears
+    setTimeout(() => setImportProgress({ total: 0, completed: 0 }), 800);
   };
 
   const handleCreatePlaylist = async (e) => {
@@ -137,6 +138,13 @@ function Sidebar({
     return unsub;
   }, []);
 
+  useEffect(() => {
+    const unsub = window.api.onImportProgress(({ completed, total }) => {
+      setImportProgress({ completed, total });
+    });
+    return unsub;
+  }, []);
+
   useEffect(() => {
     const unsub = window.api.onNormalizeProgress((data) => {
       if (data.done) {

renderer/src/__tests__/setup.js

@@ -46,6 +46,7 @@ window.api = {
   onDepsProgress: vi.fn().mockImplementation(noop),
   onMoveLibraryProgress: vi.fn().mockImplementation(noop),
   onExportM3UProgress: vi.fn().mockImplementation(noop),
+  onImportProgress: vi.fn().mockImplementation(noop),
   onNormalizeProgress: vi.fn().mockImplementation(noop),
   getMediaPort: vi.fn().mockResolvedValue(19876),
   ytDlpFetchInfo: vi.fn().mockResolvedValue({ ok: false, error: 'not configured' }),

src/__tests__/importManager.test.js

@@ -236,3 +236,77 @@ describe('normalizeAudioFile', () => {
     expect(args[iIndex + 1]).toBe(TRACK.file_path);
   });
 });
+
+// ── Artist detection from filename ────────────────────────────────────────────
+
+import { ffprobe } from '../audio/ffmpeg.js';
+
+describe('importAudioFile — artist detection from filename', () => {
+  it('uses ID3 artist tag when present, ignoring filename', async () => {
+    ffprobe.mockResolvedValueOnce({
+      format: {
+        format_name: 'mp3',
+        duration: '180.0',
+        bit_rate: '320000',
+        tags: { title: 'My Song', artist: 'Tag Artist' },
+      },
+      streams: [],
+    });
+
+    await importAudioFile('/music/Someone Else - My Song.mp3');
+
+    expect(mockAddTrack.mock.calls[0][0].artist).toBe('Tag Artist');
+  });
+
+  it('parses artist from "Artist - Title" filename when artist tag is missing', async () => {
+    ffprobe.mockResolvedValueOnce({
+      format: {
+        format_name: 'mp3',
+        duration: '180.0',
+        bit_rate: '320000',
+        tags: { title: '', artist: '' },
+      },
+      streams: [],
+    });
+
+    await importAudioFile('/music/Deadmau5 - Some Chords.mp3');
+
+    expect(mockAddTrack.mock.calls[0][0].artist).toBe('Deadmau5');
+    expect(mockAddTrack.mock.calls[0][0].title).toBe('Some Chords');
+  });
+
+  it('leaves artist empty when no tag and no dash in filename', async () => {
+    ffprobe.mockResolvedValueOnce({
+      format: {
+        format_name: 'mp3',
+        duration: '180.0',
+        bit_rate: '320000',
+        tags: { title: '', artist: '' },
+      },
+      streams: [],
+    });
+
+    await importAudioFile('/music/untitled_track.mp3');
+
+    expect(mockAddTrack.mock.calls[0][0].artist).toBe('');
+    expect(mockAddTrack.mock.calls[0][0].title).toBe('untitled_track');
+  });
+
+  it('keeps ID3 title when artist is missing but filename has dash', async () => {
+    ffprobe.mockResolvedValueOnce({
+      format: {
+        format_name: 'mp3',
+        duration: '180.0',
+        bit_rate: '320000',
+        tags: { title: 'ID3 Title', artist: '' },
+      },
+      streams: [],
+    });
+
+    await importAudioFile('/music/Filename Artist - Other Title.mp3');
+
+    expect(mockAddTrack.mock.calls[0][0].artist).toBe('Filename Artist');
+    // ID3 title wins over filename-derived title
+    expect(mockAddTrack.mock.calls[0][0].title).toBe('ID3 Title');
+  });
+});

src/audio/importManager.js

@@ -221,12 +221,24 @@ export async function importAudioFile(filePath, sourceMeta = {}) {
   // Extract tags
   const { title, artist, album, genre, year, label, bpm } = parseTags(probe);
 
+  // Fallback: parse "Artist - Title" from filename when artist tag is absent
+  const basename = path.basename(filePath, ext);
+  let resolvedArtist = artist;
+  let resolvedTitle = title;
+  if (!artist) {
+    const dashIdx = basename.indexOf(' - ');
+    if (dashIdx !== -1) {
+      resolvedArtist = basename.slice(0, dashIdx).trim();
+      resolvedTitle = resolvedTitle || basename.slice(dashIdx + 3).trim();
+    }
+  }
+
   // Extract embedded album art (best-effort, non-blocking)
   const artworkPath = await extractArtwork(dest, hash);
 
   const trackId = addTrack({
-    title: title || path.basename(filePath, ext),
-    artist,
+    title: resolvedTitle || basename,
+    artist: resolvedArtist,
     album,
     duration,
     file_path: dest,
@@ -245,7 +257,7 @@ export async function importAudioFile(filePath, sourceMeta = {}) {
     artwork_path: artworkPath ?? null,
   });
 
-  console.log(`Added track ID ${trackId}: ${title || path.basename(filePath, ext)}`);
+  console.log(`Added track ID ${trackId}: ${resolvedTitle || basename}`);
 
   spawnAnalysis(trackId, dest);
   return trackId;

src/deps.js

@@ -164,16 +164,19 @@ export function getReleaseByTag(owner, repo, tag) {
 // ── Archive helpers ───────────────────────────────────────────────────────────
 
 async function extractTarGz(archive, destDir) {
+  if (fs.existsSync(destDir)) fs.rmSync(destDir, { recursive: true, force: true });
   await fs.promises.mkdir(destDir, { recursive: true });
   await execAsync(`tar -xzf "${archive}" -C "${destDir}"`);
 }
 
 async function extractTarXz(archive, destDir) {
+  if (fs.existsSync(destDir)) fs.rmSync(destDir, { recursive: true, force: true });
   await fs.promises.mkdir(destDir, { recursive: true });
   await execAsync(`tar -xJf "${archive}" -C "${destDir}"`);
 }
 
 async function extractZip(archive, destDir) {
+  if (fs.existsSync(destDir)) fs.rmSync(destDir, { recursive: true, force: true });
   await fs.promises.mkdir(destDir, { recursive: true });
   if (process.platform === 'win32') {
     await execAsync(

src/main.js

@@ -535,13 +535,17 @@ ipcMain.handle('open-dir-dialog', async () => {
 ipcMain.handle('import-audio-files', async (event, filePaths, playlistId) => {
   console.log('Importing audio files:', filePaths);
   const trackIds = [];
+  const total = filePaths.length;
 
-  for (const filePath of filePaths) {
+  for (let i = 0; i < total; i++) {
     try {
-      const trackId = await importAudioFile(filePath);
+      const trackId = await importAudioFile(filePaths[i]);
       trackIds.push(trackId);
     } catch (err) {
-      console.error('Import failed:', filePath, err);
+      console.error('Import failed:', filePaths[i], err);
+    }
+    if (global.mainWindow) {
+      global.mainWindow.webContents.send('import-progress', { completed: i + 1, total });
     }
   }
 

src/preload.js

@@ -87,6 +87,11 @@ contextBridge.exposeInMainWorld('api', {
     ipcRenderer.on('library-updated', handler);
     return () => ipcRenderer.removeListener('library-updated', handler);
   },
+  onImportProgress: (callback) => {
+    const handler = (_, data) => callback(data);
+    ipcRenderer.on('import-progress', handler);
+    return () => ipcRenderer.removeListener('import-progress', handler);
+  },
   onPlaylistsUpdated: (callback) => {
     const handler = () => callback();
     ipcRenderer.on('playlists-updated', handler);