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

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;