@jbrowse/render-core 5.0.0-beta.1 → 5.0.0-beta.10

package/src/shaders/valueScale.slang

@@ -0,0 +1,26 @@
+// A quantitative mark's value → canvas y: `scoreScale`'s normalizer, flipped
+// so a bigger value sits higher. Only the scale lives here; each shape keeps
+// its own anchor (ADR-097). `pointMark.slang` lifts the JS twin.
+//! js-skip: valueToYPx — the linear case of valueToYPxScaled, whose twin pointMark.slang lifts; a shader reading it alone (the score example's scoreBarHeightPx) lifts the caller it sits inside
+//! js-skip: insetValueYPx — its two consumers lift it under their own anchors, pointMark.slang as pointYPx and linkMark.slang as linkValuePx, and those are the spellings the painters and hit tests read; a third twin would be one nothing calls
+module valueScale;
+
+import scoreScale;
+
+public float valueToYPxScaled(float value, float domainMin, float domainMax, float h, int scaleType, float symlogConstant) {
+  return (1.0 - normalizeScore(value, domainMin, domainMax, scaleType, symlogConstant)) * h;
+}
+
+public float valueToYPx(float value, float domainMin, float domainMax, float h) {
+  return valueToYPxScaled(value, domainMin, domainMax, h, 0, 1.0);
+}
+
+// The same scale over a range inset by `insetPx` at BOTH ends, so an edge
+// instance's glyph stays whole. Still range and not anchor: the result is px
+// below the band's top and each shape places it (ADR-097). Past `h * 0.5` the
+// clamp is load-bearing — without it the range goes negative and the scale
+// runs backwards.
+public float insetValueYPx(float value, float domainMin, float domainMax, float h, int scaleType, float insetPx, float symlogConstant) {
+  float inset = min(insetPx, h * 0.5);
+  return inset + valueToYPxScaled(value, domainMin, domainMax, h - 2.0 * inset, scaleType, symlogConstant);
+}

package/src/shaders/wideCircleLeg.test.ts

@@ -0,0 +1,85 @@
+import {
+  wideCircleLeg,
+  wideCircleLegStep,
+} from './curveDistance.js.generated.ts'
+import { LINK_CURVE_SEGMENTS } from './linkMark.consts.generated.ts'
+
+const SWEEP = 0.3
+
+function legs(segments: number) {
+  const right: number[] = []
+  const left: number[] = []
+  for (let seg = 0; seg <= segments; seg++) {
+    const [side, b] = wideCircleLeg(seg, segments, SWEEP)
+    ;(side > 0 ? right : left).push(b)
+  }
+  return { right, left }
+}
+
+// Odd counts included: the left leg is spread over `segments - half - 1`, and
+// spelling that `half - 1` instead overshoots the sweep on every odd strip
+// (65 segments reached 1.032x it) and divides by zero at 3.
+test.each([LINK_CURVE_SEGMENTS, 8, 7, 6, 5, 4, 3])(
+  'both legs of a %i-segment strip rise from the foot to the full sweep',
+  segments => {
+    const { right, left } = legs(segments)
+    expect(right[0]).toBe(0)
+    expect(left.at(-1)).toBe(0)
+    expect(Math.max(...right)).toBeCloseTo(SWEEP, 12)
+    expect(Math.max(...left)).toBeCloseTo(SWEEP, 12)
+    // And NO further: the hull is padded for `legSweep`, so a leg running past
+    // it leaves the band through a chord nothing sized.
+    expect(Math.max(...right, ...left)).toBeLessThanOrEqual(SWEEP)
+  },
+)
+
+// Reaching the sweep is half the contract; arriving in equal steps is the other
+// half, and it is the load-bearing one. `legSweepAngle` exists so that every
+// chord's sagitta stays under a pixel across the band — a leg that front-loads
+// its segments near the foot satisfies every endpoint assertion above and
+// leaves one huge chord at the band edge, which is the taper the whole sweep
+// rule was written to kill.
+test.each([LINK_CURVE_SEGMENTS, 8, 7, 4, 3])(
+  'a %i-segment strip steps each leg by a constant angle',
+  segments => {
+    const { right, left } = legs(segments)
+    for (const leg of [right, [...left].reverse()]) {
+      const steps = leg.slice(1).map((b, i) => b - leg[i]!)
+      for (const step of steps) {
+        expect(step).toBeCloseTo(steps[0]!, 12)
+      }
+    }
+  },
+)
+
+test('each leg is monotonic from its foot, the left one mirrored', () => {
+  const { right, left } = legs(LINK_CURVE_SEGMENTS)
+  for (let i = 1; i < right.length; i++) {
+    expect(right[i]).toBeGreaterThan(right[i - 1]!)
+  }
+  for (let i = 1; i < left.length; i++) {
+    expect(left[i]).toBeLessThan(left[i - 1]!)
+  }
+})
+
+// The hull circumscribes each chord by half this step, so a step read off the
+// wrong leg leaves the other leg's chords sagging.
+test.each([LINK_CURVE_SEGMENTS, 8, 7, 4, 3])(
+  'wideCircleLegStep is the step of the leg a %i-segment strip puts seg on',
+  segments => {
+    for (let seg = 0; seg < segments; seg++) {
+      const [side, b] = wideCircleLeg(seg, segments, SWEEP)
+      const [nextSide, next] = wideCircleLeg(seg + 1, segments, SWEEP)
+      if (side === nextSide) {
+        expect(wideCircleLegStep(seg, segments, SWEEP)).toBeCloseTo(
+          Math.abs(next - b),
+          12,
+        )
+        expect(wideCircleLegStep(seg + 1, segments, SWEEP)).toBeCloseTo(
+          Math.abs(next - b),
+          12,
+        )
+      }
+    }
+  },
+)

package/esm/globalRenderingBackend.d.ts

@@ -1,90 +0,0 @@
-import { Canvas2DRenderingBackendBase, GpuRenderingBackendBase } from './renderingBackendBase.ts';
-import type { FrameDimensions, RenderingBackend } from './renderingBackendBase.ts';
-/**
- * Shared contract for monolithic GPU backends (HiC, LD, multi-variant
- * matrix) — displays with no region partitioning. One payload under the
- * `data` key, one draw per frame. Render receives the data directly so
- * Canvas2D backends stay stateless; GPU backends use `upload` to push bytes
- * into a HAL buffer and ignore the `data` arg at render time.
- *
- * A display with a second upload beside the payload — HiC's and LD's colour
- * ramp texture, derived from a setting rather than the fetch — widens `Key`
- * and `Cell` so `upload` takes both cells and tells them apart, while `render`
- * is still handed the payload alone.
- */
-export interface GlobalRenderingBackend<UploadData, RenderState, Key extends string = 'data', Cell = UploadData> extends RenderingBackend {
-    upload(key: Key, data: Cell): void;
-    release(key: Key): void;
-    /**
-     * Paint one frame and report whether real content reached the canvas — the
-     * monolithic twin of `PerRegionRenderingBackend.renderBlocks`, and it answers
-     * for the same reason. `RenderLifecycleMixin` flips `canvasDrawn` (the loading
-     * scrim, `data-display-drawn`, every browser test's wait) only on `true`, so a
-     * tick that drew nothing must say so.
-     *
-     * **This used to return `void`, and the answer was the display's to give.**
-     * Each of the three wrote the same six lines — "data is here, so return
-     * `true`" — beside a renderer whose own guard was strictly narrower: a color
-     * ramp that had not arrived, a zero instance count, an empty HAL buffer. Two
-     * expressions of one fact, and the one that could see what actually happened
-     * was not the one being asked. LD's model even carried a comment explaining
-     * the workaround, which is the usual sign that a signature is wrong rather
-     * than a caller.
-     */
-    render(data: UploadData | null, state: RenderState): boolean;
-}
-/**
- * Canvas2D-side base for `GlobalRenderingBackend` implementations. Inherits the
- * `canvas` + 2D context (and no-op `dispose`) from
- * `Canvas2DRenderingBackendBase`; stubs `upload` (no-op — data flows through
- * `render`).
- *
- * `render` is concrete and runs `prepareCanvas` (DPR-aware backing-store sizing)
- * before handing off to the abstract `draw`, exactly as
- * `Canvas2DPerRegionRenderingBackend` does — so a renderer here can no more
- * forget it and paint blurry on hi-DPI than one over there can. All three
- * subclasses opened with that same call and none of them had to.
- *
- * A null payload still prepares (and so clears) the canvas, then skips the
- * draw: that is the frame where a refetch is in flight and the old picture must
- * not stay up.
- */
-export declare abstract class Canvas2DGlobalRenderingBackend<UploadData, RenderState extends FrameDimensions, Key extends string = 'data', Cell = UploadData> extends Canvas2DRenderingBackendBase implements GlobalRenderingBackend<UploadData, RenderState, Key, Cell> {
-    upload(_key: Key, _cell: Cell): void;
-    release(_key: Key): void;
-    render(data: UploadData | null, state: RenderState): boolean;
-    /**
-     * Paint `data` into `this.ctx` (already DPR-prepared) and answer whether
-     * anything reached it. Delegates to the plugin's pure `drawXxxBlocks`
-     * function, the one SVG export shares.
-     */
-    protected abstract draw(data: UploadData, state: RenderState): boolean;
-}
-/**
- * GPU-side base for `GlobalRenderingBackend` implementations. Inherits the
- * `hal` reference, the pre-allocated uniform scratch buffer, and the
- * HAL-delegating `dispose` from `GpuRenderingBackendBase`. Subclasses implement
- * `upload` and `draw`.
- *
- * `render` is the frame scaffold the per-region base has always had and this
- * one did not: resize the backing store, `beginFrame`/`endFrame`, and hand the
- * middle to `draw`. **The pairing is the point.** `beginFrame` is what clears
- * the canvas, so a frame that draws nothing still has to open and close one or
- * the last picture stays up — and with each subclass writing its own scaffold,
- * that invariant held three times by hand.
- *
- * `release` is a no-op by default: a payload leaving the map is answered by
- * `render` being handed `null`, and `beginFrame` clears the last picture. A
- * subclass whose buffers are worth freeing early overrides it.
- */
-export declare abstract class GpuGlobalRenderingBackend<UploadData, RenderState extends FrameDimensions, Key extends string = 'data', Cell = UploadData> extends GpuRenderingBackendBase implements GlobalRenderingBackend<UploadData, RenderState, Key, Cell> {
-    abstract upload(key: Key, data: Cell): void;
-    release(): void;
-    render(data: UploadData | null, state: RenderState): boolean;
-    /**
-     * Write uniforms and issue the draw passes for one frame, inside an already-
-     * open `beginFrame`/`endFrame`. Return whether anything was drawn — a buffer
-     * the upload has not filled yet is the ordinary reason not to.
-     */
-    protected abstract draw(data: UploadData, state: RenderState): boolean;
-}

package/esm/globalRenderingBackend.js

@@ -1,53 +0,0 @@
-import { prepareCanvas } from './canvas2dUtils.js';
-import { Canvas2DRenderingBackendBase, GpuRenderingBackendBase, } from './renderingBackendBase.js';
-/**
- * Canvas2D-side base for `GlobalRenderingBackend` implementations. Inherits the
- * `canvas` + 2D context (and no-op `dispose`) from
- * `Canvas2DRenderingBackendBase`; stubs `upload` (no-op — data flows through
- * `render`).
- *
- * `render` is concrete and runs `prepareCanvas` (DPR-aware backing-store sizing)
- * before handing off to the abstract `draw`, exactly as
- * `Canvas2DPerRegionRenderingBackend` does — so a renderer here can no more
- * forget it and paint blurry on hi-DPI than one over there can. All three
- * subclasses opened with that same call and none of them had to.
- *
- * A null payload still prepares (and so clears) the canvas, then skips the
- * draw: that is the frame where a refetch is in flight and the old picture must
- * not stay up.
- */
-export class Canvas2DGlobalRenderingBackend extends Canvas2DRenderingBackendBase {
-    upload(_key, _cell) { }
-    release(_key) { }
-    render(data, state) {
-        prepareCanvas(this.canvas, this.ctx, state.canvasWidth, state.canvasHeight);
-        return data !== null && this.draw(data, state);
-    }
-}
-/**
- * GPU-side base for `GlobalRenderingBackend` implementations. Inherits the
- * `hal` reference, the pre-allocated uniform scratch buffer, and the
- * HAL-delegating `dispose` from `GpuRenderingBackendBase`. Subclasses implement
- * `upload` and `draw`.
- *
- * `render` is the frame scaffold the per-region base has always had and this
- * one did not: resize the backing store, `beginFrame`/`endFrame`, and hand the
- * middle to `draw`. **The pairing is the point.** `beginFrame` is what clears
- * the canvas, so a frame that draws nothing still has to open and close one or
- * the last picture stays up — and with each subclass writing its own scaffold,
- * that invariant held three times by hand.
- *
- * `release` is a no-op by default: a payload leaving the map is answered by
- * `render` being handed `null`, and `beginFrame` clears the last picture. A
- * subclass whose buffers are worth freeing early overrides it.
- */
-export class GpuGlobalRenderingBackend extends GpuRenderingBackendBase {
-    release() { }
-    render(data, state) {
-        this.hal.resize(state.canvasWidth, state.canvasHeight);
-        this.hal.beginFrame(0, 0, 0, 0);
-        const painted = data !== null && this.draw(data, state);
-        this.hal.endFrame();
-        return painted;
-    }
-}

package/esm/keyedRenderingBackend.d.ts

@@ -1,41 +0,0 @@
-import type { RenderingBackend } from './renderingBackendBase.ts';
-/**
- * Shared contract for **keyed shared-canvas** backends — one canvas painting
- * several displays at once, each holding its own uploaded buffer under its own
- * key. Dotplot (a key per display in the view) and multi-LGV synteny (a key per
- * track level) are the two.
- *
- * The third shape beside per-region and monolithic, and genuinely neither:
- * per-region drives off `renderBlocks(blocks, regions, state)` with the model's
- * data map handed back each frame, and monolithic is one payload under the `data` key
- * with no key at all. These key their uploads and render every key in one
- * frame from state the caller assembled, so they own the map.
- *
- * Unlike the other two this is an interface with no abstract class under it:
- * the shared *state* (`hal` + uniform scratch, or `canvas` + 2D context) is
- * `GpuRenderingBackendBase` / `Canvas2DRenderingBackendBase`, which every keyed
- * backend extends, and there is no shared *behavior* on top — the render loops
- * genuinely differ. An empty abstract class between them would only be a place
- * to look.
- */
-export interface KeyedRenderingBackend<UploadData, RenderState> extends RenderingBackend {
-    /** CSS-pixel size of the shared canvas. */
-    resize(width: number, height: number): void;
-    upload(key: number, data: UploadData): void;
-    release(key: number): void;
-    /** Paint every key the state names. */
-    render(state: RenderState): void;
-}
-/**
- * Stable 32-bit slot for a display on a backend it shares with siblings, hashed
- * from its MST node id (djb2). Collisions are vanishingly rare at display
- * cardinalities, and the alternative — coordinating integer slots between
- * displays that don't know about each other — is worse.
- *
- * Key by this, never by the display's index in its parent's list. An index
- * renumbers when a sibling is hidden or reordered, which hands the survivor a
- * slot holding another display's bytes: the keyed diff sees a changed
- * reference and re-uploads every later display's whole buffer, and any frame
- * drawn between the two mistakes one display's geometry for another's.
- */
-export declare function sharedBackendKey(id: string): number;