@weasel-js/core 1.9.3 → 1.10.0

package/dist/features/text/textToPath.js

@@ -1,181 +0,0 @@
-import { SYNTHETIC_ITALIC_RADIANS as e } from "../../renderer/syntheticItalic.js";
-import { poseRotationOf as t } from "../../core/geometry/poseRotation.js";
-import { loadFontOutlines as n, outlineStatus as r, resolveFontVariant as i } from "@weasel-js/font";
-import { PATH_L as a, PATH_M as o, PATH_Z as s, pathFromD as c, pathSignedArea as l, reversePath as u, rotateAboutPoint as d, transformPath as f } from "@weasel-js/geom";
-import { layoutRuns as p, textPoseLayoutInput as m, verticalAlignOffset as h } from "@weasel-js/text";
-//#region src/features/text/textToPath.ts
-var g = class extends Error {
-	reason;
-	family;
-	weight;
-	style;
-	constructor(e, t, n, r, i) {
-		super(`textToPath: "${t}" ${n}/${r} — ${i}`), this.name = "TextOutlinesError", this.reason = e, this.family = t, this.weight = n, this.style = r;
-	}
-};
-function _(e) {
-	let t = /* @__PURE__ */ new Map(), n = (e, n, r) => {
-		t.set(`${e}|${n}|${r}`, {
-			family: e,
-			weight: n,
-			style: r
-		});
-	};
-	for (let t of e) {
-		n(t.fontFamily, t.fontWeight, t.fontStyle);
-		let { family: e, weight: r, style: a } = i(t.fontFamily, t.fontWeight, t.fontStyle).resolved;
-		n(e, r, a);
-	}
-	return [...t.values()];
-}
-function v(e) {
-	let { fontFamily: t, fontWeight: a, fontStyle: o } = e, s = (e, n) => {
-		throw new g(e, t, a, o, n);
-	}, c = r(t, a, o);
-	(c === "idle" || c === "loading") && (n(t, {
-		weight: a,
-		style: o
-	}), s("outlines-loading", "its outlines have not loaded yet; await loadTextOutlines first."));
-	let l = i(t, a, o), { family: u, weight: d, style: f } = l.resolved;
-	if (l.synthetic.bold && s("synthetic-bold", `drawn as a faux bold of ${u} ${d}/${f}, which has no geometry to embolden. Register outlines for the real bold face.`), l.source === "outline") return;
-	let p = r(u, d, f);
-	p === null && s("no-outlines", `served by ${u} ${d}/${f}, which has no outlines registered. Call registerFontOutlines for it.`), (p === "idle" || p === "loading") && (n(u, {
-		weight: d,
-		style: f
-	}), s("outlines-loading", `the outlines of ${u} ${d}/${f} have not loaded yet; await loadTextOutlines first.`)), p === "failed" && s("outlines-failed", `the outlines registered for ${u} ${d}/${f} failed to load.`);
-}
-var y = 4096, b = /* @__PURE__ */ new Map();
-function x(e) {
-	let t = b.get(e);
-	return t || (t = c(e), l(t) < 0 && (t = u(t)), b.size >= y && b.clear(), b.set(e, t), t);
-}
-function S(e) {
-	let t = 0, n = 0;
-	for (let r of e) t += r.commands.length, n += r.coords.length;
-	let r = new Uint8Array(t), i = new Float32Array(n), a = 0, o = 0;
-	for (let t of e) r.set(t.commands, a), a += t.commands.length, i.set(t.coords, o), o += t.coords.length;
-	return {
-		kind: "polygon",
-		commands: r,
-		coords: i,
-		fillRule: "nonzero"
-	};
-}
-function C(e, t, n, r) {
-	return {
-		kind: "polygon",
-		commands: new Uint8Array([
-			o,
-			a,
-			a,
-			a,
-			s
-		]),
-		coords: new Float32Array([
-			e,
-			t,
-			n,
-			t,
-			n,
-			r,
-			e,
-			r
-		]),
-		fillRule: "nonzero"
-	};
-}
-function w(e, t) {
-	return JSON.stringify([e, t ?? null]);
-}
-function T(n, r, i) {
-	let a = {
-		x: r.x,
-		y: r.y,
-		width: r.width,
-		height: r.height,
-		text: n.text,
-		runs: n.runs,
-		style: n.style,
-		verticalAlign: n.verticalAlign,
-		fill: n.fill,
-		stroke: n.stroke
-	}, { runs: o, opts: s } = m(a, i.scale ?? 1);
-	for (let e of o) v(e);
-	let c = [], l = /* @__PURE__ */ new Map(), u = o.map((e) => {
-		let t = w(e.fill, e.stroke), n = l.get(t);
-		n === void 0 && (n = c.length, l.set(t, n), c.push(e.stroke === void 0 ? { fill: e.fill } : {
-			fill: e.fill,
-			stroke: e.stroke
-		}));
-		let { stroke: r, ...i } = e;
-		return {
-			...i,
-			fill: {
-				fill: "solid",
-				color: `#${n.toString(16).padStart(6, "0")}`
-			}
-		};
-	}), _ = (e) => e !== null && "color" in e ? parseInt(e.color.slice(1), 16) : 0, y = p(u, {
-		...s,
-		outlineMinSize: 0
-	});
-	for (let e of y.groups) if (e.source !== "outline" && e.quads.length > 0) throw new g("no-outlines", e.family, e.weight, e.style, "a fallback face serving some of the text's characters has no outlines registered.");
-	let b = r.x, T = r.y + h(n.verticalAlign, r.height, y.bounds.height), E = c.map(() => []);
-	for (let t of y.groups) {
-		let n = E[_(t.fill)], r = t.synthetic.italic ? Math.tan(e) : 0;
-		for (let e of t.glyphs) {
-			let t = e.scale, i = [
-				t,
-				0,
-				-r * t,
-				t,
-				e.x + b,
-				e.baselineY + T
-			];
-			n.push(f(x(e.d), i));
-		}
-	}
-	for (let e of y.decorations) E[_(e.fill)].push(C(e.x0 + b, e.y0 + T, e.x1 + b, e.y1 + T));
-	let D = t(r);
-	return {
-		paints: c,
-		paths: E.map((e) => {
-			let t = S(e);
-			return !D || t.commands.length === 0 ? t : f(t, d(D.cx, D.cy, D.rotation));
-		})
-	};
-}
-function E(e, t, n = {}) {
-	return S(T(e, t, n).paths);
-}
-function D(e, t, n = {}) {
-	let { paints: r, paths: i } = T(e, t, n), a = [];
-	return r.forEach((e, t) => {
-		i[t].commands.length > 0 && a.push({
-			...e,
-			path: i[t]
-		});
-	}), a;
-}
-async function O(e, t = {}) {
-	let r = {
-		x: 0,
-		y: 0,
-		width: 0,
-		height: 0,
-		text: e.text,
-		runs: e.runs,
-		style: e.style
-	}, { runs: i } = m(r, t.scale ?? 1);
-	await Promise.all(_(i).map((e) => n(e.family, {
-		weight: e.weight,
-		style: e.style
-	}))), await Promise.all(_(i).map((e) => n(e.family, {
-		weight: e.weight,
-		style: e.style
-	})));
-}
-//#endregion
-export { g as TextOutlinesError, O as loadTextOutlines, E as textToPath, D as textToPathsByPaint };
-
-//# sourceMappingURL=textToPath.js.map

package/dist/features/text/textToPath.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"textToPath.js","names":["TextOutlinesError","family","weight","style","detail","reason","facesOf","out","add","r","runs","resolveFontVariant","assertOutlinable","run","fail","fontFamily","fontWeight","fontStyle","requested","outlineStatus","loadFontOutlines","status","EM_CACHE_LIMIT","emCache","emGlyph","p","d","pathFromD","pathSignedArea","reversePath","concat","nc","nk","parts","commands","coords","ci","ki","ruleContour","PATH_M","PATH_L","PATH_Z","x0","y0","x1","y1","paintKey","fill","stroke","walkOutlines","textPose","pose","data","resolved","layoutOpts","textPoseLayoutInput","opts","paints","indexOf","key","i","_stroke","rest","groupOf","laid","layoutRuns","g","dx","dy","verticalAlignOffset","shear","SYNTHETIC_ITALIC_RADIANS","glyph","s","m","transformPath","rot","poseRotationOf","path","rotateAboutPoint","textToPath","textToPathsByPaint","paths","paint","loadTextOutlines","f"],"sources":["../../../src/features/text/textToPath.ts"],"sourcesContent":["/**\n * Text as path geometry: the glyph outlines a text node draws, placed in\n * world space and composed into one `Path`. What \"Create Outlines\" replaces a\n * text node with, and what a Boolean op reads when a text node is an operand.\n *\n * The walk is `layoutRuns`', so the glyphs land exactly where the renderer's\n * outline tier puts them — same pen positions, same baselines, same synthetic\n * italic shear — but with the tier forced on for every glyph whatever its\n * size, and with paint set aside: unfilled text has outlines too.\n * `textToPathsByPaint` is the same walk, split by the paint each glyph wears.\n */\n\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\n\nimport {\n  loadFontOutlines, outlineStatus, resolveFontVariant, type FontStyle,\n} from '@weasel-js/font';\nimport {\n  layoutRuns, textPoseLayoutInput, verticalAlignOffset,\n  type ResolvedRun, type StyledRun, type TextPose, type TextStyle, type TextVerticalAlign,\n} from '@weasel-js/text';\nimport {\n  PATH_L, PATH_M, PATH_Z, pathFromD, pathSignedArea, reversePath, rotateAboutPoint,\n  transformPath, type Mat3, type PolygonPath,\n} from '@weasel-js/geom';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport type { PathInWorldPose } from 'features/paths/pathInWorld';\nimport { SYNTHETIC_ITALIC_RADIANS } from 'renderer/syntheticItalic';\n\n/** The fields of a text node's data that decide its glyph geometry, and the\n *  paint `textToPathsByPaint` splits it by. Paint never changes the geometry. */\nexport interface TextOutlineSource {\n  text: string;\n  runs?: readonly StyledRun[];\n  style?: TextStyle;\n  verticalAlign?: TextVerticalAlign;\n  /** The node's `data.fill`: `null` is no fill, absent the default black. */\n  fill?: FillStyle | null;\n  /** The node's `data.stroke`: absent or `null` is no stroke. */\n  stroke?: Stroke | null;\n}\n\n/** One paint's share of a text node's outlines — see {@link textToPathsByPaint}. */\nexport interface TextPaintPath {\n  /** The resolved fill these glyphs wear: the run's own, else the node's.\n   *  `null` for unfilled text, painted by its stroke alone. */\n  fill: FillStyle | null;\n  /** The resolved stroke — the run's own, else the node's — or absent. */\n  stroke?: Stroke;\n  /** World-space outlines, as {@link textToPath} builds them. */\n  path: PolygonPath;\n}\n\n/** A text node as {@link textToPath} reads it: its data and its pose. */\nexport interface TextNodeSource {\n  data: TextOutlineSource;\n  pose: PathInWorldPose;\n}\n\n/** Options for {@link textToPath}. */\nexport interface TextToPathOptions {\n  /** The view scale a `{ px }` `fontSize` or `letterSpacing` resolves\n   *  against, as for `textCommandFromPose`. Default 1. */\n  scale?: number;\n}\n\n/**\n * Why a text node has no outline geometry to give:\n *\n * - `'no-outlines'` — the face that serves it has no outlines registered\n *   (`registerFontOutlines`), so there is no geometry to read.\n * - `'outlines-loading'` — registered but not parsed yet. `loadTextOutlines`\n *   waits for it; the call has already started the load.\n * - `'outlines-failed'` — registered, and the bytes did not load or parse.\n * - `'synthetic-bold'` — the requested weight is faked from a lighter face.\n *   The renderer thickens the distance field for that, and a path has no\n *   field to thicken; emboldening geometry needs outline offsetting, which\n *   the kit does not have. Converting would silently lighten the text.\n */\nexport type TextOutlinesFailure =\n  | 'no-outlines'\n  | 'outlines-loading'\n  | 'outlines-failed'\n  | 'synthetic-bold';\n\n/** Thrown by {@link textToPath} when some run of the text has no outline\n *  geometry. Names the run's requested face. */\nexport class TextOutlinesError extends Error {\n  readonly reason: TextOutlinesFailure;\n  readonly family: string;\n  readonly weight: number;\n  readonly style: FontStyle;\n\n  constructor(reason: TextOutlinesFailure, family: string, weight: number, style: FontStyle, detail: string) {\n    super(`textToPath: \"${family}\" ${weight}/${style} — ${detail}`);\n    this.name = 'TextOutlinesError';\n    this.reason = reason;\n    this.family = family;\n    this.weight = weight;\n    this.style = style;\n  }\n}\n\n/** The face every run is set in, before and after variant resolution. */\nfunction facesOf(runs: readonly ResolvedRun[]): { family: string; weight: number; style: FontStyle }[] {\n  const out = new Map<string, { family: string; weight: number; style: FontStyle }>();\n  const add = (family: string, weight: number, style: FontStyle) => {\n    out.set(`${family}|${weight}|${style}`, { family, weight, style });\n  };\n  for (const r of runs) {\n    add(r.fontFamily, r.fontWeight, r.fontStyle);\n    const { family, weight, style } = resolveFontVariant(r.fontFamily, r.fontWeight, r.fontStyle).resolved;\n    add(family, weight, style);\n  }\n  return [...out.values()];\n}\n\nfunction assertOutlinable(run: ResolvedRun): void {\n  const { fontFamily, fontWeight, fontStyle } = run;\n  const fail = (reason: TextOutlinesFailure, detail: string): never => {\n    throw new TextOutlinesError(reason, fontFamily, fontWeight, fontStyle, detail);\n  };\n  const requested = outlineStatus(fontFamily, fontWeight, fontStyle);\n  if (requested === 'idle' || requested === 'loading') {\n    void loadFontOutlines(fontFamily, { weight: fontWeight, style: fontStyle });\n    fail('outlines-loading', 'its outlines have not loaded yet; await loadTextOutlines first.');\n  }\n  const r = resolveFontVariant(fontFamily, fontWeight, fontStyle);\n  const { family, weight, style } = r.resolved;\n  if (r.synthetic.bold) {\n    fail('synthetic-bold', `drawn as a faux bold of ${family} ${weight}/${style}, which has no ` +\n      'geometry to embolden. Register outlines for the real bold face.');\n  }\n  if (r.source === 'outline') return;\n  const status = outlineStatus(family, weight, style);\n  if (status === null) {\n    fail('no-outlines', `served by ${family} ${weight}/${style}, which has no outlines ` +\n      'registered. Call registerFontOutlines for it.');\n  }\n  if (status === 'idle' || status === 'loading') {\n    void loadFontOutlines(family, { weight, style });\n    fail('outlines-loading', `the outlines of ${family} ${weight}/${style} have not loaded yet; ` +\n      'await loadTextOutlines first.');\n  }\n  if (status === 'failed') {\n    fail('outlines-failed', `the outlines registered for ${family} ${weight}/${style} failed to load.`);\n  }\n}\n\n// Em-space glyph geometry, wound one way, keyed by the outline data itself so a\n// re-registered face cannot serve stale geometry. The cap bounds a document\n// that cycles through many faces.\nconst EM_CACHE_LIMIT = 4096;\nconst emCache = new Map<string, PolygonPath>();\n\n/** A glyph's em-space path, wound positive so glyphs from faces that disagree\n *  on winding — TrueType against CFF — still fill their overlaps under\n *  `'nonzero'`, and so do the decoration rules drawn across them. */\nfunction emGlyph(d: string): PolygonPath {\n  let p = emCache.get(d);\n  if (p) return p;\n  p = pathFromD(d);\n  if (pathSignedArea(p) < 0) p = reversePath(p);\n  if (emCache.size >= EM_CACHE_LIMIT) emCache.clear();\n  emCache.set(d, p);\n  return p;\n}\n\nfunction concat(parts: readonly PolygonPath[]): PolygonPath {\n  let nc = 0, nk = 0;\n  for (const p of parts) { nc += p.commands.length; nk += p.coords.length; }\n  const commands = new Uint8Array(nc);\n  const coords = new Float32Array(nk);\n  let ci = 0, ki = 0;\n  for (const p of parts) {\n    commands.set(p.commands, ci); ci += p.commands.length;\n    coords.set(p.coords, ki); ki += p.coords.length;\n  }\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n\nfunction ruleContour(x0: number, y0: number, x1: number, y1: number): PolygonPath {\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),\n    fillRule: 'nonzero',\n  };\n}\n\n/** Paint identity for grouping. Paint is plain data, so structural equality\n *  is exact — a gradient set on two runs separately is still one paint. */\nfunction paintKey(fill: FillStyle | null, stroke: Stroke | undefined): string {\n  return JSON.stringify([fill, stroke ?? null]);\n}\n\n/**\n * The one glyph walk behind both entry points. Each resolved run is repainted\n * with an opaque solid whose color is its paint group's index, so the layout's\n * own groups and decoration rules come back labeled with it; nothing else in\n * the layout reads paint once `outlineMinSize` is 0, so the geometry is what\n * it would be with no paint at all.\n */\nfunction walkOutlines(\n  data: TextOutlineSource,\n  pose: PathInWorldPose,\n  opts: TextToPathOptions,\n): { paints: { fill: FillStyle | null; stroke?: Stroke }[]; paths: PolygonPath[] } {\n  const textPose: TextPose = {\n    x: pose.x, y: pose.y, width: pose.width, height: pose.height,\n    text: data.text,\n    runs: data.runs as StyledRun[] | undefined,\n    style: data.style,\n    verticalAlign: data.verticalAlign,\n    fill: data.fill,\n    stroke: data.stroke,\n  };\n  const { runs: resolved, opts: layoutOpts } = textPoseLayoutInput(textPose, opts.scale ?? 1);\n  for (const run of resolved) assertOutlinable(run);\n\n  const paints: { fill: FillStyle | null; stroke?: Stroke }[] = [];\n  const indexOf = new Map<string, number>();\n  const runs = resolved.map((run): ResolvedRun => {\n    const key = paintKey(run.fill, run.stroke);\n    let i = indexOf.get(key);\n    if (i === undefined) {\n      i = paints.length;\n      indexOf.set(key, i);\n      paints.push(run.stroke !== undefined ? { fill: run.fill, stroke: run.stroke } : { fill: run.fill });\n    }\n    const { stroke: _stroke, ...rest } = run;\n    return { ...rest, fill: { fill: 'solid', color: `#${i.toString(16).padStart(6, '0')}` } };\n  });\n  const groupOf = (fill: FillStyle | null): number =>\n    fill !== null && 'color' in fill ? parseInt(fill.color.slice(1), 16) : 0;\n\n  const laid = layoutRuns(runs, { ...layoutOpts, outlineMinSize: 0 });\n  // A code point the run's own face lacks escalates to a fallback face, which\n  // the per-run check above never saw.\n  for (const g of laid.groups) {\n    if (g.source !== 'outline' && g.quads.length > 0) {\n      throw new TextOutlinesError('no-outlines', g.family, g.weight, g.style,\n        'a fallback face serving some of the text\\'s characters has no outlines registered.');\n    }\n  }\n\n  const dx = pose.x;\n  const dy = pose.y + verticalAlignOffset(data.verticalAlign, pose.height, laid.bounds.height);\n  const parts: PolygonPath[][] = paints.map(() => []);\n  for (const g of laid.groups) {\n    const out = parts[groupOf(g.fill)]!;\n    const shear = g.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;\n    for (const glyph of g.glyphs) {\n      const s = glyph.scale;\n      // The renderer's placement (`mergeGlyphMeshes`): x = pen + (ex - ey·shear)·s.\n      const m: Mat3 = [s, 0, -shear * s, s, glyph.x + dx, glyph.baselineY + dy];\n      out.push(transformPath(emGlyph(glyph.d), m) as PolygonPath);\n    }\n  }\n  for (const r of laid.decorations) {\n    parts[groupOf(r.fill)]!.push(ruleContour(r.x0 + dx, r.y0 + dy, r.x1 + dx, r.y1 + dy));\n  }\n\n  const rot = poseRotationOf(pose);\n  const paths = parts.map((p) => {\n    const path = concat(p);\n    if (!rot || path.commands.length === 0) return path;\n    return transformPath(path, rotateAboutPoint(rot.cx, rot.cy, rot.rotation)) as PolygonPath;\n  });\n  return { paints, paths };\n}\n\n/**\n * The outline geometry of a text node, in world space: every glyph and every\n * underline, strikethrough and overline rule it draws, as one `'nonzero'`\n * compound path whose filled region is their union. Glyphs keep the font's\n * curves; overlapping contours are not merged — run the result through\n * `pathUnion` for that, at the cost of flattening the curves.\n *\n * `pose` is the node's box and rotation. Synthetic italic is sheared exactly\n * as the renderer shears it. Throws {@link TextOutlinesError} when any run's\n * face cannot supply outlines — never returns a partial or empty path for\n * that. Text with no ink (empty, or only spaces) returns an empty path.\n */\nexport function textToPath(\n  data: TextOutlineSource,\n  pose: PathInWorldPose,\n  opts: TextToPathOptions = {},\n): PolygonPath {\n  return concat(walkOutlines(data, pose, opts).paths);\n}\n\n/**\n * {@link textToPath}, split by paint: one path per distinct resolved fill and\n * stroke, each gathering the glyphs and decoration rules that wear it — a\n * rule takes the fill of the run it underlines. Groups come in the order\n * their paint first appears in the text; a paint whose runs put down no ink\n * has none. Together the paths cover exactly what `textToPath` covers.\n *\n * Paint resolves as the renderer resolves it: a run's `fill` / `stroke`, else\n * the node's `data.fill` / `data.stroke` from `data`, else the default black\n * fill and no stroke. Throws as `textToPath` does.\n */\nexport function textToPathsByPaint(\n  data: TextOutlineSource,\n  pose: PathInWorldPose,\n  opts: TextToPathOptions = {},\n): TextPaintPath[] {\n  const { paints, paths } = walkOutlines(data, pose, opts);\n  const out: TextPaintPath[] = [];\n  paints.forEach((paint, i) => {\n    if (paths[i]!.commands.length > 0) out.push({ ...paint, path: paths[i]! });\n  });\n  return out;\n}\n\n/**\n * Load the outlines of every face `data` is set in — the requested faces and\n * the ones they resolve to — so a following {@link textToPath} does not fail\n * with `'outlines-loading'`. Resolves once each has loaded or failed.\n */\nexport async function loadTextOutlines(\n  data: TextOutlineSource,\n  opts: TextToPathOptions = {},\n): Promise<void> {\n  const textPose: TextPose = {\n    x: 0, y: 0, width: 0, height: 0,\n    text: data.text,\n    runs: data.runs as StyledRun[] | undefined,\n    style: data.style,\n  };\n  const { runs } = textPoseLayoutInput(textPose, opts.scale ?? 1);\n  await Promise.all(facesOf(runs).map((f) => loadFontOutlines(f.family, { weight: f.weight, style: f.style })));\n  // An outline-only family resolves to its own face only once that face has\n  // parsed; before, it resolved to whatever stood in. Ask again.\n  await Promise.all(facesOf(runs).map((f) => loadFontOutlines(f.family, { weight: f.weight, style: f.style })));\n}\n\n"],"mappings":"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"}