@nxtedition/lib 23.0.6 → 23.0.8

package/ass.js

@@ -1,36 +1,126 @@
+// @ts-check
 import fp from 'lodash/fp.js'
+import { wordwrap } from './wordwrap.js'
 
 const BASE_WIDTH = 1920
 const BASE_HEIGHT = 1080
 
-export function encodeASS(events, { styles = {}, width = BASE_WIDTH, height = BASE_HEIGHT } = {}) {
+/**
+ * @typedef {object} SubtitleEvent
+ * @property {number} start
+ * @property {number | null} [duration]
+ * @property {number | null} [end]
+ * @property {string | null} [style]
+ * @property {string | null} [text]
+ *
+ * @typedef {object} Styles
+ * @property {string} [name]
+ * @property {string} [fontname]
+ * @property {string} [fontsize]
+ * @property {string} [primaryColour]
+ * @property {string} [secondaryColour]
+ * @property {string} [outlineColour]
+ * @property {string} [backColour]
+ * @property {string} [bold]
+ * @property {string} [italic]
+ * @property {string} [underline]
+ * @property {string} [strikeOut]
+ * @property {string} [scaleX]
+ * @property {string} [scaleY]
+ * @property {string} [spacing]
+ * @property {string} [angle]
+ * @property {string} [borderStyle]
+ * @property {string} [outline]
+ * @property {string} [shadow]
+ * @property {string} [alignment]
+ * @property {string} [marginL]
+ * @property {string} [marginR]
+ * @property {string} [marginV]
+ * @property {string} [encoding]
+ *
+ * @typedef {object} Options
+ * @property {{ [styleName: string]: Styles }} [styles]
+ * @property {number} [width]
+ * @property {number} [height]
+ * @property {boolean} [scaledBorderAndShadow] TODO: default to true when all client styles depend on it?
+ * @property {boolean} [futureWordWrapping]
+ */
+
+/**
+ * @param {SubtitleEvent[]} events
+ * @param {Options} [options]
+ * @returns {string}
+ */
+export function encodeASS(
+  events,
+  {
+    styles = {},
+    width = BASE_WIDTH,
+    height = BASE_HEIGHT,
+    scaledBorderAndShadow = false,
+    futureWordWrapping = false,
+  } = {},
+) {
+  const scale = typeof width === 'number' ? BASE_WIDTH / width : 1
+  const playResX = scale * (width || BASE_WIDTH)
+  const playResY = scale * (height || BASE_HEIGHT)
   return [
-    encASSHeader({ width, height }),
-    encASSStyles({ styles, width, height }),
-    encASSEvents(events),
+    encASSHeader({ playResX, playResY, scaledBorderAndShadow, futureWordWrapping }),
+    encASSStyles(styles),
+    encASSEvents(events, styles, playResX, futureWordWrapping),
   ].join('\n')
 }
 
-function formatDialogues(events) {
+/**
+ * @param {SubtitleEvent[]} events
+ * @param {{ [styleName: string]: Styles }} styles
+ * @param {number} scriptResX
+ * @param {boolean} futureWordWrapping
+ */
+function formatDialogues(events, styles, scriptResX, futureWordWrapping) {
   let s = ''
   for (const { start, duration, end = duration != null ? start + duration : null, text, style } of [
     ...events,
   ].sort((a, b) => a.start - b.start)) {
+    const styleName = style || 'nxt-default'
+    const eventStyle = styles[styleName]
+    const fontSize = parseFloat(eventStyle.fontsize || '32')
+    const fontFamily = eventStyle.fontname ?? 'Arial'
+    const maxWidth = Math.max(
+      0,
+      scriptResX - parseFloat(eventStyle.marginL || '0') - parseFloat(eventStyle.marginR || '0'),
+    )
     if (typeof text === 'string' && text.length > 0 && Number.isFinite(start)) {
       s += `Dialogue: 0,${formatASSTime(start) || '0:00:00.00'},${
         formatASSTime(end) || '9:59:59.00'
-      },${style || 'nxt-default'},,0000,0000,0000,,${(text || '').replace(/\\n|\n/, '\\N')}\n`
+      },${styleName},,0000,0000,0000,,${text
+        .split(/\\n|\n|\\N/)
+        .map((line) => line.trim())
+        .flatMap((line) =>
+          futureWordWrapping ? wordwrap(line, fontSize, fontFamily, maxWidth) : [line],
+        )
+        .map((line) => line.trim())
+        .join('\\N')}`
     }
   }
   return s
 }
 
-function encASSEvents(events) {
+/**
+ * @param {SubtitleEvent[]} events
+ * @param {{ [styleName: string]: Styles }} styles
+ * @param {number} scriptResX
+ * @param {boolean} futureWordWrapping
+ */
+function encASSEvents(events, styles, scriptResX, futureWordWrapping) {
   return `[Events]
 Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-${formatDialogues(events)}`
+${formatDialogues(events, styles, scriptResX, futureWordWrapping)}`
 }
 
+/**
+ * @param {{ [styleName: string]: Styles }} styles
+ */
 const formatStyles = fp.pipe(
   fp.entries,
   fp.reduce((s, [id, style]) => {
@@ -87,40 +177,48 @@ const formatStyles = fp.pipe(
   }, ''),
 )
 
-function encASSStyles({ styles, width, height }) {
-  const scaledStyles = {}
-
-  for (const [id, style] of Object.entries(styles)) {
-    scaledStyles[id] = { ...style }
-    for (const key of ['fontsize', 'marginV', 'marginL', 'marginR']) {
-      const scale = key === 'fontsize' ? height / BASE_HEIGHT : width / BASE_WIDTH
-
-      if (typeof style[key] === 'string') {
-        const scaled = Number(style[key]) * scale
-        scaledStyles[id][key] = String(Math.round(scaled * 10) / 10)
-      }
-    }
-  }
-
+/**
+ * @param {Styles} styles
+ * @returns {string}
+ */
+function encASSStyles(styles) {
   return `[V4+ Styles]
 Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-${formatStyles(scaledStyles)}`
+${formatStyles(styles)}`
 }
 
-function encASSHeader({ width, height }) {
+/**
+ * @param {object} params
+ * @param {number} params.playResX
+ * @param {number} params.playResY
+ * @param {boolean} [params.scaledBorderAndShadow]
+ * @param {boolean} params.futureWordWrapping
+ */
+function encASSHeader({ playResX, playResY, scaledBorderAndShadow, futureWordWrapping }) {
   // WrapStyle
   // 0: smart wrapping, lines are evenly broken
   // 1: end-of-line word wrapping, only \N breaks
   // 2: no word wrapping, \n \N both breaks
   // 3: same as 0, but lower line gets wider.
-  return `[Script Info]
-ScriptType: v4.00+
-PlayResX: ${width || BASE_WIDTH}
-PlayResY: ${height || BASE_HEIGHT}
-WrapStyle: 1
-`
+  const header = [
+    '[Script Info]',
+    'ScriptType: v4.00+',
+    `PlayResX: ${playResX}`,
+    `PlayResY: ${playResY}`,
+    // new way is to not let ass wrap (2) -- we handle it ourselves
+    // to make sure hub and render gets the same result
+    `WrapStyle: ${futureWordWrapping ? 2 : 1}`,
+  ]
+  if (scaledBorderAndShadow) {
+    header.push('ScaledBorderAndShadow: Yes')
+  }
+  return `${header.join('\n')}\n`
 }
 
+/**
+ * @param {number | null | undefined} seconds
+ * @returns {string}
+ */
 function formatASSTime(seconds) {
   if (seconds == null) {
     return ''

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.0.6",
+  "version": "23.0.8",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -40,7 +40,8 @@
     "scheduler.js",
     "stream.js",
     "timeline.js",
-    "docker-secrets.js"
+    "docker-secrets.js",
+    "wordwrap.js"
   ],
   "scripts": {
     "prepublishOnly": "pinst --disable",
@@ -65,6 +66,7 @@
     "@elastic/transport": "^8.9.3",
     "@nxtedition/nxt-undici": "^6.0.0",
     "@swc/wasm-web": "^1.10.1",
+    "canvas": "^3.1.0",
     "content-type": "^1.0.5",
     "date-fns": "^3.6.0",
     "fast-querystring": "^1.1.1",

package/wordwrap.js

@@ -0,0 +1,128 @@
+// @ts-check
+import { createCanvas } from 'canvas'
+
+const canvas = createCanvas(0, 0)
+const ctx = canvas.getContext('2d')
+
+/**
+ * Takes a string and a maxWidth and splits the text into lines.
+ *
+ * @param {string} text
+ * @param {number} fontSize
+ * @param {string} fontFamily
+ * @param {number} maxWidth
+ */
+export function wordwrap(text, fontSize, fontFamily, maxWidth) {
+  // TODO: Register fonts
+  // const fontFile = name =>
+  //   path.join(path.dirname(__dirname), 'fonts', `${name}.ttf`)
+  // const ptSans = new Canvas.Font('PTSans', fontFile('ptsans-regular'))
+  // ctx.addFont(ptSans)
+
+  ctx.font = `${fontSize}px ${fontFamily}`
+  const emMeasure = ctx.measureText('M').width
+  const spaceMeasure = ctx.measureText(' ').width
+
+  if (maxWidth < emMeasure) {
+    // To prevent weird looping anamolies farther on.
+    return text.split('')
+  }
+
+  if (ctx.measureText(text).width < maxWidth) {
+    return [text]
+  }
+
+  const words = text.split(' ')
+  const metawords = []
+  const lines = []
+
+  // measure first.
+  for (const w in words) {
+    const word = words[w]
+    const measure = ctx.measureText(word).width
+
+    // Edge case - If the current word is too long for one line, break it into maximized pieces.
+    if (measure > maxWidth) {
+      // TODO - a divide and conquer method might be nicer.
+      const edgewords = splitWord(word, maxWidth)
+
+      // could use metawords = metawords.concat(edgwords)
+      for (const ew in edgewords) {
+        metawords.push(edgewords[ew])
+      }
+    } else {
+      metawords.push({ word, len: word.length, measure })
+    }
+  }
+
+  // build array of lines second.
+  let cline = ''
+  let cmeasure = 0
+  for (const mw in metawords) {
+    const metaword = metawords[mw]
+
+    // If current word doesn't fit on current line, push the current line and start a new one.
+    // Unless (edge-case): this is a new line and the current word is one character.
+    if (cmeasure + metaword.measure > maxWidth && cmeasure > 0 && metaword.len > 1) {
+      lines.push(cline)
+      cline = ''
+      cmeasure = 0
+    }
+
+    cline += metaword.word
+    cmeasure += metaword.measure
+
+    // If there's room, append a space, else push the current line and start a new one.
+    if (cmeasure + spaceMeasure < maxWidth) {
+      cline += ' '
+      cmeasure += spaceMeasure
+    } else {
+      lines.push(cline)
+      cline = ''
+      cmeasure = 0
+    }
+  }
+  if (cmeasure > 0) {
+    lines.push(cline)
+  }
+
+  return lines
+}
+
+/**
+ * @param {string} word
+ * @param {number} maxWidth
+ */
+function splitWord(word, maxWidth) {
+  const wlen = word.length
+  if (wlen === 0) {
+    return []
+  }
+
+  const awords = []
+  const letters = []
+  let cword = ''
+  let cmeasure = 0
+
+  // Measure each letter.
+  for (let l = 0; l < wlen; l += 1) {
+    letters.push({ letter: word[l], measure: ctx.measureText(word[l]).width })
+  }
+
+  // Assemble the letters into words of maximized length.
+  for (const ml in letters) {
+    const metaletter = letters[ml]
+
+    if (cmeasure + metaletter.measure > maxWidth) {
+      awords.push({ word: cword, len: cword.length, measure: cmeasure })
+      cword = ''
+      cmeasure = 0
+    }
+
+    cword += metaletter.letter
+    cmeasure += metaletter.measure
+  }
+  // there will always be one more word to push.
+  awords.push({ word: cword, len: cword.length, measure: cmeasure })
+  return awords
+}