@weasel-js/core 0.5.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,153 @@
 # Changelog
 
+## 0.7.0
+
+### Minor Changes
+
+- d3e5597: Extract the MSDF glyph tier into a new `@weasel-js/font` package: font
+  registry, atlas parsing, glyph layout, runtime rasterization, and the SDF
+  text shader source. `@weasel-js/core` depends on it; `registerFont` is still
+  re-exported from `@weasel-js/core/renderer`, so existing call sites keep
+  working.
+
+  Unregistered font families now render in the default family with a one-time
+  warning instead of rendering nothing. Configure with
+  `setFontFallbackPolicy('substitute' | 'canvas' | 'none')` — `'none'`
+  restores the previous hard-miss behavior, and `'canvas'` rasterizes the real
+  typeface at runtime when the browser has it. A family the `'canvas'` policy
+  enrolled for itself stops being canvas-served once the policy changes; one
+  you name with `registerCanvasFont` is served under every policy, and
+  `isCanvasFont` reports that distinction — it answers "will the dynamic tier
+  serve this family right now", so an auto-enrolled family reads `false` under
+  `'substitute'` and `'none'`. The default
+  family may be a canvas-registered family, and when it cannot serve the
+  request either, the resulting blank text is reported with its own warning
+  naming the default family rather than failing silently. Requesting the
+  default family itself also warns — whether it is registered at a variant it
+  can't serve, or `setDefaultFontFamily` named a family that was never
+  registered at all; either way there is nothing left to fall back to. An app
+  that has registered no fonts and set no default stays silent, since that is
+  not a misconfiguration.
+
+  `ResolveResult.substituted` reports the substitution structurally, and
+  `ResolveResult.resolved` now
+  carries the matched `family` alongside `weight` and `style` — the full atlas
+  identity to pass to `getFont` / `textureCacheKey`.
+
+  Adds `listFonts()` for enumerating registered families.
+
+- a925117: Text antialiasing is derived from the screen-space derivative instead of a
+  constant.
+
+  Both SDF text shaders computed their smoothstep band from a fixed `u_aaWidth`
+  (0.05, set once per draw). A constant band cannot be correct at more than one
+  scale: at 16px it collapsed to well under a screen pixel, so glyph coverage
+  quantized to all-or-nothing and edges rendered as hard stair-steps; at display
+  sizes the same constant read mushy. `TEXT_FRAG_SRC` and `TEXT_FRAG_R8_SRC` now
+  take the band from `fwidth(sdfVal)`, which folds in font size, zoom, and DPR
+  together, with a small floor so a degenerate derivative can't reproduce the
+  aliased behavior.
+
+  This changes how all GL-rendered text looks — most visibly at UI sizes, where
+  it is the difference between binary and antialiased edges.
+
+  Breaking, for anyone driving the shaders directly:
+
+  - `u_aaWidth` is gone from both fragment sources and from `TEXT_SDF_UNIFORMS`.
+    There is no CPU-side AA knob to set; the shader derives it. Setting the
+    uniform was never useful — the kit only ever wrote 0.05 to it.
+
+- eeae450: A codepoint the atlas never baked now falls back to a real glyph instead of a
+  literal `?`.
+
+  Font fallback resolved at family granularity: `resolveFontVariant` picks one
+  tier for a whole run. But a baked MSDF atlas covers a fixed charset, so a run
+  served by a perfectly good atlas can still contain a character that atlas has
+  no glyph for — an em dash, a curly quote, anything outside the subset. Those
+  drew codepoint 63. That fabricates a character the author never wrote and is
+  indistinguishable from one they did; the committed text baseline read "Themed
+  editing ? magenta caret" for a full commit without anyone noticing.
+
+  `layoutRuns` now escalates the individual codepoint to the dynamic canvas
+  tier, which rasterizes from installed fonts and can usually serve it for real.
+  The escalated glyph gets its own draw group (different texture and shader) and
+  is scaled by its own atlas's bake size. When escalation isn't available the
+  character is skipped with a warning naming it, rather than substituted —
+  `.notdef` is what a text stack should draw here, and the BmFont format has no
+  such glyph.
+
+  New in `@weasel-js/font`:
+
+  - `resolveGlyphFallback(family, weight, style)` returns a canvas-tier
+    `ResolveResult` for per-codepoint escalation, or `null` when it isn't
+    available. Declines under the `'none'` fallback policy, which documents a
+    miss as a hard miss, and when there is no canvas to rasterize into (SSR)
+    rather than throwing into the layout pass.
+
+- e7d71c9: Text properties: node-level typography through the schema-driven panel, and
+  caret-range styling through a new tool options bar.
+
+  `TextStyle` and `StyledRun` gain `letterSpacing`, `underline`, and
+  `strikethrough`, with GL rendering, DOM-overlay, and SVG round-trips for all
+  three. `styleAtRange` / `applyStyleToRange` expose the run algebra publicly,
+  and `useTextEdit` gains `selection`, `rangeStyle`, and
+  `applyStyleToSelection`. Text nodes get Character and Paragraph schema
+  groups. New `ToolOptionsBar` component; `ToggleBar` renders indeterminate
+  segments via `mixedValues`.
+
+  Behavior changes worth knowing about:
+
+  - **`SelectionPanel` reads and writes node paths of any depth** (two or more
+    segments). It previously split at the first dot and read exactly one level,
+    so `data.style.fontSize` resolved to `data['style.fontSize']`.
+  - **The default `kit:text` painter paints a node's `runs`** when it has them,
+    instead of re-flattening `data.text`. Run styling was previously invisible
+    to anything drawn by the default scene layer.
+  - **`useTextEdit` no longer commits when focus moves into editing chrome**
+    (`isEditorChrome`), and commits on a pointerdown outside both the overlay
+    and that chrome. Its published `selection` survives focus leaving the
+    overlay — it clears on `startEdit` and when the edit ends. Without this a
+    character bar could not exist: clicking its controls ended the edit they
+    were there to change.
+  - **The edit overlay can scale with the view** (`TextEditScreenPose.zoom`),
+    keeping every metric on it — including run-level `fontSize` and
+    `letterSpacing` — in world units. Omitting `zoom` keeps the old
+    screen-pixel contract.
+  - **The canvas-2D measurement path counts tracking**, as the GL path already
+    did, so wrap points, `caretIndexAt`, and `fitTextPose` agree on tracked
+    text. This moves wrap points on any text with a non-zero `letterSpacing`.
+  - **The text tool enters edit on the box it inserts.**
+
+  Breaking-ish, in packages that have not been published with these paths:
+
+  - `splitNodePath` is removed from `@weasel-js/ui`'s public API — it was dead
+    and encoded the superseded one-level path model. `nodeValueAt` and
+    `setAtPath` are exported in its place.
+  - A text node's color leaf is now `data.style.fill` of the new `paint` kind
+    rather than `data.style.fill.color` of the `color` kind. `TextStyle.fill`
+    is a tagged union, so the old leaf read `undefined` off a gradient and
+    wrote a hybrid the renderer painted flat solid.
+
+### Patch Changes
+
+- Updated dependencies [d3e5597]
+- Updated dependencies [a925117]
+- Updated dependencies [eeae450]
+  - @weasel-js/font@0.7.0
+  - @weasel-js/geom@0.7.0
+  - @weasel-js/gestures@0.7.0
+  - @weasel-js/history@0.7.0
+  - @weasel-js/modes@0.7.0
+
+## 0.6.0
+
+### Patch Changes
+
+- @weasel-js/geom@0.6.0
+- @weasel-js/gestures@0.6.0
+- @weasel-js/history@0.6.0
+- @weasel-js/modes@0.6.0
+
 ## 0.5.1
 
 ### Patch Changes

package/dist/{DrawCommand-Dl0bXNfS.d.ts → DrawCommand-CJtqqt8H.d.ts}

@@ -242,6 +242,12 @@ interface TextStyle {
     selectionBackground?: string;
     /** Selection text color paired with `selectionBackground`. Default: inherits text color. */
     selectionColor?: string;
+    /** Extra advance added after each glyph, in world units. Default 0. */
+    letterSpacing?: number;
+    /** Default `false`. */
+    underline?: boolean;
+    /** Default `false`. */
+    strikethrough?: boolean;
 }
 /** `TextStyle` with all fields filled in from defaults — what the renderer actually consumes. */
 interface ResolvedTextStyle {
@@ -255,6 +261,9 @@ interface ResolvedTextStyle {
     caretColor: string;
     selectionBackground: string | null;
     selectionColor: string | null;
+    letterSpacing: number;
+    underline: boolean;
+    strikethrough: boolean;
 }
 /** Default resolved style used when a `TextPose` omits `style`. */
 declare const DEFAULT_TEXT_STYLE: ResolvedTextStyle;
@@ -281,6 +290,9 @@ interface StyledRun {
     fontFamily?: string;
     fontSize?: number;
     fill?: FillStyle;
+    letterSpacing?: number;
+    underline?: boolean;
+    strikethrough?: boolean;
 }
 declare function toRuns(input: string | StyledRun[]): StyledRun[];
 declare function runsToPlainText(runs: readonly StyledRun[]): string;
@@ -301,8 +313,14 @@ declare function markdownToRuns(input: string): StyledRun[];
  *
  * `bold`/`italic` toggles on a run are folded into `fontWeight`/`fontStyle`:
  * `bold: true` → fontWeight 700, `italic: true` → fontStyle 'italic'.
- * Explicit `fontFamily` / `fontSize` / `fill` on the run override the
- * node-level value.
+ * Explicit `fontFamily` / `fontSize` / `fill` / `letterSpacing` on the run
+ * override the node-level value (`letterSpacing: 0` on a run is an override,
+ * not an absence — it zeroes inherited tracking).
+ *
+ * `underline` / `strikethrough` are *additive*, like `bold`/`italic`: a run
+ * can turn a decoration on but never off, so they resolve as
+ * `run.x || style.x` and not `run.x ?? style.x`. See the header of
+ * `runs/rangeStyle.ts` for why the model collapses the tri-state.
  */
 
 interface ResolvedRun {
@@ -312,6 +330,12 @@ interface ResolvedRun {
     fontWeight: number;
     fontStyle: 'normal' | 'italic';
     fill: FillStyle;
+    /** Extra advance added after each glyph of this run, in world units. */
+    letterSpacing: number;
+    /** Draw a rule below this run's baseline. Additive over the node style. */
+    underline: boolean;
+    /** Draw a rule through this run's x-height. Additive over the node style. */
+    strikethrough: boolean;
 }
 declare function resolveRuns(runs: readonly StyledRun[], style: ResolvedTextStyle): ResolvedRun[];