@weasel-js/core 0.6.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,238 @@
 # Changelog
 
+## 0.7.1
+
+### Patch Changes
+
+- a3af158: Gestures are now keyed per pointer. `gestureIdFor` returned the literal string
+  `pointer-mouse` with nothing interpolated — despite its own docs promising
+  `pointer-<pointerId>` — so every pointer shared one in-flight handle slot and
+  two pointer gestures could not coexist. Pointer events carry `pointerId` now
+  and the id interpolates; events without one (synthetic probes, most tests)
+  still key to `pointer-mouse`.
+
+  That removes an accident the pinch path was relying on, so the multitouch
+  policy is stated rather than implied: when a second pointer lands, the
+  multitouch channel claims every pointer that hasn't already committed to a
+  gesture, suppressing both drags and taps from those pointers. A drag already in
+  flight keeps running — yanking a gesture away from someone who rested a palm is
+  worse than letting it finish.
+
+  `useTools` also reports routing conflicts now. `findConflicts` had been
+  written, tested, and never called, so the kit could detect its one class of
+  genuine routing ambiguity and never looked. It runs at registry assembly under
+  a dev guard and warns each conflict in the grammar the route was written in. It
+  warns and never throws: a consumer tool colliding with a kit tool can be
+  deliberate, since the loser may still take the gesture by declining through
+  `enabled()`.
+
+- a3af158: Scenes with many shapes or much text draw far less work per frame. Two caches
+  the kit already had were missing on essentially every node of every frame,
+  because the values they key on were rebuilt each time.
+
+  The tessellation cache (`WeakMap<Path, Mesh>`) keys on `Path` identity, but
+  `kit:shape` allocated a fresh path for every ellipse, polygon and star on every
+  draw. Painters now memoize `paint` against the node, so the same path comes
+  back and the cache does its job: 1000 shape nodes went from 6.69 to 0.20
+  ms/frame through paint and tessellation.
+
+  Text layout is the larger one. `layoutRuns` — which walks every codepoint,
+  resolves a face per run, measures, wraps and places each glyph — ran per text
+  command per frame. It is now cached in the renderer, keyed on the resolved
+  runs. 200 wrapped paragraphs went from 31.8 to 0.06 ms/frame, 1000 short
+  labels from 12.5 to 0.42. The cache drops itself when a font becomes
+  available, so text still reflows the moment the real face lands.
+
+  Two contracts follow from this, for anyone writing a custom painter or calling
+  these directly:
+
+  - The array a painter's `paint` returns belongs to the painter. Treat it as
+    immutable and copy before appending — `defaultDrawOne` now does, for its
+    label overlay.
+  - `registerFont` now notifies `subscribeGlyphReady` when a family finishes
+    registering, so a font loaded mid-session repaints without waiting for an
+    unrelated redraw. `glyphGeneration()` is a new pull-based companion to that
+    signal, for caches that can't hold a subscription.
+
+- 6af4806: Reorder: `Cmd/Ctrl+Shift+]` and `Cmd/Ctrl+Shift+[` now bring-to-front and
+  send-to-back. The shortcut every drawing app uses could never fire — modifier
+  matching is strict, so a binding without `shift` in its spec cannot match a
+  keystroke that holds it, which also made the shifted `'}'` / `'{'` characters
+  in those key lists unreachable. `Cmd+Alt+]` / `Cmd+Alt+[` remain as the
+  fallback for browsers that reserve `Cmd+Shift+[`/`]` for tab switching.
+
+  `BUNDLE_TOOLS.standard` no longer includes `pencil`. Freehand is a specialist
+  instrument rather than part of the everyday shape-drawing set; it is still in
+  `exhaustive`. Consumers wanting it back can pass `tools={{ pencil: true }}`
+  alongside the bundle.
+
+- a3af158: Clicks now land on the shape a node actually paints, not on its bounding box.
+  The pose rect is the wrong answer for anything that isn't a rectangle: a click
+  in a star's notch, in the corner outside an ellipse, or in the blank half of a
+  text box went to the node that merely bounds that point, burying whatever was
+  really underneath. `picking: 'shape'` had been available since it shipped and
+  was opt-in only because flipping it changes what a click selects.
+
+  Ink counts too, not just the boundary. A shape whose interior isn't filled —
+  an outlined rect, a pencil stroke, a bare line — is now grabbable along its
+  outline and not through its empty middle, which is the opposite of what a fill
+  test alone answers. Painters declare this through the new `NodeShapeEntry.ink`;
+  one that declares none is treated as filled, the previous behavior.
+
+  Pass `geometry={{ picking: 'pose' }}` to `SceneCanvas` for the old rect
+  behavior. Painters with no silhouette are unaffected either way, so nothing
+  becomes unreachable.
+
+- 2003597: Export `VERSION` — the kit version a build was compiled from, baked in at
+  build time. Apps can pair it with their own compile timestamp to report what
+  they're running (WeaselDraw now shows `0.7.0 · Jul 30` in its status bar).
+- Updated dependencies [6af4806]
+- Updated dependencies [a3af158]
+  - @weasel-js/font@0.7.1
+  - @weasel-js/geom@0.7.1
+  - @weasel-js/gestures@0.7.1
+  - @weasel-js/history@0.7.1
+  - @weasel-js/modes@0.7.1
+
+## 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

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[];