refactor(synced-lyrics): unify empty line handling

robroid · robroid · commit 8501f03c4caf · 2025-10-03T01:53:48.000+08:00
diff --git a/src/plugins/synced-lyrics/parsers/lrc.ts b/src/plugins/synced-lyrics/parsers/lrc.ts
@@ -1,3 +1,8 @@
+import {
+  ensureLeadingPaddingEmptyLine,
+  mergeConsecutiveEmptySyncedLines,
+} from '../shared/lines';
+
 interface LRCTag {
   tag: string;
   value: string;
@@ -79,42 +84,11 @@ export const LRC = {
       line.timeInMs += offset;
     }
 
-    const first = lrc.lines.at(0);
-    if (first && first.timeInMs > 300) {
-      lrc.lines.unshift({
-        time: '0:0:0',
-        timeInMs: 0,
-        duration: first.timeInMs,
-        text: '',
-      });
-    }
+    // leading padding line if the first line starts late
+    lrc.lines = ensureLeadingPaddingEmptyLine(lrc.lines, 300, 'span');
 
     // Merge consecutive empty lines into a single empty line
-    {
-      const merged: LRCLine[] = [];
-      for (const line of lrc.lines) {
-        const isEmpty = !line.text || !line.text.trim();
-        if (isEmpty && merged.length > 0) {
-          const prev = merged[merged.length - 1];
-          const prevEmpty = !prev.text || !prev.text.trim();
-          if (prevEmpty) {
-            const prevEnd = Number.isFinite(prev.duration)
-              ? prev.timeInMs + prev.duration
-              : Infinity;
-            const thisEnd = Number.isFinite(line.duration)
-              ? line.timeInMs + line.duration
-              : Infinity;
-            const newEnd = Math.max(prevEnd, thisEnd);
-            prev.duration = Number.isFinite(newEnd)
-              ? newEnd - prev.timeInMs
-              : Infinity;
-            continue;
-          }
-        }
-        merged.push(line);
-      }
-      lrc.lines = merged;
-    }
+    lrc.lines = mergeConsecutiveEmptySyncedLines(lrc.lines);
 
     return lrc;
   },
diff --git a/src/plugins/synced-lyrics/providers/LRCLib.ts b/src/plugins/synced-lyrics/providers/LRCLib.ts
@@ -2,6 +2,11 @@ import { jaroWinkler } from '@skyra/jaro-winkler';
 
 import { config } from '../renderer/renderer';
 import { LRC } from '../parsers/lrc';
+import {
+  ensureLeadingPaddingEmptyLine,
+  ensureTrailingEmptyLine,
+  mergeConsecutiveEmptySyncedLines,
+} from '../shared/lines';
 
 import type { LyricProvider, LyricResult, SearchSongInfo } from '../types';
 
@@ -162,67 +167,18 @@ export class LRCLib implements LyricProvider {
         ...l,
         status: 'upcoming' as const,
       }));
-
-      // Merge consecutive empty lines into a single empty line
-      const merged: typeof parsed = [];
-      for (const line of parsed) {
-        const isEmpty = !line.text || !line.text.trim();
-        if (isEmpty && merged.length > 0) {
-          const prev = merged[merged.length - 1];
-          const prevEmpty = !prev.text || !prev.text.trim();
-          if (prevEmpty) {
-            // extend previous duration to cover this line
-            const prevEnd = prev.timeInMs + prev.duration;
-            const thisEnd = line.timeInMs + line.duration;
-            const newEnd = Math.max(prevEnd, thisEnd);
-            prev.duration = newEnd - prev.timeInMs;
-            continue; // skip adding this line
-          }
-        }
-        merged.push(line);
-      }
-
-      // If the final merged line is not empty, append a computed empty line
-      if (merged.length > 0) {
-        const last = merged[merged.length - 1];
-        const lastIsEmpty = !last.text || !last.text.trim();
-        if (lastIsEmpty) {
-          // last line already empty, don't append another
-        } else {
-          // If duration is infinity (no following line), treat end as start for midpoint calculation
-          const lastEndCandidate = Number.isFinite(last.duration)
-            ? last.timeInMs + last.duration
-            : last.timeInMs;
-          const songEnd = songDuration * 1000;
-
-          if (lastEndCandidate < songEnd) {
-            const midpoint = Math.floor((lastEndCandidate + songEnd) / 2);
-
-            // update last duration to end at midpoint
-            last.duration = midpoint - last.timeInMs;
-
-            const minutes = Math.floor(midpoint / 60000);
-            const seconds = Math.floor((midpoint % 60000) / 1000);
-            const centiseconds = Math.floor((midpoint % 1000) / 10);
-            const timeStr = `${minutes.toString().padStart(2, '0')}:${seconds
-              .toString()
-              .padStart(2, '0')}.${centiseconds.toString().padStart(2, '0')}`;
-
-            merged.push({
-              timeInMs: midpoint,
-              time: timeStr,
-              duration: songEnd - midpoint,
-              text: '',
-              status: 'upcoming' as const,
-            });
-          }
-        }
-      }
+      const merged = mergeConsecutiveEmptySyncedLines(parsed);
+      const withLeading = ensureLeadingPaddingEmptyLine(merged, 300, 'span');
+      const finalLines = ensureTrailingEmptyLine(
+        withLeading,
+        'midpoint',
+        songDuration * 1000,
+      );
 
       return {
         title: closestResult.trackName,
         artists: closestResult.artistName.split(/[&,]/g),
-        lines: merged,
+        lines: finalLines,
       };
     } else if (plain) {
       // Fallback to plain if no synced
diff --git a/src/plugins/synced-lyrics/providers/MusixMatch.ts b/src/plugins/synced-lyrics/providers/MusixMatch.ts
@@ -1,6 +1,11 @@
 import * as z from 'zod';
 
 import { LRC } from '../parsers/lrc';
+import {
+  ensureLeadingPaddingEmptyLine,
+  ensureTrailingEmptyLine,
+  mergeConsecutiveEmptySyncedLines,
+} from '../shared/lines';
 import { netFetch } from '../renderer';
 
 import type { LyricProvider, LyricResult, SearchSongInfo } from '../types';
@@ -47,26 +52,13 @@ export class MusixMatch implements LyricProvider {
               (l) => ({ ...l, status: 'upcoming' as const }),
             );
 
-            // Merge consecutive empty lines into a single empty line
-            const merged: typeof parsed = [];
-            for (const line of parsed) {
-              const isEmpty = !line.text || !line.text.trim();
-              if (isEmpty && merged.length > 0) {
-                const prev = merged[merged.length - 1];
-                const prevEmpty = !prev.text || !prev.text.trim();
-                if (prevEmpty) {
-                  // extend previous duration to cover this line
-                  const prevEnd = prev.timeInMs + prev.duration;
-                  const thisEnd = line.timeInMs + line.duration;
-                  const newEnd = Math.max(prevEnd, thisEnd);
-                  prev.duration = newEnd - prev.timeInMs;
-                  continue; // skip adding this line
-                }
-              }
-              merged.push(line);
-            }
-
-            return merged;
+            const merged = mergeConsecutiveEmptySyncedLines(parsed);
+            const withLeading = ensureLeadingPaddingEmptyLine(
+              merged,
+              300,
+              'span',
+            );
+            return ensureTrailingEmptyLine(withLeading, 'lastEnd');
           })()
         : undefined,
       lyrics: lyrics,
diff --git a/src/plugins/synced-lyrics/providers/YTMusic.ts b/src/plugins/synced-lyrics/providers/YTMusic.ts
@@ -1,3 +1,9 @@
+import {
+  ensureLeadingPaddingEmptyLine,
+  ensureTrailingEmptyLine,
+  mergeConsecutiveEmptySyncedLines,
+} from '../shared/lines';
+
 import type { LyricProvider, LyricResult, SearchSongInfo } from '../types';
 import type { YouTubeMusicAppElement } from '@/types/youtube-music-app-element';
 
@@ -76,39 +82,20 @@ export class YTMusic implements LyricProvider {
       return null;
     }
 
-    if (synced?.length && synced[0].timeInMs > 300) {
-      synced.unshift({
-        duration: 0,
-        text: '',
-        time: '00:00.00',
-        timeInMs: 0,
-        status: 'upcoming' as const,
-      });
-    }
-
-    // ensure a final empty line exists
-    if (synced?.length) {
-      const last = synced[synced.length - 1];
-      const lastEnd = parseInt(last.timeInMs.toString()) + last.duration;
-
-      // youtube sometimes omits trailing silence, add our own
-      if (last.text !== '') {
-        synced.push({
-          duration: 0,
-          text: '',
-          time: this.millisToTime(lastEnd),
-          timeInMs: lastEnd,
-          status: 'upcoming' as const,
-        });
-      }
-    }
+    const processed = synced
+      ? (() => {
+          const merged = mergeConsecutiveEmptySyncedLines(synced);
+          const withLeading = ensureLeadingPaddingEmptyLine(merged, 300, 'span');
+          return ensureTrailingEmptyLine(withLeading, 'lastEnd');
+        })()
+      : undefined;
 
     return {
       title,
       artists: [artist],
 
       lyrics: plain,
-      lines: synced,
+      lines: processed,
     };
   }
 
