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

package/dist/index.js

@@ -1,5 +1,5 @@
-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 { lazy, DEFAULT_TAB_SIZE, resolveTextStyle, cachedLayoutRuns, blankGlyph, LineBox, doubles, graphemeCount, wrapLines, hangs, layoutRuns, tabAdvance, widthWithTabs } from './chunk-DOTR55MR.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-DOTR55MR.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, poseFrameOf, transformPath, PATH_M, PATH_L, PATH_Z, pathSignedArea, reversePath } from '@weasel-js/geom';
@@ -398,7 +398,7 @@ function decorationRule(kind, baselineY, fontSize, face) {
   const y0 = baselineY + fontSize * m.offset;
   return { y0, y1: y0 + fontSize * m.thickness };
 }
-function lineDecorations(glyphs, runs, faceOf, paintOf) {
+function lineDecorations(runs, faceOf, paintOf) {
   const rules = [];
   let open = null;
   const close = () => {
@@ -411,24 +411,28 @@ function lineDecorations(glyphs, runs, faceOf, paintOf) {
       rules.push({ kind, x0: s.x0, y0, x1: s.x1, y1, run: s.run });
     }
   };
-  for (const g of glyphs) {
-    const style = runs[g.run];
-    const paint = style.underline || style.strikethrough || style.overline ? paintOf(g.run) : null;
-    if (paint === null) {
-      close();
-      continue;
-    }
-    const face = faceOf(g.run);
-    const joins = open !== null && DECORATION_KINDS.every((kind) => open.style[kind] === style[kind]) && open.style.fontSize === style.fontSize && open.face === face && open.baselineY === g.baselineY && open.paint === paint;
-    if (joins) {
-      open.x1 = g.x + g.step;
-    } else {
+  return {
+    add(g) {
+      const style = runs[g.run];
+      const paint = style.underline || style.strikethrough || style.overline ? paintOf(g.run) : null;
+      if (paint === null) {
+        if (open !== null) close();
+        return;
+      }
+      const face = faceOf(g.run);
+      const joins = open !== null && DECORATION_KINDS.every((kind) => open.style[kind] === style[kind]) && open.style.fontSize === style.fontSize && open.face === face && open.baselineY === g.baselineY && open.paint === paint;
+      if (joins) {
+        open.x1 = g.x + g.step;
+      } else {
+        close();
+        open = { run: g.run, style, face, paint, baselineY: g.baselineY, x0: g.x, x1: g.x + g.step };
+      }
+    },
+    end() {
       close();
-      open = { run: g.run, style, face, paint, baselineY: g.baselineY, x0: g.x, x1: g.x + g.step };
+      return rules;
     }
-  }
-  close();
-  return rules;
+  };
 }
 
 // src/measure/verticalAlign.ts
@@ -527,28 +531,53 @@ function faceOutlineD(g) {
   if (g.resolved.source !== "outline" && g.glyph === null) return null;
   return glyphOutline(family, weight, style, g.cp);
 }
-function glyphQuad(g) {
+var QUAD_STRIDE = 9;
+function hasGlyphQuad(g) {
   const { font, glyph } = g;
-  if (font === null || glyph === null || glyph.width === 0 || glyph.page < 0) return null;
+  return font !== null && glyph !== null && glyph.width !== 0 && glyph.page >= 0;
+}
+function writeGlyphQuad(g, out, at) {
+  const font = g.font, glyph = g.glyph;
   const scale = g.fontSize / g.metrics.size;
   const x0 = g.x + glyph.xoffset * scale;
   const y0 = g.baselineY + (glyph.yoffset - g.metrics.base) * scale;
-  return {
-    x0,
-    y0,
-    x1: x0 + glyph.width * scale,
-    y1: y0 + glyph.height * scale,
-    u0: glyph.x / font.common.scaleW,
-    v0: glyph.y / font.common.scaleH,
-    u1: (glyph.x + glyph.width) / font.common.scaleW,
-    v1: (glyph.y + glyph.height) / font.common.scaleH,
-    baselineY: g.baselineY
-  };
-}
+  out[at] = x0;
+  out[at + 1] = y0;
+  out[at + 2] = x0 + glyph.width * scale;
+  out[at + 3] = y0 + glyph.height * scale;
+  out[at + 4] = glyph.x / font.common.scaleW;
+  out[at + 5] = glyph.y / font.common.scaleH;
+  out[at + 6] = (glyph.x + glyph.width) / font.common.scaleW;
+  out[at + 7] = (glyph.y + glyph.height) / font.common.scaleH;
+  out[at + 8] = g.baselineY;
+}
+var groupViews = {
+  quads: lazy("quads", (group) => {
+    const d = group.quadData;
+    const out = [];
+    for (let at = 0, k = 0; at < d.length; at += QUAD_STRIDE, k++) {
+      const q = {
+        x0: d[at],
+        y0: d[at + 1],
+        x1: d[at + 2],
+        y1: d[at + 3],
+        u0: d[at + 4],
+        v0: d[at + 5],
+        u1: d[at + 6],
+        v1: d[at + 7],
+        baselineY: d[at + 8]
+      };
+      if (group.colorGlyphs) q.colorGlyph = group.colorGlyphs[k];
+      out.push(q);
+    }
+    return out;
+  })
+};
 function runFaces(runs) {
   const faces = runs.map((r) => faceMetricsOf(resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle)));
   return (run) => faces[run];
 }
+var isDecorated = (r) => r.underline || r.strikethrough || r.overline;
 function groupFor(groups, g, run, source, last) {
   const { family, weight, style } = g.resolved.resolved;
   const { synthetic } = g.resolved;
@@ -569,7 +598,8 @@ function groupFor(groups, g, run, source, last) {
       page,
       fill: run.fill,
       ...stroke ? { stroke } : {},
-      quads: [],
+      quadData: [],
+      ...source === "color" ? { colorGlyphs: [] } : {},
       glyphs: []
     };
     groups.set(key, group);
@@ -599,10 +629,20 @@ function paintRuns(laid, runs, opts = {}) {
     page: 0
   };
   const decorations = [];
-  const faceOf = runFaces(runs);
+  const faceOf = runs.some(isDecorated) ? runFaces(runs) : null;
   const rulePaint = (run) => fillHasInk(runs[run].fill) ? paintKey(runs[run].fill.paint) : null;
+  const cursor = blankGlyph();
+  let glyphCount = 0;
+  for (const line of laid.lines) glyphCount += LineBox.count(line);
+  let sized = null;
+  let sizedAt = 0;
   for (const line of laid.lines) {
-    for (const g of line.glyphs) {
+    const span = LineBox.span(line);
+    const count = LineBox.count(line);
+    const rules = faceOf && lineDecorations(runs, faceOf, rulePaint);
+    for (let slot = 0; slot < count; slot++) {
+      const g = span ? span.cols.glyph(span.start, span.cols.visual(span.start, slot), cursor) : line.glyphs[slot];
+      rules?.add(g);
       const run = runs[g.run];
       const outline = glyphOutlineD(g, run, opts.outlineMinSize);
       if (!fillHasInk(run.fill) && !(outline !== null && strokeHasInk(run.stroke))) continue;
@@ -615,17 +655,31 @@ function paintRuns(laid, runs, opts = {}) {
         });
         continue;
       }
-      const quad = glyphQuad(g);
-      if (!quad) continue;
-      if (g.glyph?.color) groupFor(groups, g, run, "color", last).quads.push({ ...quad, colorGlyph: g.glyph });
-      else groupFor(groups, g, run, g.resolved.source, last).quads.push(quad);
+      if (!hasGlyphQuad(g)) continue;
+      const group = groupFor(groups, g, run, g.glyph.color ? "color" : g.resolved.source, last);
+      if (sized === null) {
+        sized = group;
+        group.quadData = doubles(glyphCount * QUAD_STRIDE);
+      }
+      const quads = group.quadData;
+      if (group === sized) {
+        writeGlyphQuad(g, quads, sizedAt);
+        sizedAt += QUAD_STRIDE;
+      } else {
+        writeGlyphQuad(g, quads, quads.length);
+      }
+      group.colorGlyphs?.push(g.glyph);
     }
-    for (const rule of lineDecorations(line.glyphs, runs, faceOf, rulePaint)) {
+    if (!rules) continue;
+    for (const rule of rules.end()) {
       const { run, ...rect } = rule;
       decorations.push({ ...rect, fill: runs[run].fill });
     }
   }
-  return { groups: [...groups.values()], decorations };
+  if (sized !== null) sized.quadData.length = sizedAt;
+  const out = [];
+  for (const group of groups.values()) out.push(Object.defineProperties(group, groupViews));
+  return { groups: out, decorations };
 }
 var PAINT_CACHE_VARIANT_LIMIT = 32;
 var own = /* @__PURE__ */ new WeakMap();
@@ -1370,7 +1424,7 @@ function emGlyph(d) {
 function placedGlyphOutline(g, dx, dy, caller, blankFallback = false) {
   const d = faceOutlineD(g);
   if (d === null) {
-    if (!blankFallback && glyphQuad(g) !== null) {
+    if (!blankFallback && hasGlyphQuad(g)) {
       const { family, weight, style } = g.resolved.resolved;
       throw new TextOutlinesError(
         "no-outlines",
@@ -1464,12 +1518,14 @@ function walkOutlines(data, pose, opts) {
   const rules = paints.map(() => []);
   const faceOf = runFaces(runs);
   for (const line of laid.lines) {
+    const deco = lineDecorations(runs, faceOf, (run) => String(paintOf[run]));
     for (const g of line.glyphs) {
+      deco.add(g);
       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]))) {
+    for (const r of deco.end()) {
       rules[paintOf[r.run]].push(ruleContour(r.x0 + dx, r.y0 + dy, r.x1 + dx, r.y1 + dy));
     }
   }
@@ -1545,6 +1601,6 @@ function textClusters(data, opts = {}) {
   });
 }
 
-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 };
+export { DEFAULT_DECORATION_METRICS, MARKDOWN_RUN_GRAMMAR, QUAD_STRIDE, 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