2D Vector Field Component

[bewuwy]

There should be a Vector / Arrow Field / Quiver 2D component.

x, y, u, v -> x,y location; u,v is the vector which to draw (length/direction)

Input: func f(x,y) => u,v

Arrows:

• if (u,v) is zero - no arrow

Options:

• (num) scaleLength - if not set and scale is true, then use a default
• (bool) scale - default true, if disable, then dont scale
• (bool) isArrow - if false, then just lines, default true
• start point - by default end is at x,y; there shold also be an option to do middle or end of the arrow, default is start

[bewuwy]

This was generated by AI during triage.

Agent Brief

Category: enhancement (new reusable 2D primitive component)
State: ready-for-agent
Label: none — this is a library component, not an applet; the repo has no clean enhancement/component label and change required ("modify existing applet") fits poorly. Intentionally left unlabelled.

Summary: Add a VectorField2D (quiver) component that samples a vector-valued function f(x,y) → (u,v) on a regular grid and draws an arrow (or line) for each non-zero vector.

Current behavior:
No vector-field / quiver component exists in the 2D layer. The building block is Vector2D (props include origin, direction, length, noNormalise for true-magnitude drawing, and hideHead for line-only). Existing samplers (ExplicitFunction2D, ImplicitFunction2D) establish the domain convention: xMin/xMax/yMin/yMax (default ±GRID_SIZE_2D) plus a stepSize.

Desired behavior:
A component that, given f(x,y) → (u,v), renders one arrow per grid node, following these rules.

Interface (behavioral, names indicative):

• f: (x: number, y: number) => [number, number] | Vector2 — required. Returns the vector (u,v) to draw at (x,y).
• Grid: xMin, xMax, yMin, yMax — default ±GRID_SIZE_2D (match existing samplers). stepSize — grid spacing, default 1 (deliberately coarser than curve samplers; a quiver needs a readable, sparse grid). Sample f at each node (x,y) stepping by stepSize across the ranges.
• scale: boolean — default true.
  • true: arrow length encodes true magnitude — length = |(u,v)| × scaleLength, drawn with Vector2D's noNormalise so relative magnitudes across the field are preserved. Do not auto-normalize to the max magnitude (that would rescale dynamically and break cross-state comparability).
  • false: direction-only — every arrow a fixed length of 0.4 × stepSize (normalized direction), so arrows read as flow direction and don't overlap neighbors.
• scaleLength: number — default 1. Multiplier applied only when scale=true.
• isArrow: boolean — default true. false → draw plain lines (no arrowhead; use Vector2D hideHead).
• anchor: 'start' | 'middle' | 'end' — default 'start'. Which part of the arrow sits on the grid node (x,y):
  • start: origin = (x,y) (node = tail; arrow grows toward (u,v)).
  • middle: origin = (x,y) − dir·length/2 (node at arrow center).
  • end: origin = (x,y) − dir·length (arrowhead lands on the node).
• color: ColorString — default a PrimeColor. Applied to all arrows unless colorFn is given.
• colorFn?: (u, v, x, y) => ColorString — optional per-arrow color (e.g. by magnitude or direction). Off by default.
• Zero vectors: if |(u,v)| ≈ 0 (below a small epsilon), render nothing at that node — no arrow, no line.

Implementation notes:

• Render one Vector2D per grid node with origin/direction/length computed per the rules above; hideHead from isArrow; noNormalise when scale=true.
• A field renders many scaled vectors, so it exercises the same per-primitive world→screen scale path that Deepen the 2D scale transform into a Projection2D seam #491 (Projection2D seam) targets — build on Vector2D as-is now; if Deepen the 2D scale transform into a Projection2D seam #491 lands, this component benefits automatically. Don't reimplement the scale transform here.
• Keep the prop shape parallel to the planned Vector Field 3D component #459 3D vector-field twin, so the two APIs stay consistent.

Acceptance criteria:

• Given an f(x,y), arrows render on a regular grid over [xMin,xMax] × [yMin,yMax] at stepSize spacing.
• scale=true: arrow length is proportional to |(u,v)| (× scaleLength); larger vectors are visibly longer.
• scale=false: all arrows are the same length (0.4·stepSize), showing direction only.
• isArrow=false draws lines without arrowheads.
• anchor places the node at the tail / center / head respectively; default is tail (start).
• Zero (or near-zero) vectors produce no mark.
• color sets a uniform color; colorFn overrides per-arrow when provided.
• A Storybook story demonstrates the component (e.g. a rotational field like f=(−y, x) and a source/sink), covering scale on/off, isArrow on/off, and a colorFn.

Out of scope:

• 3D vector field (Vector Field 3D component #459) — separate, keep the API parallel.
• Streamlines / field-line integration (only discrete arrows here).
• An explicit points[] sampling override — sampling is from f on the grid only.
• Reworking the world→screen scale transform (that's Deepen the 2D scale transform into a Projection2D seam #491).

Decisions recorded (triage grilling): grid from ranges + stepSize (no points array); scale=true magnitude × scaleLength (no auto-fit), scale=false fixed 0.4·stepSize; default scaleLength=1; anchor default start; colorFn hook included now; zero-vectors skipped; parallel API with #459.