add: implement meanings functionality with letrasmus source support

Author: 1Lucas1apk

config.default.js

@@ -384,6 +384,11 @@ export default {
       enabled: true
     }
   },
+  meanings: {
+    letrasmus: {
+      enabled: true
+    }
+  },
   audio: {
     quality: 'high', // high, medium, low, lowest
     encryption: 'aead_aes256_gcm_rtpsize',

src/api/meaning.js

@@ -1,97 +1,11 @@
 import myzod from 'myzod'
-import { translateMany, translateText } from '../modules/googleTranslate.js'
-import {
-  decodeTrack,
-  http1makeRequest,
-  logger,
-  sendErrorResponse
-} from '../utils.js'
+import { decodeTrack, logger, sendErrorResponse } from '../utils.js'
 
 const meaningSchema = myzod.object({
   encodedTrack: myzod.string(),
   lang: myzod.string().optional()
 })
 
-const decodeHtml = (text) => {
-  if (!text) return text
-  return text
-    .replace(/&/g, '&')
-    .replace(/"/g, '"')
-    .replace(/'/g, "'")
-    .replace(/'/g, "'")
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-}
-
-const extractMeta = (html, property) => {
-  const re1 = new RegExp(
-    `<meta[^>]+property=[\"']${property}[\"'][^>]+content=[\"']([^\"']+)[\"'][^>]*>`,
-    'i'
-  )
-  const re2 = new RegExp(
-    `<meta[^>]+content=[\"']([^\"']+)[^>]+property=[\"']${property}[\"'][^>]*>`,
-    'i'
-  )
-  const match = html.match(re1) || html.match(re2)
-  return match ? decodeHtml(match[1]) : null
-}
-
-const extractOmqLyric = (html) => {
-  const match = html.match(/_omq\.push\(\['ui\/lyric',\s*({[\s\S]*?})\s*,/i)
-  if (!match) return null
-  try {
-    return JSON.parse(match[1])
-  } catch {
-    return null
-  }
-}
-
-const extractOmqMeaning = (html) => {
-  const match = html.match(
-    /_omq\.push\(\['ui\/lyric',\s*({[\s\S]*?})\s*,\s*({[\s\S]*?})\s*,/i
-  )
-  if (!match) return null
-  try {
-    return JSON.parse(match[2])
-  } catch {
-    return null
-  }
-}
-
-const extractMeaning = (html) => {
-  const match = html.match(/<div class="lyric-meaning[^>]*">([\s\S]*?)<\/div>/i)
-  if (!match) return { title: null, body: [] }
-  let block = match[1]
-  const titleMatch = block.match(/<h3[^>]*>([\s\S]*?)<\/h3>/i)
-  const title = titleMatch ? decodeHtml(titleMatch[1].replace(/<[^>]+>/g, '')) : null
-  block = block.replace(/<h3[^>]*>[\s\S]*?<\/h3>/i, '')
-  const paragraphs = []
-  const pRegex = /<p[^>]*>([\s\S]*?)<\/p>/gi
-  let pMatch
-  while ((pMatch = pRegex.exec(block))) {
-    let text = pMatch[1]
-    text = text.replace(/<br\s*\/?>/gi, '\n')
-    text = text.replace(/<[^>]+>/g, '')
-    text = decodeHtml(text)
-    const lines = text
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean)
-    if (lines.length) paragraphs.push(lines.join(' '))
-  }
-  if (!paragraphs.length) {
-    let text = block.replace(/<br\s*\/?>/gi, '\n')
-    text = text.replace(/<[^>]+>/g, '')
-    text = decodeHtml(text)
-    const lines = text
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean)
-    if (lines.length) paragraphs.push(lines.join(' '))
-  }
-  return { title, body: paragraphs }
-}
-
 async function handler(nodelink, req, res, sendResponse, parsedUrl) {
   const result = meaningSchema.try({
     encodedTrack: parsedUrl.searchParams.get('encodedTrack'),
@@ -130,106 +44,56 @@ async function handler(nodelink, req, res, sendResponse, parsedUrl) {
   }
 
   try {
-    let trackInfo = decodedTrack.info
-    if (nodelink.sources?.resolve && decodedTrack.info?.uri) {
-      const resolved = await nodelink.sources.resolve(decodedTrack.info.uri)
-      if (resolved.loadType !== 'track') {
-        return sendResponse(
-          req,
-          res,
-          { loadType: 'empty', data: {} },
-          200
-        )
-      }
-      trackInfo = resolved.data?.info || resolved.data
-    }
-
-    if (!trackInfo || trackInfo.sourceName !== 'letrasmus') {
-      return sendResponse(
+    let delegated = false
+    if (nodelink.sourceWorkerManager) {
+      delegated = nodelink.sourceWorkerManager.delegate(
         req,
         res,
-        { loadType: 'empty', data: {} },
-        200
+        'loadMeaning',
+        {
+          decodedTrackInfo: decodedTrack.info,
+          language: targetLang
+        }
       )
     }
 
-    const baseUrl = trackInfo.uri?.endsWith('/')
-      ? trackInfo.uri
-      : `${trackInfo.uri}/`
-    const meaningUrl = `${baseUrl}significado.html`
-    const { body, statusCode, error } = await http1makeRequest(meaningUrl, {
-      method: 'GET'
-    }).catch((e) => ({ error: e }))
-
-    if (error || statusCode !== 200 || !body) {
-      return sendResponse(
+    if (delegated) return
+
+    let meaning
+    if (nodelink.workerManager) {
+      const worker = nodelink.workerManager.getBestWorker()
+      meaning = await nodelink.workerManager.execute(worker, 'loadMeaning', {
+        decodedTrackInfo: decodedTrack.info,
+        language: targetLang
+      })
+    } else if (nodelink.meanings?.loadMeaning) {
+      meaning = await nodelink.meanings.loadMeaning(decodedTrack, targetLang)
+    } else {
+      logger('error', 'Meaning', 'Meaning sources are not available.')
+      return sendErrorResponse(
         req,
         res,
-        { loadType: 'empty', data: {} },
-        200
+        503,
+        'meaning sources unavailable',
+        'Meaning sources are not available.',
+        parsedUrl.pathname,
+        true
       )
     }
 
-    const meaning = extractMeaning(body)
-    const omq = extractOmqLyric(body)
-    const meaningMeta = extractOmqMeaning(body)
-    const ogImage = extractMeta(body, 'og:image')
-    const ogTitle = extractMeta(body, 'og:title')
-    const ogDescription = extractMeta(body, 'og:description')
-
-    let translated = null
-    if (targetLang) {
-      const sourceLang = 'pt'
-      try {
-        const translatedParagraphs = await translateMany(
-          meaning.body,
-          sourceLang,
-          targetLang
-        )
-        const translatedTitle = meaning.title
-          ? await translateText(meaning.title, sourceLang, targetLang)
-          : null
-        const translatedDescription = ogDescription
-          ? await translateText(ogDescription, sourceLang, targetLang)
-          : null
-        translated = {
-          language: {
-            source: sourceLang,
-            target: targetLang
-          },
-          title: translatedTitle?.translation || null,
-          description: translatedDescription?.translation || null,
-          paragraphs: translatedParagraphs
-        }
-      } catch (e) {
-        logger('warn', 'Meaning', `Translate failed: ${e.message}`)
-      }
+    if (meaning?.loadType === 'error') {
+      return sendErrorResponse(
+        req,
+        res,
+        500,
+        'failed to load meaning',
+        meaning.data?.message || 'Failed to load meaning',
+        parsedUrl.pathname,
+        true
+      )
     }
 
-    return sendResponse(req, res, {
-      loadType: meaning.body.length ? 'meaning' : 'empty',
-      data: {
-        title: meaning.title || ogTitle || null,
-        description: ogDescription || null,
-        paragraphs: meaning.body,
-        translation: translated,
-        url: meaningUrl,
-        meaningMeta: {
-          id: meaningMeta?.ID || null,
-          localeId: meaningMeta?.LocaleID || null,
-          origin: meaningMeta?.Origin || null,
-          submittedBy: null,
-          reviewedBy: null
-        },
-        song: {
-          title: omq?.Name || trackInfo.title || null,
-          artist: omq?.Artist || trackInfo.author || null,
-          youtubeId: omq?.YoutubeID || null,
-          letrasId: omq?.ID || null,
-          artworkUrl: ogImage || trackInfo.artworkUrl || null
-        }
-      }
-    }, 200)
+    return sendResponse(req, res, meaning, 200)
   } catch (err) {
     logger('error', 'Meaning', `Failed to load meaning: ${err.message}`)
     return sendErrorResponse(

src/index.js

@@ -163,6 +163,7 @@ class NodelinkServer extends EventEmitter {
     this.sessions = new sessionManager(this, PlayerManagerClass)
     this.sources = null
     this.lyrics = null
+    this.meanings = null
 
     this._sourceInitPromise = this._initSources(isClusterPrimary, options)
 
@@ -226,13 +227,15 @@ class NodelinkServer extends EventEmitter {
 
   async _initSources(isClusterPrimary, _options) {
     if (!isClusterPrimary) {
-      const [{ default: sourceMan }, { default: lyricsMan }] =
+      const [{ default: sourceMan }, { default: lyricsMan }, { default: meaningMan }] =
         await Promise.all([
           import('./managers/sourceManager.js'),
-          import('./managers/lyricsManager.js')
+          import('./managers/lyricsManager.js'),
+          import('./managers/meaningManager.js')
         ])
       this.sources = new sourceMan(this)
       this.lyrics = new lyricsMan(this)
+      this.meanings = new meaningMan(this)
     }
   }
 
@@ -1543,6 +1546,7 @@ class NodelinkServer extends EventEmitter {
     if (this.sources && (!startOptions.isClusterPrimary || !specEnabled)) {
       await this.sources.loadFolder()
       await this.lyrics.loadFolder()
+      await this.meanings.loadFolder()
     }
 
     this._setupSocketEvents()