@nxtedition/lib 27.1.9 → 28.0.0

package/app.d.ts

@@ -10,7 +10,7 @@ export function makeApp<
   Records extends Record<string, unknown> = Record<string, unknown>,
   RpcMethods extends Record<string, RpcMethodDef> = Record<string, RpcMethodDef>,
   Config = Record<string, unknown>,
->(appConfig: AppConfig<Config>, meta?: { url: URL }): App<Records, RpcMethods, Config>
+>(appConfig: AppConfig<Config>, meta?: { url: string }): App<Records, RpcMethods, Config>
 
 export interface AppConfig<Config = Record<string, unknown>> {
   name?: string

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@nxtedition/lib",
-  "version": "27.1.9",
+  "version": "28.0.0",
   "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
   "files": [
     "index.d.ts",
     "hash.js",
-    "ass.js",
     "util/*",
     "cache.js",
     "fixed-queue.js",
@@ -40,7 +39,6 @@
     "stream.js",
     "transcript.js",
     "docker-secrets.js",
-    "wordwrap.js",
     "under-pressure.js"
   ],
   "scripts": {
@@ -92,5 +90,5 @@
     "pino": ">=7.0.0",
     "rxjs": "^7.0.0"
   },
-  "gitHead": "b9f4002d3dae6b3fd6c05c53d72d66653a697637"
+  "gitHead": "dca4323e9bb3624bdce93ed05e654c8892074f7d"
 }

package/ass.js

@@ -1,411 +0,0 @@
-// @ts-check
-import { wordwrap } from './wordwrap.js'
-
-const BASE_WIDTH = 1920
-const BASE_HEIGHT = 1080
-
-/**
- * @typedef {object} SubtitleEvent
- * @property {number} start
- * @property {number | null} [duration]
- * @property {number | null} [end]
- * @property {string | null} [style]
- * @property {string | null} [text]
- * @property {SubtitleEventStyleOverrides} [styleOverrides]
- *
- * @typedef {object} SubtitleEventStyleOverrides
- * @property {string} [marginL]
- * @property {string} [marginR]
- * @property {string} [marginV]
- * @property {string} [alignment]
- * @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]
- *
- * @typedef {object} EmbeddableSubtitleFontFace
- * @property {string} family
- * @property {string} name
- * @property {'normal'|'bold'} [weight]
- * @property {'normal'|'italic'} [style]
- * @property {Uint8Array} data
- *
- * @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]
- * @property {EmbeddableSubtitleFontFace[]} [fonts]
- */
-
-/**
- * @param {SubtitleEvent[]} events
- * @param {Options} [options]
- * @returns {string}
- */
-export function encodeASS(
-  events,
-  {
-    styles = {},
-    width = BASE_WIDTH,
-    height = BASE_HEIGHT,
-    scaledBorderAndShadow = false,
-    futureWordWrapping = false,
-    fonts = [],
-  } = {},
-) {
-  const scale = typeof width === 'number' ? BASE_HEIGHT / height : 1
-  const playResX = scale * (width || BASE_WIDTH)
-  const playResY = scale * (height || BASE_HEIGHT)
-  return [
-    encASSHeader({ playResX, playResY, scaledBorderAndShadow, futureWordWrapping }),
-    encFontFaces(fonts),
-    encASSStyles(styles),
-    '',
-    encASSEvents(events, styles, playResX, futureWordWrapping),
-  ]
-    .filter((x) => typeof x === 'string')
-    .join('\n')
-}
-
-/**
- * @param {SubtitleEvent[]} events
- * @param {{ [styleName: string]: Styles }} styles
- * @param {number} scriptResX
- * @param {boolean} futureWordWrapping
- */
-function formatDialogues(events, styles, scriptResX, futureWordWrapping) {
-  return [...events]
-    .sort((a, b) => a.start - b.start)
-    .map((event) => {
-      const {
-        start,
-        duration,
-        end = duration != null ? start + duration : null,
-        text,
-        style,
-        styleOverrides,
-      } = event
-
-      if (typeof text !== 'string' || text.length === 0 || typeof start !== 'number') {
-        return null
-      }
-
-      const styleName = style || 'nxt-default'
-      const eventStyle = styles[styleName] ?? {}
-      const textOptions = {
-        fontSize: parseFloat(eventStyle.fontsize || '32'),
-        fontFamily: eventStyle.fontname ?? 'Arial',
-        maxWidth: Math.max(
-          0,
-          scriptResX -
-            parseFloat(eventStyle.marginL || '0') -
-            parseFloat(eventStyle.marginR || '0'),
-        ),
-        styleOverrides,
-        futureWordWrapping,
-      }
-
-      return `Dialogue: ${[
-        /* Layer   */ '0',
-        /* Start   */ formatASSTime(start) || '0:00:00.00',
-        /* End     */ formatASSTime(end) || '9:59:59.00',
-        /* Style   */ styleName,
-        /* Name    */ '',
-        /* MarginL */ (styleOverrides?.marginL ?? '0').padStart(4, '0'),
-        /* MarginR */ (styleOverrides?.marginR ?? '0').padStart(4, '0'),
-        /* MarginV */ (styleOverrides?.marginV ?? '0').padStart(4, '0'),
-        /* Effect  */ '',
-        /* Text    */ encodeText(text, textOptions),
-      ]
-        .filter((s) => typeof s === 'string')
-        .join(',')}`
-    })
-    .join('\n')
-}
-
-/**
- * @param {string} text
- * @param {object} options
- * @param {number} options.fontSize
- * @param {string} options.fontFamily
- * @param {number} options.maxWidth
- * @param {SubtitleEventStyleOverrides} [options.styleOverrides]
- * @param {boolean} options.futureWordWrapping
- */
-function encodeText(text, { styleOverrides, futureWordWrapping, ...options }) {
-  return `${getOverrideTags(styleOverrides)}${text
-    .split(/\\n|\n|\\N/)
-    .map((line) => line.trim())
-    .flatMap((line) =>
-      futureWordWrapping ? wordwrap(line, { ...options, breakWord: false }) : [line],
-    )
-    .map((line) => line.trim())
-    .join('\\N')}`
-}
-
-/**
- * @param {SubtitleEventStyleOverrides} [styleOverrides]
- */
-function getOverrideTags(styleOverrides) {
-  return Object.entries(styleOverrides ?? {})
-    .map(([key, value]) => {
-      switch (key) {
-        case 'alignment':
-          return `an${value}`
-        case 'primaryColour':
-          return `c${value}`
-        case 'secondaryColour':
-          return `2c${value}`
-        case 'outlineColour':
-          return `3c${value}`
-        case 'backColour':
-          return `4c${value}`
-        case 'bold':
-          return `b${value === '0' ? '0' : '1'}`
-        case 'italic':
-          return `i${value === '0' ? '0' : '1'}`
-        case 'underline':
-          return `u${value === '0' ? '0' : '1'}`
-        case 'strikeOut':
-          return `s${value === '0' ? '0' : '1'}`
-        case 'fontname':
-          return `fn${value}`
-        case 'fontsize':
-          return `fs${value}`
-        default:
-          return null
-      }
-    })
-    .filter((tag) => typeof tag === 'string')
-    .map((tag) => `{\\${tag}}`)
-    .join('')
-}
-
-/**
- * @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, styles, scriptResX, futureWordWrapping)}\n`
-}
-
-/**
- * @param {{ [styleName: string]: Styles }} styles
- * @returns {string}
- */
-const formatStyles = (styles) =>
-  Object.entries(styles)
-    .map(([id, style]) =>
-      [
-        `Style: ${id}`,
-        style.fontname,
-        style.fontsize,
-        style.primaryColour,
-        style.secondaryColour,
-        style.outlineColour,
-        style.backColour,
-        style.bold,
-        style.italic,
-        style.underline,
-        style.strikeOut,
-        style.scaleX,
-        style.scaleY,
-        style.spacing,
-        style.angle,
-        style.borderStyle,
-        style.outline,
-        style.shadow,
-        style.alignment,
-        style.marginL,
-        style.marginR,
-        style.marginV,
-        style.encoding,
-      ]
-        .map((s) => s ?? '')
-        .join(','),
-    )
-    .join('\n')
-
-/**
- * @param {{ [styleName: string]: 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(styles)}`
-}
-
-/**
- * @param {object} params
- * @param {number} params.playResX
- * @param {number} params.playResY
- * @param {boolean} [params.scaledBorderAndShadow]
- * @param {boolean} params.futureWordWrapping
- * @returns {string}
- */
-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.
-  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 ''
-  }
-
-  const h = Math.floor(seconds / 3600)
-  seconds -= h * 3600
-  const m = Math.floor(seconds / 60)
-  seconds -= m * 60
-  const s = Math.floor(seconds)
-  const cs = Math.floor((seconds - s) * 100)
-
-  return (
-    h +
-    ':' +
-    (m === 0 ? '00' : m < 10 ? '0' + m : m) +
-    ':' +
-    (s === 0 ? '00' : s < 10 ? '0' + s : s) +
-    '.' +
-    (cs === 0 ? '00' : cs < 10 ? '0' + cs : cs)
-  )
-}
-
-/**
- * @param {EmbeddableSubtitleFontFace[]} fontFaces
- * @returns {string | undefined}
- */
-function encFontFaces(fontFaces) {
-  if (fontFaces.length === 0) {
-    return
-  }
-  return [
-    '[Fonts]',
-    ...fontFaces.map((fontFace) => {
-      return [`fontname: ${getFontName(fontFace)}`, ...uuencodeForSSA(fontFace.data)]
-    }),
-  ]
-    .filter((x) => x !== undefined)
-    .flat()
-    .join('\n')
-}
-
-/**
- * @param {EmbeddableSubtitleFontFace} fontFace
- */
-function getFontName(fontFace) {
-  const { name, family, weight, style } = fontFace
-  // NOTE: Seems like libass doesn't care about the font name as specified in the original spec.
-  // That is good, because then we can register more faces than the original spec allowed.
-  return name ?? `${family}_${weight === 'bold' ? 'B' : ''}${style === 'italic' ? 'I' : ''}0`
-}
-
-/**
- * UUEncode a binary file (e.g. font file) for SSA/ASS embedding.
- * @param {Uint8Array} data - Binary content of the file.
- * @returns {string[]} - Encoded lines, each max 80 characters.
- */
-function uuencodeForSSA(data) {
-  const result = []
-  const outputLineLength = 80
-
-  let i = 0
-  const fullChunks = Math.floor(data.length / 3)
-
-  // Encode 3-byte chunks
-  while (i < fullChunks * 3) {
-    const b1 = data[i++]
-    const b2 = data[i++]
-    const b3 = data[i++]
-    const n = (b1 << 16) | (b2 << 8) | b3
-
-    const c1 = ((n >> 18) & 0x3f) + 33
-    const c2 = ((n >> 12) & 0x3f) + 33
-    const c3 = ((n >> 6) & 0x3f) + 33
-    const c4 = (n & 0x3f) + 33
-
-    result.push(String.fromCharCode(c1, c2, c3, c4))
-  }
-
-  // Handle remainder
-  const remaining = data.length % 3
-  if (remaining === 1) {
-    const last = data[i] * 0x100
-    const c1 = ((last >> 10) & 0x3f) + 33
-    const c2 = ((last >> 4) & 0x3f) + 33
-    result.push(String.fromCharCode(c1, c2))
-  } else if (remaining === 2) {
-    const last = ((data[i] << 8) | data[i + 1]) * 0x10000
-    const c1 = ((last >> 16) & 0x3f) + 33
-    const c2 = ((last >> 10) & 0x3f) + 33
-    const c3 = ((last >> 4) & 0x3f) + 33
-    result.push(String.fromCharCode(c1, c2, c3))
-  }
-
-  // Break into 80-char lines
-  const finalLines = []
-  const allChars = result.join('')
-  for (let j = 0; j < allChars.length; j += outputLineLength) {
-    finalLines.push(allChars.slice(j, j + outputLineLength))
-  }
-
-  return finalLines
-}

package/wordwrap.js

@@ -1,130 +0,0 @@
-// @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 {object} options
- * @param {number} options.fontSize
- * @param {string} options.fontFamily
- * @param {number} options.maxWidth
- * @param {boolean} [options.breakWord]
- */
-export function wordwrap(text, { fontSize, fontFamily, maxWidth, breakWord = true }) {
-  // 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 (breakWord && 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
-}