new tests for Typography

Author: williamngan

bench/baselines/node24-linux-x64-intel-core-i9-9820x-3-30ghz-chromium.json

@@ -160,6 +160,58 @@ export default defineSuite("canvas", (b, { Pts, fx }) => {
     },
   );
 
+  // Same workload with the heuristic width estimator instead of measureText,
+  // so both sides of the `fontWidthEstimate` toggle have a baseline.
+  draw(
+    "textBox (estimated width)",
+    SIZES.S,
+    () => ({
+      form: makeForm().fontWidthEstimate(true),
+      boxes: positive("canvas:textBox:est", SIZES.S).map((p) =>
+        Group.fromArray([p, [p[0] + 120, p[1] + 40]]),
+      ),
+      words: fx.words("canvas:textBox:est:words", SIZES.S, 20, 60),
+    }),
+    ({ form, boxes, words }) => {
+      for (let i = 0; i < SIZES.S; i++) form.textBox(boxes[i], words[i]);
+      sink(SIZES.S);
+    },
+  );
+
+  // Word wrap re-measures the remaining text for every line, so paragraphBox
+  // is the most expensive text call in the API. Small batch: each call wraps
+  // a few hundred characters into many lines.
+  draw(
+    "paragraphBox",
+    SIZES.XS,
+    () => ({
+      boxes: positive("canvas:paragraphBox", SIZES.XS).map((p) =>
+        Group.fromArray([p, [p[0] + 220, p[1] + 160]]),
+      ),
+      texts: fx.words("canvas:paragraphBox:texts", SIZES.XS, 240, 400),
+    }),
+    ({ form, boxes, texts }) => {
+      for (let i = 0; i < SIZES.XS; i++) form.paragraphBox(boxes[i], texts[i]);
+      sink(SIZES.XS);
+    },
+  );
+
+  draw(
+    "paragraphBox (estimated width)",
+    SIZES.XS,
+    () => ({
+      form: makeForm().fontWidthEstimate(true),
+      boxes: positive("canvas:paragraphBox:est", SIZES.XS).map((p) =>
+        Group.fromArray([p, [p[0] + 220, p[1] + 160]]),
+      ),
+      texts: fx.words("canvas:paragraphBox:est:texts", SIZES.XS, 240, 400),
+    }),
+    ({ form, boxes, texts }) => {
+      for (let i = 0; i < SIZES.XS; i++) form.paragraphBox(boxes[i], texts[i]);
+      sink(SIZES.XS);
+    },
+  );
+
   // Style changes force a context state write on every call, which is the
   // usual reason a colourful sketch is slower than a monochrome one.
   draw(

bench/baselines/node24-linux-x64-intel-core-i9-9820x-3-30ghz.json

@@ -54,6 +54,61 @@ export default defineSuite("typography", (b, { Pts, fx }) => {
     },
   });
 
+  // A measure whose cost grows with string length, like a host `measureText`.
+  // The flat-cost `measure` above times Typography's own overhead; this one
+  // shows how the truncate/wrap algorithms scale when every probe re-measures
+  // the whole remaining string.
+  const measurePerChar = (text) => {
+    let w = 0;
+    for (let i = 0; i < text.length; i++) w += 4 + (text.charCodeAt(i) % 8);
+    return w;
+  };
+
+  const paragraph = (label, chars) => {
+    const words = fx.words(label, 64, 3, 12);
+    let text = words[0];
+    for (let i = 1; text.length < chars; i++) {
+      text += " " + words[i % words.length];
+    }
+    return text;
+  };
+
+  b.case("Typography.truncate (long text, per-char measure)", {
+    batch: 32,
+    setupOnce: () => paragraph("typography:truncate:long", 2048),
+    run: (text) => {
+      let acc = 0;
+      for (let i = 0; i < 32; i++) {
+        acc += Typography.truncate(measurePerChar, text, 200 + i * 8, "...")[1];
+      }
+      sink(acc);
+    },
+  });
+
+  // The line-consumption loop inside `CanvasForm.paragraphBox`: truncate the
+  // remaining text to one line's width, cut at the last space, repeat.
+  // Re-measuring the whole remainder for every line makes this the quadratic
+  // hot path in text-heavy sketches, so it gets its own baseline.
+  b.case("paragraph wrap loop (per-char measure)", {
+    batch: 4,
+    setupOnce: () => paragraph("typography:wrap", 2048),
+    run: (text) => {
+      let lines = 0;
+      for (let k = 0; k < 4; k++) {
+        let sub = text;
+        for (let guard = 0; sub && guard < 10000; guard++) {
+          const t = Typography.truncate(measurePerChar, sub, 320, "");
+          let dt = t[0].lastIndexOf(" ") + 1;
+          if (dt <= 0 || t[1] === sub.length) dt = undefined;
+          lines++;
+          if (t[1] <= 0 || t[1] === sub.length) break;
+          sub = sub.substring(dt ?? t[1]);
+        }
+      }
+      sink(lines);
+    },
+  });
+
   b.case("Typography.fontSizeToBox (build)", {
     batch: N,
     setupOnce: () =>