@nxtedition/lib 23.3.28 → 23.3.30

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.28",
+  "version": "23.3.30",
   "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"
   ],
@@ -61,23 +62,24 @@
     "singleQuote": true
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.758.0",
+    "@aws-sdk/client-s3": "^3.796.0",
     "@elastic/elasticsearch": "^8.17.1",
     "@elastic/transport": "^8.9.3",
-    "@nxtedition/nxt-undici": "^6.2.2",
-    "@swc/wasm-web": "^1.11.8",
-    "content-type": "^1.0.5",
+    "@nxtedition/nxt-undici": "^6.3.4",
+    "@smithy/node-http-handler": "^4.0.4",
+    "@swc/wasm-web": "^1.11.22",
     "date-fns": "^4.1.0",
+    "diff": "5.2.0",
     "fast-querystring": "^1.1.1",
     "hasha": "^6.0.0",
     "http-errors": "^2.0.0",
     "json5": "^2.2.3",
     "koa-compose": "^4.1.0",
     "lodash": "^4.17.21",
-    "lru-cache": "^11.0.2",
-    "mime": "^4.0.6",
+    "lru-cache": "^11.1.0",
+    "mime": "^4.0.7",
     "mitata": "^1.0.34",
-    "moment-timezone": "^0.5.46",
+    "moment-timezone": "^0.5.48",
     "nconf": "^0.12.1",
     "nested-error-stacks": "^2.1.1",
     "object-hash": "^3.0.0",
@@ -87,30 +89,29 @@
     "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"
+    "yocto-queue": "^1.2.1"
   },
   "devDependencies": {
-    "@nxtedition/deepstream.io-client-js": ">=28.1.9",
+    "@nxtedition/deepstream.io-client-js": ">=28.1.15",
     "@types/lodash": "^4.17.16",
-    "@types/node": "^22.13.10",
-    "eslint": "^9.22.0",
-    "eslint-config-prettier": "^10.1.1",
+    "@types/node": "^22.15.1",
+    "eslint": "^9.25.1",
+    "eslint-config-prettier": "^10.1.2",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-n": "^17.16.2",
+    "eslint-plugin-n": "^17.17.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^7.2.1",
     "husky": "^9.1.7",
-    "lint-staged": "^15.3.0",
+    "lint-staged": "^15.5.1",
     "pinst": "^3.0.0",
     "prettier": "^3.5.3",
     "rxjs": "^7.8.2",
     "send": "^1.1.0",
     "tap": "^21.1.0",
-    "typescript-eslint": "^8.26.0"
+    "typescript-eslint": "^8.31.0"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.6.0",

package/time.js

@@ -1,6 +1,16 @@
-export function isTimeBetween(date, startTime, endTime) {
-  const currentHours = date.getHours()
-  const currentMinutes = date.getMinutes()
+export function isTimeBetween(date, startTime, endTime, isUTC) {
+  let currentHours = date.getHours()
+  let currentMinutes = date.getMinutes()
+
+  if (isUTC) {
+    currentHours = date.getUTCHours()
+    currentMinutes = date.getUTCMinutes()
+  } else {
+    // Convert local time to UTC equivalent
+    const utcDate = new Date(date.getTime() + date.getTimezoneOffset() * 60000)
+    currentHours = utcDate.getUTCHours()
+    currentMinutes = utcDate.getUTCMinutes()
+  }
 
   // Validate and parse start and end times
   if (!startTime) startTime = '00:00' // Default start at midnight
@@ -49,7 +59,9 @@ export function getUTCRangeForLocalTime(range) {
   // Validate input format (hh:mm-hh:mm)
   const timeFormat = /^\d{2}:\d{2}-\d{2}:\d{2}$/
   if (!timeFormat.test(range)) {
-    throw new Error("Invalid format. Use 'hh:mm-hh:mm' (e.g., '01:00-05:00').")
+    throw Object.assign(new Error("Invalid format. Use 'hh:mm-hh:mm' (e.g., '01:00-05:00')."), {
+      data: range,
+    })
   }
 
   const [startTime, endTime] = range.split('-')

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,
+    }
+  })
+}