@weasel-js/text 1.11.1 → 1.13.0-rc.0

package/dist/index.js

@@ -1,8 +1,8 @@
-import { DEFAULT_TAB_SIZE, resolveTextStyle, cachedLayoutRuns, graphemeCount, wrapLines, hangs, tabAdvance, widthWithTabs, layoutRuns } from './chunk-JOVZEHBJ.js';
-export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, cachedLayoutRuns, fontString, isHardLineBreak, layoutRuns, lineBreakOpportunities, paragraphDirection, registerBidi, resolveAlign, resolveTextStyle } from './chunk-JOVZEHBJ.js';
+import { DEFAULT_TAB_SIZE, resolveTextStyle, cachedLayoutRuns, graphemeCount, wrapLines, hangs, layoutRuns, tabAdvance, widthWithTabs } from './chunk-ADRQIIHS.js';
+export { BREAK_ALLOWED, BREAK_MANDATORY, DEFAULT_TEXT_FILL, DEFAULT_TEXT_STYLE, LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, NO_BREAK, cachedLayoutRuns, fontString, isHardLineBreak, layoutRuns, lineBreakOpportunities, paragraphDirection, registerBidi, resolveAlign, resolveTextStyle } from './chunk-ADRQIIHS.js';
 import { resolveScreenLength, fillHasInk, strokeHasInk, paintKey, strokeKey } from '@weasel-js/paint';
 import { faceMetricsOf, resolveFontVariant, syntheticBoldGrowth, glyphGeneration, loadFontOutlines, faceMetricsFor, glyphOutline, outlineStatus, cssFamilyName } from '@weasel-js/font';
-import { pathToD, pathFromD, mergeRegion, growRegion, transformPath, poseFrameOf, pathSignedArea, reversePath, PATH_M, PATH_L, PATH_Z } from '@weasel-js/geom';
+import { pathToD, pathFromD, mergeRegion, growRegion, poseFrameOf, transformPath, PATH_M, PATH_L, PATH_Z, pathSignedArea, reversePath } from '@weasel-js/geom';
 import { MIXED, deepEqual } from '@weasel-js/registry';
 export { MIXED } from '@weasel-js/registry';
 
@@ -1307,8 +1307,8 @@ var TextOutlinesError = class extends Error {
   family;
   weight;
   style;
-  constructor(reason, family, weight, style, detail) {
-    super(`textToPath: "${family}" ${weight}/${style} \u2014 ${detail}`);
+  constructor(reason, family, weight, style, detail, caller = "textToPath") {
+    super(`${caller}: "${family}" ${weight}/${style} \u2014 ${detail}`);
     this.name = "TextOutlinesError";
     this.reason = reason;
     this.family = family;
@@ -1316,22 +1316,10 @@ var TextOutlinesError = class extends Error {
     this.style = style;
   }
 };
-function facesOf(runs) {
-  const out = /* @__PURE__ */ new Map();
-  const add = (family, weight, style) => {
-    out.set(`${family}|${weight}|${style}`, { family, weight, style });
-  };
-  for (const r of runs) {
-    add(r.fontFamily, r.fontWeight, r.fontStyle);
-    const { family, weight, style } = resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle).resolved;
-    add(family, weight, style);
-  }
-  return [...out.values()];
-}
-function assertOutlinable(run) {
+function assertOutlinable(run, caller) {
   const { fontFamily, fontWeight, fontStyle } = run;
   const fail = (reason, detail) => {
-    throw new TextOutlinesError(reason, fontFamily, fontWeight, fontStyle, detail);
+    throw new TextOutlinesError(reason, fontFamily, fontWeight, fontStyle, detail, caller);
   };
   const requested = outlineStatus(fontFamily, fontWeight, fontStyle);
   if (requested === "idle" || requested === "loading") {
@@ -1353,6 +1341,21 @@ function assertOutlinable(run) {
     fail("outlines-failed", `the outlines registered for ${family} ${weight}/${style} failed to load.`);
   }
 }
+function paintsOf(runs) {
+  const paints = [];
+  const indexOf = /* @__PURE__ */ new Map();
+  const paintOf = runs.map((run) => {
+    const key = `${paintKey(run.fill?.paint)}|${strokeKey(run.stroke)}`;
+    let i = indexOf.get(key);
+    if (i === void 0) {
+      i = paints.length;
+      indexOf.set(key, i);
+      paints.push(run.stroke !== void 0 ? { fill: run.fill, stroke: run.stroke } : { fill: run.fill });
+    }
+    return i;
+  });
+  return { paints, paintOf };
+}
 var EM_CACHE_LIMIT = 4096;
 var emCache = /* @__PURE__ */ new Map();
 function emGlyph(d) {
@@ -1364,6 +1367,37 @@ function emGlyph(d) {
   emCache.set(d, p);
   return p;
 }
+function placedGlyphOutline(g, dx, dy, caller, blankFallback = false) {
+  const d = faceOutlineD(g);
+  if (d === null) {
+    if (!blankFallback && glyphQuad(g) !== null) {
+      const { family, weight, style } = g.resolved.resolved;
+      throw new TextOutlinesError(
+        "no-outlines",
+        family,
+        weight,
+        style,
+        "a fallback face serving some of the text's characters has no outlines registered.",
+        caller
+      );
+    }
+    return null;
+  }
+  const s = g.fontSize;
+  const shear = g.resolved.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
+  const m = [s, 0, -shear * s, s, g.x + dx, g.baselineY + dy];
+  return transformPath(emboldenGlyph(emGlyph(d), d, g.resolved), m);
+}
+function colorGlyphError(run, caller) {
+  return new TextOutlinesError(
+    "color-glyph",
+    run.fontFamily,
+    run.fontWeight,
+    run.fontStyle,
+    "the text holds an emoji, which is drawn in its own colors and has no outline.",
+    caller
+  );
+}
 function concat(parts) {
   let nc = 0, nk = 0;
   for (const p of parts) {
@@ -1381,20 +1415,26 @@ function concat(parts) {
   }
   return { kind: "polygon", commands, coords, fillRule: "nonzero" };
 }
-function ruleContour(x0, y0, x1, y1) {
-  return {
-    kind: "polygon",
-    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),
-    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),
-    fillRule: "nonzero"
+
+// src/textToPath.ts
+function facesOf(runs) {
+  const out = /* @__PURE__ */ new Map();
+  const add = (family, weight, style) => {
+    out.set(`${family}|${weight}|${style}`, { family, weight, style });
   };
+  for (const r of runs) {
+    add(r.fontFamily, r.fontWeight, r.fontStyle);
+    const { family, weight, style } = resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle).resolved;
+    add(family, weight, style);
+  }
+  return [...out.values()];
 }
-function walkOutlines(data, pose, opts) {
+function outlineLayoutInput(data, box, opts, caller) {
   const textPose = {
-    x: pose.x,
-    y: pose.y,
-    width: pose.width,
-    height: pose.height,
+    x: box.x,
+    y: box.y,
+    width: box.width,
+    height: box.height,
     text: data.text,
     runs: data.runs,
     style: data.style,
@@ -1402,20 +1442,21 @@ function walkOutlines(data, pose, opts) {
     fill: data.fill,
     stroke: data.stroke
   };
-  const { runs, opts: layoutOpts } = textPoseLayoutInput(textPose, opts.scale ?? 1);
-  for (const run of runs) assertOutlinable(run);
-  const paints = [];
-  const indexOf = /* @__PURE__ */ new Map();
-  const paintOf = runs.map((run) => {
-    const key = `${paintKey(run.fill?.paint)}|${strokeKey(run.stroke)}`;
-    let i = indexOf.get(key);
-    if (i === void 0) {
-      i = paints.length;
-      indexOf.set(key, i);
-      paints.push(run.stroke !== void 0 ? { fill: run.fill, stroke: run.stroke } : { fill: run.fill });
-    }
-    return i;
-  });
+  const input = textPoseLayoutInput(textPose, opts.scale ?? 1);
+  for (const run of input.runs) assertOutlinable(run, caller);
+  return input;
+}
+function ruleContour(x0, y0, x1, y1) {
+  return {
+    kind: "polygon",
+    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),
+    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),
+    fillRule: "nonzero"
+  };
+}
+function walkOutlines(data, pose, opts) {
+  const { runs, opts: layoutOpts } = outlineLayoutInput(data, pose, opts, "textToPath");
+  const { paints, paintOf } = paintsOf(runs);
   const laid = layoutRuns(runs, layoutOpts);
   const dx = pose.x;
   const dy = pose.y + verticalAlignOffset(data.verticalAlign, pose.height, laid.bounds.height);
@@ -1424,34 +1465,9 @@ function walkOutlines(data, pose, opts) {
   const faceOf = runFaces(runs);
   for (const line of laid.lines) {
     for (const g of line.glyphs) {
-      if (g.glyph?.color) {
-        const { fontFamily, fontWeight, fontStyle } = runs[g.run];
-        throw new TextOutlinesError(
-          "color-glyph",
-          fontFamily,
-          fontWeight,
-          fontStyle,
-          "the text holds an emoji, which is drawn in its own colors and has no outline."
-        );
-      }
-      const d = faceOutlineD(g);
-      if (d === null) {
-        if (glyphQuad(g) !== null) {
-          const { family, weight, style } = g.resolved.resolved;
-          throw new TextOutlinesError(
-            "no-outlines",
-            family,
-            weight,
-            style,
-            "a fallback face serving some of the text's characters has no outlines registered."
-          );
-        }
-        continue;
-      }
-      const s = g.fontSize;
-      const shear = g.resolved.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
-      const m = [s, 0, -shear * s, s, g.x + dx, g.baselineY + dy];
-      parts[paintOf[g.run]].push(transformPath(emboldenGlyph(emGlyph(d), d, g.resolved), m));
+      if (g.glyph?.color) throw colorGlyphError(runs[g.run], "textToPath");
+      const glyph = placedGlyphOutline(g, dx, dy, "textToPath");
+      if (glyph) parts[paintOf[g.run]].push(glyph);
     }
     for (const r of lineDecorations(line.glyphs, runs, faceOf, (run) => String(paintOf[run]))) {
       rules[paintOf[r.run]].push(ruleContour(r.x0 + dx, r.y0 + dy, r.x1 + dx, r.y1 + dy));
@@ -1487,7 +1503,48 @@ async function loadTextOutlines(data, opts = {}) {
   await Promise.all(facesOf(runs).map((f) => loadFontOutlines(f.family, { weight: f.weight, style: f.style })));
   await Promise.all(facesOf(runs).map((f) => loadFontOutlines(f.family, { weight: f.weight, style: f.style })));
 }
+var MIDDLE_FALLBACK = 0.25;
+function textClusters(data, opts = {}) {
+  const box = { x: 0, y: 0, width: opts.width ?? Infinity, height: 0 };
+  const { runs, opts: layoutOpts } = outlineLayoutInput(data, box, opts, "textClusters");
+  const line = layoutRuns(runs, layoutOpts).lines[0];
+  if (!line || line.cells.length === 0) return [];
+  const { paints, paintOf } = paintsOf(runs);
+  const glyphOf = new Array(line.cells.length);
+  for (const g of line.glyphs) glyphOf[g.cell] = g;
+  const groups = [];
+  let open = [];
+  line.cells.forEach((cell, i) => {
+    open.push(glyphOf[i]);
+    if (cell.clusterEnd || i === line.cells.length - 1) {
+      groups.push(open);
+      open = [];
+    }
+  });
+  const slots = groups.map((glyphs) => ({ glyphs, left: Math.min(...glyphs.map((g) => g.x)) })).sort((a, b) => a.left - b.left);
+  return slots.map(({ glyphs, left }, i) => {
+    const right = i + 1 < slots.length ? slots[i + 1].left : line.x1;
+    const parts = paints.map(() => []);
+    for (const g of glyphs) {
+      if (g.glyph?.color || !line.cells[g.cell].drawsInk) continue;
+      const outline = placedGlyphOutline(g, -left, -line.baselineY, "textClusters", true);
+      if (outline) parts[paintOf[g.run]].push(outline);
+    }
+    const paths = [];
+    parts.forEach((p, k) => {
+      if (p.length > 0) paths.push({ ...paints[k], path: concat(p) });
+    });
+    const first = glyphs[0];
+    const xHeight = faceMetricsOf(first.resolved)?.xHeight;
+    return {
+      x: left - line.x0,
+      advance: right - left,
+      paths,
+      middle: (xHeight === void 0 ? MIDDLE_FALLBACK : xHeight / 2) * first.fontSize
+    };
+  });
+}
 
-export { DEFAULT_DECORATION_METRICS, MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, SMALL_CAPS_SCALE, SYNTHETIC_ITALIC_RADIANS, TextOutlinesError, applyStyleToRange, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, emboldenGlyphD, fitTextPose, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, paintRuns, patchRangeStyle, pointInTextPose, rangeWeight, renderLabel, resolveRunFace, resolveRuns, runsCarryStyling, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, supersededKey, syntheticBoldOffset, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset };
+export { DEFAULT_DECORATION_METRICS, MARKDOWN_RUN_GRAMMAR, SCRIPT_METRICS, SMALL_CAPS_SCALE, SYNTHETIC_ITALIC_RADIANS, TextOutlinesError, applyStyleToRange, cachedPaintRuns, caretIndexAt, createMarkdownRenderer, decorationMetrics, defaultLabelTextRenderer, effectiveRangeStyle, emboldenGlyphD, fitTextPose, isBoldWeight, isSmallCapsLetter, isTextData, layoutMarkdown, layoutTextPose, loadTextOutlines, markdownToRuns, measureText, measureTextBounds, measuredWidth, nodeHasFlag, numericWeight, paintRuns, patchRangeStyle, pointInTextPose, rangeWeight, renderLabel, resolveRunFace, resolveRuns, runsCarryStyling, runsToMarkdown, runsToPlainText, scriptMetrics, scriptMetricsFor, setFlagOverRange, smallCapsScale, smallCapsScaleFor, smallCapsText, styleAtRange, supersededKey, syntheticBoldOffset, textClusters, textLineBoxes, textPoseLayoutInput, textToPath, textToPathsByPaint, toRuns, transformRunTexts, unboldPatch, verticalAlignOffset };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map