@nxtedition/lib 23.3.27 → 23.3.29

package/app.js

@@ -137,6 +137,10 @@ export function makeApp(appConfig, onTerminate) {
       } (module:${serviceModule}; instance:${serviceInstanceId}) worker:${serviceWorkerId} Node/${process.version}`) ??
     null)
 
+  if (isMainThread && serviceName) {
+    process.title = serviceName
+  }
+
   const dailyOffpeakTime = config.dailyOffpeakTime ?? getUTCRangeForLocalTime('00:00-04:00')
 
   if (dailyOffpeakTime) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.3.27",
+  "version": "23.3.29",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -40,6 +40,7 @@
     "scheduler.js",
     "stream.js",
     "timeline.js",
+    "transcript.js",
     "docker-secrets.js",
     "wordwrap.js"
   ],
@@ -65,9 +66,10 @@
     "@elastic/elasticsearch": "^8.17.1",
     "@elastic/transport": "^8.9.3",
     "@nxtedition/nxt-undici": "^6.2.2",
+    "@smithy/node-http-handler": "^4.0.4",
     "@swc/wasm-web": "^1.11.8",
-    "content-type": "^1.0.5",
     "date-fns": "^4.1.0",
+    "diff": "5.2.0",
     "fast-querystring": "^1.1.1",
     "hasha": "^6.0.0",
     "http-errors": "^2.0.0",
@@ -87,13 +89,13 @@
     "request-target": "^1.0.2",
     "smpte-timecode": "^1.3.6",
     "split-string": "^6.0.0",
-    "undici": "^7.4.0",
     "url-join": "^5.0.0",
     "xuid": "^4.1.5",
     "yocto-queue": "^1.2.0"
   },
   "devDependencies": {
     "@nxtedition/deepstream.io-client-js": ">=28.1.9",
+    "@types/diff": "^5.0.9",
     "@types/lodash": "^4.17.16",
     "@types/node": "^22.13.10",
     "eslint": "^9.22.0",

package/transcript.js

@@ -0,0 +1,215 @@
+import * as Diff from 'diff'
+import round from 'lodash/round.js'
+
+/**
+ * @type {{
+ *  start: number,
+ *  end: number,
+ *  text: string,
+ *  p?: number
+ * }} Word
+ */
+
+/**
+ * Aligns a new string of words to a reference list of timed words.
+ *
+ * Takes a list of reference words with associated timing information, and a new
+ * string that is similar (e.g., lightly edited). The function attempts to align
+ * the new words with the original ones, assigning interpolated timing data to
+ * each word in the new string based on the timing of the reference words.
+ *
+ * @param {string} textToAlign - A new string containing a similar sentence or phrase to align.
+ * @param {Word[]} referenceWords - List of words with timing information (e.g., from a transcript).
+ * @return {Word[]} An array of words from the new string, each annotated with estimated timing data.
+ */
+export function alignWords(textToAlign, referenceWords) {
+  // Use the Diff library to create a diff with minimal changes, based on text content only (ignore timing):
+  const patches = Diff.diffArrays(
+    referenceWords,
+    textToAlign
+      .split(' ')
+      .map((w) => w.trim())
+      .filter((w) => w.length > 0)
+      .map((w) => ({ text: w })),
+    {
+      comparator: (a, b) => a.text === b.text,
+    },
+  )
+
+  const patchQueue = [...patches]
+  const originalWordsQueue = [...referenceWords]
+
+  /** @type {Word[]} */
+  const targetWords = []
+
+  while (patchQueue.length > 0) {
+    const currentPatch = patchQueue.shift()
+    const nextPatch = patchQueue.at(0)
+    if (!currentPatch) {
+      continue
+    }
+
+    if (currentPatch.removed && nextPatch?.added) {
+      // REPLACE
+      patchQueue.shift() // NOTE: Skip next queue item, as we're handling it in this iteration.
+      originalWordsQueue.splice(0, currentPatch.count)
+      if (!validateTranscriptWords(currentPatch.value)) {
+        // NOTE: This check shouldn't be necessary, but acts as a type guard.
+        throw new Error('Expected words to be replaced to be valid, timed, transcript words')
+      }
+      targetWords.push(...assignTimingToReplacement(nextPatch.value, currentPatch.value))
+    } else if (currentPatch.added && currentPatch.value) {
+      // ADD
+      const wordAtChangeIndex = originalWordsQueue.at(0)
+      if (!wordAtChangeIndex) {
+        // HACK: Edge case: Only added words at the end. In this case we just add them with zero duration.
+        // Ideally we should try to split the timing of the previous words somehow.
+        const lastWord = targetWords.at(-1)
+        if (!lastWord) {
+          continue
+        }
+        for (const word of currentPatch.value) {
+          targetWords.push({
+            start: lastWord.end,
+            end: lastWord.end,
+            text: word.text,
+            p: 1,
+          })
+        }
+        continue
+      }
+      targetWords.push(...assignTimingToInsertion(wordAtChangeIndex, currentPatch.value))
+    } else if (currentPatch.removed) {
+      // REMOVE
+      originalWordsQueue.splice(0, currentPatch.count)
+    } else if (!currentPatch.removed && !currentPatch.added) {
+      // KEEP
+      targetWords.push(...originalWordsQueue.splice(0, currentPatch.count))
+    }
+  }
+
+  validateTranscriptWords(targetWords)
+
+  return targetWords
+}
+
+/**
+ * @param {Array<{ text: string }>} added
+ * @param {Word[]} removedWord
+ * @return {Word[]}
+ */
+function assignTimingToReplacement(added, removedWord) {
+  if (added.length === removedWord.length) {
+    // Same number of words. We assume timing is still valid,
+    // even if word lengths may have changed.
+    return added.map((addedWord, i) => ({
+      text: addedWord.text,
+      start: removedWord[i].start,
+      end: removedWord[i].end,
+      p: 1,
+    }))
+  }
+
+  // Different number of words, we interpolate the timing:
+  const firstRemovedWord = removedWord.at(0)
+  const lastRemovedWord = removedWord.at(-1)
+
+  if (!firstRemovedWord || !lastRemovedWord) {
+    throw new Error('Expected first and last removed word')
+  }
+
+  return interpolate({
+    start: firstRemovedWord.start,
+    end: lastRemovedWord.end,
+    text: added.map((word) => word.text).join(' '),
+  }).map((interpolatedWord) => ({
+    ...interpolatedWord,
+    p: 1,
+  }))
+}
+
+/**
+ * @param {Word} wordAtChangeIndex
+ * @param {Array<{ text: string }>} added
+ * @return {Word[]}
+ */
+function assignTimingToInsertion(wordAtChangeIndex, added) {
+  return added.map((word) => ({
+    ...word,
+    start: wordAtChangeIndex.start,
+    // NOTE:
+    // Currently, added (non-replaced) words always have zero duration.
+    // Could possibly detect if there is a gap available in the original timing,
+    // and use that somehow...
+    end: wordAtChangeIndex.start,
+    p: 1,
+  }))
+}
+
+/**
+ * @param {unknown} input
+ * @return {input is Word[]}
+ */
+function validateTranscriptWords(input) {
+  return (
+    Array.isArray(input) &&
+    input.every(
+      (word) =>
+        typeof word === 'object' &&
+        word !== null &&
+        'start' in word &&
+        typeof word.start === 'number' &&
+        'end' in word &&
+        typeof word.end === 'number' &&
+        'text' in word &&
+        typeof word.text === 'string' &&
+        'p' in word &&
+        typeof word.p === 'number',
+    )
+  )
+}
+
+const zeroTimeCharacters = ['\\s', '\\.', ',', ':', '!', '?', '\\(', '\\)'].join('')
+
+/**
+ * @param {object} args
+ * @param {string} args.text
+ * @param {number} args.start
+ * @param {number} args.end
+ * @return {Array<{ start: number; end: number; text: string }>}
+ */
+export function interpolate(args) {
+  let accumulatedCharacterCount = 0
+  const splitWords = args.text.split(' ').map((word) => {
+    return {
+      word,
+      timeUnits: word.replace(new RegExp(`[${zeroTimeCharacters}]`, 'gi'), '').length,
+    }
+  })
+
+  let totalTimeUnits = splitWords.reduce((acc, word) => acc + word.timeUnits, 0)
+
+  if (totalTimeUnits === 0) {
+    // Can happen if the "sentence" for some reason only contains punctuation.
+    // In that case it doesn't really matter which value we give totalTimeUnits,
+    // as long as it's not 0 (since it's the denominator below).
+    totalTimeUnits = 1
+  }
+
+  const secondsPerCharacter = (args.end - args.start) / totalTimeUnits
+
+  return splitWords.map((splitWord, splitWordIndex) => {
+    const start = round(args.start + secondsPerCharacter * accumulatedCharacterCount, 2)
+    accumulatedCharacterCount += splitWord.timeUnits
+    const end =
+      splitWordIndex === splitWords.length - 1
+        ? args.end
+        : round(args.start + secondsPerCharacter * accumulatedCharacterCount, 2)
+
+    return {
+      start,
+      end,
+      text: splitWord.word,
+    }
+  })
+}

package/util/template/nextpressions.js

@@ -158,6 +158,7 @@ export default function ({ ds, logger } = {}) {
         moment: (format, tz) => {
           // TODO (fix): Validate arguments...
           return (value) => {
+            value = moment(value)
             if (tz) {
               value = value.tz(tz)
             }