@nxtedition/lib 22.0.14 → 22.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "22.0.14",
+  "version": "22.0.15",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -34,7 +34,8 @@
     "worker.js",
     "stream.js",
     "timeline.js",
-    "docker-secrets.js"
+    "docker-secrets.js",
+    "wordwrap.js"
   ],
   "scripts": {
     "prepublishOnly": "pinst --disable",

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