@weasel-js/core 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,213 @@
 # Changelog
 
+## 1.0.4
+
+### Patch Changes
+
+- da7c150: The solid batch stops re-sending index data a ring slot already holds, and
+  `u_color` / `u_alpha` join the per-frame uniform cache.
+
+  A run of rects has indices that are a pure function of the rect count, so a
+  slot coming round to the same count already holds the right bytes. A mesh's
+  indices are rebased onto the staged vertices and a respecified buffer keeps
+  nothing, so both mark the slot as holding no pattern and the next flush writes.
+
+  `u_color` and `u_alpha` were excluded from `UploadedUniforms` because several
+  places wrote them directly. All of those now go through `setColorUniform` /
+  `setAlphaUniform`, which makes the cache correct per program rather than
+  dependent on knowing which caller uses which — the batch holds `u_color` at
+  white forever and was re-sending it once per flush.
+
+  Measured together on an M2 Max via ANGLE (`tests/perf/clip-cost.spec.ts`): a
+  flush 5.39 -> 3.22 us, entering a clip 12.47 -> 9.53. Read the difference, not
+  the absolutes — the same spec measured a 4.35 us flush earlier on a cooler
+  machine, and only the two halves of one A/B are comparable.
+
+- f7df982: Path booleans keep holes, and Bezier flattening terminates on degenerate input
+
+  `pathToMultiPolygon` emitted every contour of a path as its own polygon.
+  `polygon-clipping` unions the polygons of a MultiPolygon, so a donut lost its
+  hole the moment it entered any boolean op — `pathUnion`, `pathIntersect`,
+  `pathSubtract`, `pathExclude`, `pathDivide` and `pathCrop` all returned a
+  filled disc. The path's `fillRule` was never read. Contours are now resolved
+  into outer + hole rings by nesting depth, honoring both `nonzero` and
+  `evenodd`, before the clipper sees them.
+
+  Results of a boolean op on a path with holes change shape, so this can move
+  pixels.
+
+  `flattenCubic`, `flattenQuadratic` and their arc-length variants recursed
+  forever on a non-finite control point and on a tolerance of `0`, `NaN`, or a
+  negative number — the flatness test can never be satisfied, so a stroke or a
+  hit-test on a path carrying a `NaN` coordinate blew the stack. Non-finite
+  input now emits the segment endpoint and stops; a non-positive tolerance is
+  floored at `1e-6`.
+
+- 85be764: Fix four renderer bugs found in a review of `packages/core/src/renderer`.
+
+  - A stroke carrying per-anchor `vertexColors` never set the stencil test
+    before its draw. Inside a clipped group it ignored the clip and wrote clip
+    bits of its own; drawn after a clipped group it was tested against a bit
+    that had just been cleared and disappeared entirely.
+  - `GroupState` was never reset between frames, so a frame that threw part-way
+    down the tree (the max-7 clip nesting error, for one) left every enclosing
+    group's transform, alpha and color matrix on the stack and shifted every
+    later frame.
+  - `dispose()` never deleted the pattern-fill program.
+  - `GLTextureCache` applied a texture's wrap mode on first upload only, so a
+    registered image used as both a clamped shader texture and a repeating
+    pattern tile got whichever mode reached it first.
+
+  Also: re-registering a custom shader program on a renderer now deletes the
+  program it replaces instead of orphaning it.
+
+- a3db906: Correctness pass over the tools, canvas, interactions and affordances layers.
+
+  Fixed, each with a test: a UI-driven ongoing action (color/opacity pickers)
+  committed a second time when `cancelAll` had already ended its handle; the
+  `align.*` and `distribute.*` descriptors reported themselves permanently
+  disabled, greying out every `<ActionBar>` entry; `reorder.backward`,
+  `align.*`, `distribute.*` and `pathfinder.*` read deps they never declared in
+  `requires`, which throws in dev builds and silently bypasses a consumer's
+  history in production; `ActionsRegistry.begin` ignored `requires` and so never
+  passed the paint actions their `applyOps`; `Canvas.hitTestExtras` handed
+  registered layers `undefined` where `draw` gets live data, making
+  `composeAffordanceLayer`'s hit-test throw; `<Canvas>` never disposed its GL
+  renderer on unmount; `useTools` returned a stale registry when a tool was
+  added after mount; an `actions` prop override deleted the default action it
+  merged onto when the prop object was rebuilt; picking and marquee selected
+  nodes on hidden layers; a throwing drop-zone `onDrop` stranded every later
+  pointer drag; `snapBackOrDelete`'s `'snap-back'` policy left the node where it
+  was dropped; a cancelled pen handle-drag left the anchor it placed; and anchor
+  affordances on a second selected path routed their drag into the path actually
+  being edited.
+
+  Removed as unreachable: `useViewportTools`, `Canvas.previewBoundsExtra`,
+  `marqueeDrawCommands`, `applyHitExistingGate`, and the `enableKeyboard` options
+  on `useAlign` / `useDistribute`, which documented a registration those hooks do
+  not perform — `useStandardActions` owns it. The public `InsertOverlayStyle`
+  type `marqueeDrawCommands` carried is unchanged and still exported.
+
+- 12303bc: The solid batch no longer rewrites one pair of GL buffers on every flush. It
+  cycles a ring of buffer sets instead — 64 slot-sized ones, plus 4 growable ones
+  for a flush too big for a slot — so a write lands that many draws behind the
+  draw that read the same buffer. On an M2 Max via ANGLE a flush goes from ~54 us
+  to ~4.4, which is the cost anything that breaks a run of solid geometry was
+  paying: entering a clip is 64.9 us -> 10.2, and a boundary between solid and any
+  other command kind is 28.4 us -> 2.5. Measured by `tests/perf/clip-cost.spec.ts`
+  and `tests/perf/transition-matrix.spec.ts`.
+
+  The driver tracks a write hazard per buffer object, so a flush that overwrote
+  its buffers from offset 0 waited on the draw still reading them. Writing
+  disjoint ranges of one buffer does not escape that — the hazard is per object,
+  not per range.
+
+  Nothing about the API or the pixels changes. Buffers are taken on first use
+  rather than at construction, so a renderer that never draws solid geometry
+  allocates none, and every set is freed in `WeaselRenderer.dispose`.
+
+- d36953e: SVG import and export lose less on the way through, and installed fonts pick
+  one face per variant slot.
+
+  Paint servers are now found wherever they are declared, not just as direct
+  children of `<defs>`, and a gradient that inherits another's stops or geometry
+  through `href` / `xlink:href` resolves instead of coming back empty.
+  Percentages are read as ratios, so `x2="100%"` no longer means 100 bounds
+  units, and `gradientTransform` warns rather than silently painting elsewhere.
+
+  Three fidelity bugs in the round trip itself. A leaf's own `transform` was
+  decomposed against bounds that had already been through the inherited matrix,
+  so a rotation inside a translated `<g>` lost its rotation and moved. Any
+  stroke carrying `stroke-opacity` re-serialized with the attribute written
+  twice, which is not well-formed XML. And the computed `viewBox` was taken from
+  unrotated, untransformed geometry, cropping rotated content out of the export.
+
+  `<text>` now follows SVG's whitespace rules, so importing a pretty-printed
+  file no longer drags the source indentation into the document text; weasel's
+  own `<text>` carries `xml:space="preserve"` to keep real line breaks. A nested
+  `<svg x= y=>` places its children at that origin.
+
+  In the shared `d=` grammar, exponent coordinates (`M1e2 1e2`) no longer read
+  the `e` as a command, and arc flags written without separators
+  (`A5 5 0 0110 0`) no longer drop the arc.
+
+  `enableLocalFontOutlines` picks the least-qualified face when several installed
+  faces reduce to one (weight, style) slot, so "Helvetica Neue Condensed Bold"
+  stops displacing "Helvetica Neue Bold" depending on query order.
+
+  **Exported SVG bytes change**: `<text>` gains `xml:space="preserve"`, a stroke
+  writes `stroke-opacity` once, and a document containing rotated or
+  group-transformed content gets a larger computed `viewBox`.
+
+- Updated dependencies [bd42540]
+- Updated dependencies [d36953e]
+  - @weasel-js/geom@1.0.4
+  - @weasel-js/history@1.0.4
+  - @weasel-js/gestures@1.0.4
+  - @weasel-js/font@1.0.4
+  - @weasel-js/modes@1.0.4
+
+## 1.0.3
+
+### Patch Changes
+
+- 5d25a40: `@weasel-js/font`'s six reset seams — `_resetFontRegistryForTests`,
+  `_resetFallbackForTests`, `_getPagesForTests`, `_resetDynamicFontsForTests`,
+  `__setGlyphRasterizerForTests` and `_resetFontOutlinesForTests` — are no longer
+  exported from the package barrel. They now live at a new
+  `@weasel-js/font/test-seams` entry point.
+
+  Nothing loses the ability to reach them. They exist because font registration,
+  the fallback policy, the dynamic atlas and the outline registry are global
+  module state that changes what renders, so a test in another package that sets
+  one has to be able to put it back — which is why they were on the barrel in the
+  first place. A named test-seam entry serves that need without an application
+  finding a `_resetFontOutlinesForTests` by autocompleting the barrel. Both
+  entries share one chunk, so the registries remain single instances.
+
+  This is a breaking change for anything importing those six names from
+  `@weasel-js/font`; the import specifier is the only edit.
+
+  `evaluateEnabled` in `@weasel-js/core` is now marked `@experimental` at its
+  definition. An `@internal` block intended for it had come detached and sat above
+  three unrelated constants, so the function read as undocumented public API while
+  a stale marker said otherwise. It is genuinely public — `@weasel-js/ui`'s
+  `ActionBar` calls it — and `@experimental` matches the rest of the `enabled`
+  predicate surface.
+
+- f7077f6: An image quad no longer mints and frees a vertex array and two buffers on every
+  draw. The renderer keeps a ring of quad geometry per image program instead, and
+  a draw writes its four corners into the next slot. On an M2 Max via ANGLE this
+  takes an image command from ~7.0 us to ~3.9 us, measured by
+  `tests/perf/image-quad.spec.ts`; nothing about the API or the pixels changes.
+
+  A ring rather than one buffer, because one is the worst of the three shapes. The
+  driver tracks a write hazard per buffer object, so rewriting a single quad
+  buffer before each draw waits on the draw still reading it — 40–80 us per quad
+  against 5.4 for the per-draw allocation this replaced and 0.3 for the ring.
+  Sixty-four slots put that many draws between one write of a buffer and the next.
+
+  The remaining gap to a pattern-filled rect of the same size (~2.3 us) is texture
+  state, not geometry: an image binds a different texture and sets its filter per
+  draw.
+
+- 514c34a: Document every public export at its definition site
+
+  A JSDoc string now sits on each symbol reachable through a package's published
+  entry points, in every package except `@weasel-js/ui`. Documentation only — no
+  export was added, removed, renamed or reordered, and no behavior changed.
+
+  `npm run audit:jsdoc` enumerates the public exports and reports which lack a
+  docstring, so the claim can be re-derived rather than trusted.
+
+- Updated dependencies [5d25a40]
+- Updated dependencies [514c34a]
+  - @weasel-js/font@1.0.3
+  - @weasel-js/geom@1.0.3
+  - @weasel-js/gestures@1.0.3
+  - @weasel-js/history@1.0.3
+  - @weasel-js/modes@1.0.3
+
 ## 1.0.2
 
 ### Patch Changes

package/dist/{DrawCommand-DCmiNkBj.d.ts → DrawCommand-BbPrSTra.d.ts}

@@ -33,6 +33,10 @@ declare function apply(m: Mat3, x: number, y: number): [number, number];
  * matches clip-down).
  */
 declare function screenToClip(width: number, height: number): Mat3;
+/** The renderer's 3x3 matrix operations, as one namespace. These work on the
+ *  9-element `Float32Array` form the GL uniform upload wants — distinct from
+ *  `@weasel-js/geom`'s 6-element affine `Mat3`, though the logical element
+ *  order is the same. */
 declare const mat3: {
     identity: typeof identity;
     multiply: typeof multiply;
@@ -140,6 +144,9 @@ declare function fontString(s: ResolvedTextStyle): string;
  * (300/500/900) are out of scope for slice 1.
  */
 
+/** A span of text with its own styling, as authored. Fields left absent
+ *  inherit from the node's text style — this is the difference between a run
+ *  and a fully resolved one. */
 interface StyledRun {
     text: string;
     bold?: boolean;
@@ -155,8 +162,13 @@ interface StyledRun {
     underline?: boolean;
     strikethrough?: boolean;
 }
+/** Normalize the two accepted spellings of text content — a plain string or
+ *  an array of runs — to runs. Throws on a run with no string `text`. */
 declare function toRuns(input: string | StyledRun[]): StyledRun[];
+/** Concatenate runs, dropping all styling. */
 declare function runsToPlainText(runs: readonly StyledRun[]): string;
+/** Render runs as Markdown, preserving bold and italic. The flavor written to
+ *  the clipboard alongside the plain-text one. */
 declare function runsToMarkdown(runs: readonly StyledRun[]): string;
 /**
  * Parse a small markdown subset (`**bold**`, `*italic*`, `***both***`) into
@@ -184,6 +196,8 @@ declare function markdownToRuns(input: string): StyledRun[];
  * `runs/rangeStyle.ts` for why the model collapses the tri-state.
  */
 
+/** A run with every style resolved against the node's text style — no
+ *  optional inheritance left. This is what layout and painting consume. */
 interface ResolvedRun {
     text: string;
     fontFamily: string;
@@ -201,6 +215,8 @@ interface ResolvedRun {
     /** Draw a rule through this run's x-height. Additive over the node style. */
     strikethrough: boolean;
 }
+/** Resolve each run's styling against the node's text style, filling in
+ *  everything the run left inherited. */
 declare function resolveRuns(runs: readonly StyledRun[], style: ResolvedTextStyle): ResolvedRun[];
 
 /**
@@ -210,6 +226,9 @@ declare function resolveRuns(runs: readonly StyledRun[], style: ResolvedTextStyl
  * `height`) is the legacy behavior: offset 0.
  */
 type TextVerticalAlign = 'top' | 'center' | 'bottom';
+/** How far to shift laid-out text down inside a box of `boxHeight` to satisfy
+ *  a vertical alignment. Zero when the box height is unknown or alignment is
+ *  top. */
 declare function verticalAlignOffset(align: TextVerticalAlign | undefined, boxHeight: number | undefined, textHeight: number): number;
 
 /**
@@ -286,6 +305,8 @@ interface SolidPaint {
 }
 /** DrawCommand variants implemented through step 6. */
 type DrawCommand = PathDrawCommand | GroupDrawCommand | TextDrawCommand | ImageDrawCommand | ShaderDrawCommand;
+/** Draw a path, filled and/or stroked. The workhorse command: every shape the
+ *  kit draws that is not text, an image, or a custom shader is one of these. */
 interface PathDrawCommand {
     kind: 'path';
     path: Path;
@@ -308,6 +329,9 @@ interface PathDrawCommand {
      */
     vertexColors?: number[];
 }
+/** Draw a list of commands under a shared transform, opacity, color matrix
+ *  and clip. Groups nest, and their effects accumulate down the stack — this
+ *  is how a container node's transform reaches its descendants. */
 interface GroupDrawCommand {
     kind: 'group';
     transform?: Mat3;

package/dist/{chunk-6SHZHXXR.js → chunk-4Z6J4IVH.js}

@@ -1,4 +1,4 @@
-import { elevateQuadraticToCubic, cubicBounds, transformCoords, boxToBox } from '@weasel-js/geom';
+import { elevateQuadraticToCubic, cubicBounds, pointSegmentDist2, transformCoords, boxToBox } from '@weasel-js/geom';
 
 // src/core/units.ts
 function resolveUnit(v, unitSystem) {
@@ -119,6 +119,16 @@ function boundsOfPath(path) {
 
 // src/features/paths/flatten.ts
 var DEFAULT_FLATTEN_TOLERANCE = 0.5;
+var MIN_FLATTEN_TOLERANCE = 1e-6;
+function usableTolerance(tolerance) {
+  return tolerance > 0 ? tolerance : MIN_FLATTEN_TOLERANCE;
+}
+function finite6(a, b, c, d, e, f) {
+  return Number.isFinite(a) && Number.isFinite(b) && Number.isFinite(c) && Number.isFinite(d) && Number.isFinite(e) && Number.isFinite(f);
+}
+function finite8(a, b, c, d, e, f, g, h) {
+  return finite6(a, b, c, d, e, f) && Number.isFinite(g) && Number.isFinite(h);
+}
 function distPointToLine(px, py, ax, ay, bx, by) {
   const dx = bx - ax;
   const dy = by - ay;
@@ -132,6 +142,13 @@ function distPointToLine(px, py, ax, ay, bx, by) {
   return Math.abs(cross) / Math.sqrt(len2);
 }
 function flattenCubic(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
+  if (!finite8(x0, y0, x1, y1, x2, y2, x3, y3)) {
+    out.push(x3, y3);
+    return;
+  }
+  flattenCubicRec(x0, y0, x1, y1, x2, y2, x3, y3, usableTolerance(tolerance), out);
+}
+function flattenCubicRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
   const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);
   const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);
   if (Math.max(d1, d2) <= tolerance) {
@@ -144,10 +161,17 @@ function flattenCubic(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out) {
   const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
   const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;
   const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;
-  flattenCubic(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);
-  flattenCubic(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);
+  flattenCubicRec(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);
+  flattenCubicRec(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);
 }
 function flattenQuadratic(x0, y0, x1, y1, x2, y2, tolerance, out) {
+  if (!finite6(x0, y0, x1, y1, x2, y2)) {
+    out.push(x2, y2);
+    return;
+  }
+  flattenQuadraticRec(x0, y0, x1, y1, x2, y2, usableTolerance(tolerance), out);
+}
+function flattenQuadraticRec(x0, y0, x1, y1, x2, y2, tolerance, out) {
   const d = distPointToLine(x1, y1, x0, y0, x2, y2);
   if (d <= tolerance) {
     out.push(x2, y2);
@@ -156,11 +180,16 @@ function flattenQuadratic(x0, y0, x1, y1, x2, y2, tolerance, out) {
   const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;
   const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;
   const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;
-  flattenQuadratic(x0, y0, x01, y01, x012, y012, tolerance, out);
-  flattenQuadratic(x012, y012, x12, y12, x2, y2, tolerance, out);
+  flattenQuadraticRec(x0, y0, x01, y01, x012, y012, tolerance, out);
+  flattenQuadraticRec(x012, y012, x12, y12, x2, y2, tolerance, out);
 }
 function flattenCubicWithArcLen(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut) {
-  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut, 0);
+  if (!finite8(x0, y0, x1, y1, x2, y2, x3, y3)) {
+    out.push(x3, y3);
+    arcOut.push(0);
+    return 0;
+  }
+  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, usableTolerance(tolerance), out, arcOut, 0);
 }
 function flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut, accum) {
   const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);
@@ -185,7 +214,12 @@ function flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcO
   return accum;
 }
 function flattenQuadraticWithArcLen(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut) {
-  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut, 0);
+  if (!finite6(x0, y0, x1, y1, x2, y2)) {
+    out.push(x2, y2);
+    arcOut.push(0);
+    return 0;
+  }
+  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, usableTolerance(tolerance), out, arcOut, 0);
 }
 function flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut, accum) {
   const d = distPointToLine(x1, y1, x0, y0, x2, y2);
@@ -205,8 +239,6 @@ function flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut,
   accum = flattenQuadraticArcRec(x012, y012, x12, y12, x2, y2, tolerance, out, arcOut, accum);
   return accum;
 }
-
-// src/features/paths/hitTest.ts
 function pointInPath(path, x, y, opts = {}) {
   if (path.kind === "rect") {
     return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;
@@ -380,22 +412,6 @@ function polylineWithinThreshold(path, px, py, t2, tolerance) {
   if (subOpen && checkSegments(false)) return true;
   return false;
 }
-function pointSegmentDist2(px, py, ax, ay, bx, by) {
-  const dx = bx - ax;
-  const dy = by - ay;
-  const len2 = dx * dx + dy * dy;
-  if (len2 === 0) {
-    const ex2 = px - ax, ey2 = py - ay;
-    return ex2 * ex2 + ey2 * ey2;
-  }
-  let t = ((px - ax) * dx + (py - ay) * dy) / len2;
-  if (t < 0) t = 0;
-  else if (t > 1) t = 1;
-  const cx = ax + t * dx;
-  const cy = ay + t * dy;
-  const ex = px - cx, ey = py - cy;
-  return ex * ex + ey * ey;
-}
 
 // src/features/paths/builder.ts
 var PathBuilder = class _PathBuilder {
@@ -864,5 +880,5 @@ function guideSnapStrategy(getGuides, options = {}) {
 }
 
 export { AUTO_POSE_DESCRIPTOR, DEFAULT_FLATTEN_TOLERANCE, DEFAULT_GUIDE_TOLERANCE_PX, IMPERIAL_INCHES, METRIC_MM, PATH_C, PATH_CMD_LENGTHS, PATH_L, PATH_M, PATH_Q, PATH_Z, PIXELS, PathBuilder, RECT_ORIGIN_PROJECTION, RECT_POSE_DESCRIPTOR, ROTATED_POSE_DESCRIPTOR, boundsOfPath, ellipsePath, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, formatUnit, gridSnapStrategy, guideSnapStrategy, linePath, pathPoseDescriptor, pointInPath, pointToGridCell, polygonFromPoints, pxExtent, rectPath, regularPolygonPath, remapRotatedLeaf, resolveUnit, scaleDelta, scalePathToBounds, starPath, strokeHitTest, transformPath, translatePath, translatePolygonInPlace, withinPxBox, withinPxRadius };
-//# sourceMappingURL=chunk-6SHZHXXR.js.map
-//# sourceMappingURL=chunk-6SHZHXXR.js.map
+//# sourceMappingURL=chunk-4Z6J4IVH.js.map
+//# sourceMappingURL=chunk-4Z6J4IVH.js.map