@react-x11/components 0.8.0 → 0.10.0

package/dist/flow/gl/shaders.js

@@ -0,0 +1,346 @@
+// The GL renderer's four programs.
+//
+// GLSL ES 1.00, for the reason `src/maps/gl/shaders.ts` gives: it is the one
+// dialect both direct backends compile, Apple's GL 4.1 core through
+// ARB_ES2_compatibility and every Linux GLES driver natively.
+//
+// Every program shares one coordinate contract, and it is the whole of what
+// the vertex shaders agree on. Positions arrive in the scene's units —
+// **logical window pixels**, what `../scene.ts` builds in — and leave in
+// clip space via device pixels:
+//
+//     device = (logical * u_zoom + u_offset - u_origin) * u_scale
+//
+// where `u_origin` is where the surface's top-left sits in the window (the
+// pane's content box, which the surface covers exactly) and `u_scale` is the
+// display scale. `u_offset` is the pan: the graph's world is built at a
+// pinned origin and moved here, so a pan is this one uniform and nothing
+// else (`./renderer.ts`). `u_zoom` is the part of a zoom the world was not
+// built at — 1 at rest, and while a zoom gesture moves, the view's zoom over
+// the one the world on the GPU was built for, so a step of the gesture is a
+// uniform too, and every length an instance carries is multiplied by it
+// with its position. The overlay, pinned to the pane and built every frame,
+// draws with no offset and a zoom of 1. So the one multiply `../draw.ts`
+// does on the way to the 2D context happens here, per vertex, and every
+// antialiasing ramp below is measured in device pixels — which is what makes
+// a 1px line one pixel of coverage on any panel.
+import { SDF_EDGE, SDF_INK_BIAS_PX } from '../../internal/sdf.js';
+/** Attribute locations, shared so one quad buffer feeds every program. */
+export const ATTRIBUTES = {
+    a_corner: 0,
+    a_i0: 1,
+    a_i1: 2,
+    a_i2: 3,
+    a_i3: 4,
+};
+const PRELUDE = `precision highp float;
+uniform vec2 u_origin;
+uniform vec2 u_offset;
+uniform float u_scale;
+uniform float u_zoom;
+uniform vec2 u_viewport;
+vec2 device(vec2 logical) {
+  return (logical * u_zoom + u_offset - u_origin) * u_scale;
+}
+vec4 clip(vec2 d) {
+  return vec4(d.x / u_viewport.x * 2.0 - 1.0,
+              1.0 - d.y / u_viewport.y * 2.0, 0.0, 1.0);
+}
+`;
+/**
+ * A line segment as a capsule: the quad round it, widened by half the line
+ * plus a pixel of fringe, shaded by distance to the segment.
+ *
+ * Clamping the pixel's position along the segment before measuring is what
+ * gives round caps and round joins for nothing — two consecutive capsules
+ * overlap in exactly the disc a round join is — and the same distance is the
+ * antialiasing ramp. The cost of that is a translucent line, which would lay
+ * its colour down twice where two capsules overlap; every line a graph draws
+ * by default is opaque, and `src/maps/gl/shaders.ts` has the stencil pass
+ * that fixes it if one ever is not.
+ *
+ * Instance: a_i0 = ends, a_i1 = half-width, distance along at the first end,
+ * dash on, dash off; a_i2 = dash offset, and 1 where the dash marches — by
+ * `u_phase`, the timer's, in logical pixels; a_i3 = colour.
+ */
+export const LINE_VERTEX = `${PRELUDE}
+uniform float u_phase;
+attribute vec2 a_corner;
+attribute vec4 a_i0;
+attribute vec4 a_i1;
+attribute vec4 a_i2;
+attribute vec4 a_i3;
+varying vec2 v_local;
+varying float v_len;
+varying float v_half;
+varying float v_along;
+varying vec3 v_dash;
+varying vec4 v_color;
+void main() {
+  vec2 a = device(a_i0.xy);
+  vec2 b = device(a_i0.zw);
+  vec2 d = b - a;
+  float len = length(d);
+  vec2 t = len > 0.0001 ? d / len : vec2(1.0, 0.0);
+  vec2 n = vec2(-t.y, t.x);
+  float half_ = a_i1.x * u_zoom * u_scale;
+  float e = half_ + 1.0;
+  float along = mix(-e, len + e, a_corner.x);
+  float across = a_corner.y * e;
+  v_local = vec2(along, across);
+  v_len = len;
+  v_half = half_;
+  v_along = a_i1.y * u_zoom * u_scale + along;
+  // a marching dash takes the timer's phase from a uniform, so a tick moves
+  // every dash on the GPU without a byte uploaded — and the phase is the
+  // view's, already at its zoom, where the pattern is the world's
+  v_dash = (vec3(a_i1.z, a_i1.w, a_i2.x) * u_zoom +
+            vec3(0.0, 0.0, a_i2.y * u_phase)) * u_scale;
+  v_color = a_i3;
+  gl_Position = clip(a + t * along + n * across);
+}
+`;
+export const LINE_FRAGMENT = `precision highp float;
+varying vec2 v_local;
+varying float v_len;
+varying float v_half;
+varying float v_along;
+varying vec3 v_dash;
+varying vec4 v_color;
+void main() {
+  float x = clamp(v_local.x, 0.0, v_len);
+  float dist = length(vec2(v_local.x - x, v_local.y));
+  float alpha = clamp(v_half - dist + 0.5, 0.0, 1.0);
+  float period = v_dash.x + v_dash.y;
+  if (period > 0.0) {
+    // Where in the pattern this pixel is, the canvas way: the offset shifts
+    // the pattern's start along the line. Covered by how far the pixel is
+    // inside the nearer end of its dash, so a dash's ends antialias too.
+    float m = mod(v_along + v_dash.z, period);
+    alpha *= clamp(min(m, v_dash.x - m) + 0.5, 0.0, 1.0);
+  }
+  if (alpha <= 0.0) discard;
+  gl_FragColor = v_color * alpha;
+}
+`;
+/**
+ * A rounded box: fill, border and antialiased edge out of one distance.
+ *
+ * The 2D painter fills the whole box and strokes a border *inset* by half
+ * its pen (`../draw.ts`), so the ink band runs from the edge inward by the
+ * pen's width with the fill beneath it. This composites the same way — the
+ * border *over* the fill across the band, not in place of it — which only
+ * differs when the border is translucent, and a hovered card's is.
+ *
+ * A disc is a box whose side is twice its corner radius, which is why
+ * handles are drawn here too — and a label is a box that samples its
+ * distance field in the atlas (`./text.ts`) instead, flagged in `a_i1.z`,
+ * which is what keeps every label in the box stream at exactly the place in
+ * the order the 2D painter draws it.
+ *
+ * Instance: a_i0 = x, y, width, height; a_i1 = corner radius, border width;
+ * a_i2 = fill; a_i3 = border colour. For a label: a_i0 = the text's corner
+ * and the quad's size; a_i1 = the quad's margin before that corner, its
+ * field's page, 1, and the logical pixels a field texel covers; a_i2 = ink; a_i3 = its rect
+ * in the atlas.
+ */
+export const BOX_VERTEX = `${PRELUDE}
+attribute vec2 a_corner;
+attribute vec4 a_i0;
+attribute vec4 a_i1;
+attribute vec4 a_i2;
+attribute vec4 a_i3;
+varying vec2 v_local;
+varying vec2 v_half;
+varying vec2 v_shape;
+varying vec4 v_fill;
+varying vec4 v_border;
+varying vec2 v_uv;
+varying float v_text;
+void main() {
+  vec2 corner = vec2(a_corner.x, a_corner.y * 0.5 + 0.5);
+  v_text = a_i1.z;
+  if (a_i1.z > 1.5) {
+    // a label whose field is still being set: nothing, until it lands
+    gl_Position = vec4(0.0, 0.0, 2.0, 1.0);
+    return;
+  }
+  if (a_i1.z > 0.5) {
+    // A label: its field, scaled to the size it is drawn at. The text's
+    // corner goes on the device grid *after* the pan's offset, which is
+    // where the grid is — the 2D painter rounds the same corner — and the
+    // quad reaches its margin before it.
+    float k = u_zoom * u_scale;
+    vec2 origin = floor(device(a_i0.xy) + 0.5) - a_i1.x * k;
+    v_uv = mix(a_i3.xy, a_i3.zw, corner);
+    v_fill = a_i2;
+    v_local = vec2(0.0);
+    v_half = vec2(0.0);
+    // device pixels a field texel covers, for the fragment's ramp, and the
+    // page its field is on
+    v_shape = vec2(a_i1.w * k, a_i1.y);
+    v_border = vec4(0.0);
+    gl_Position = clip(origin + corner * a_i0.zw * k);
+    return;
+  }
+  v_uv = vec2(0.0);
+  vec2 size = a_i0.zw * u_zoom * u_scale;
+  vec2 half_ = size * 0.5;
+  // a pixel of fringe all round, for the antialiased edge to fade into
+  vec2 local = (corner - 0.5) * (size + 2.0);
+  v_local = local;
+  v_half = half_;
+  v_shape = vec2(a_i1.x, a_i1.y) * u_zoom * u_scale;
+  v_fill = a_i2;
+  v_border = a_i3;
+  gl_Position = clip(device(a_i0.xy) + half_ + local);
+}
+`;
+/**
+ * A label's field says how far a pixel is from the glyphs' edge — in texels,
+ * `u_spread` of them across the byte range, and so in device pixels once
+ * scaled by how many a texel covers — and ink is that distance ramped across
+ * one device pixel, whatever size the label is drawn at.
+ */
+export const BOX_FRAGMENT = `precision highp float;
+uniform sampler2D u_atlas;
+uniform float u_spread;
+varying vec2 v_local;
+varying vec2 v_half;
+varying vec2 v_shape;
+varying vec4 v_fill;
+varying vec4 v_border;
+varying vec2 v_uv;
+varying float v_text;
+void main() {
+  if (v_text > 0.5) {
+    // Four pages, one a channel: alpha is page 0, red, green and blue
+    // pages 1 to 3 (CHANNELS in ./text.ts).
+    vec4 pages = texture2D(u_atlas, v_uv);
+    vec4 pick = 1.0 - min(abs(vec4(v_shape.y) - vec4(1.0, 2.0, 3.0, 0.0)), 1.0);
+    float field = dot(pages, pick);
+    // device pixels past the glyphs' edge: positive outside, negative in
+    float d = (${SDF_EDGE.toFixed(4)} - field) * u_spread * v_shape.x;
+    float ink = clamp(0.5 + ${SDF_INK_BIAS_PX.toFixed(2)} - d, 0.0, 1.0);
+    if (ink <= 0.0) discard;
+    gl_FragColor = v_fill * ink;
+    return;
+  }
+  float r = min(v_shape.x, min(v_half.x, v_half.y));
+  vec2 q = abs(v_local) - (v_half - r);
+  float d = length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - r;
+  float outside = clamp(0.5 - d, 0.0, 1.0);
+  vec4 color = v_fill * outside;
+  if (v_shape.y > 0.0) {
+    float inner = clamp(0.5 - (d + v_shape.y), 0.0, 1.0);
+    float band = outside - inner;
+    color = v_border * band + color * (1.0 - v_border.a * band);
+  }
+  if (color.a <= 0.0) discard;
+  gl_FragColor = color;
+}
+`;
+/** A flat triangle: the fill of a closed arrowhead. Its edge is
+ *  antialiased by the hairline `./pack.ts` strokes round it. */
+export const TRI_VERTEX = `${PRELUDE}
+attribute vec2 a_corner;
+attribute vec4 a_i0;
+varying vec4 v_color;
+void main() {
+  v_color = a_i0;
+  gl_Position = clip(device(a_corner));
+}
+`;
+export const TRI_FRAGMENT = `precision mediump float;
+varying vec4 v_color;
+void main() {
+  gl_FragColor = v_color;
+}
+`;
+/**
+ * The grid, worked out per pixel: no tile, no pattern and no pile of runs —
+ * and none of the 2D path's integral-pitch restriction, because nothing here
+ * is a pixmap that has to repeat on whole pixels.
+ *
+ * Distances are to the nearest grid point in each axis, in logical pixels,
+ * and each mark's coverage ramps across one *device* pixel, so a dot is as
+ * sharp as the panel draws it.
+ */
+export const GRID_VERTEX = `precision highp float;
+attribute vec2 a_corner;
+uniform vec2 u_viewport;
+varying vec2 v_device;
+void main() {
+  v_device = vec2(a_corner.x * u_viewport.x,
+                  (a_corner.y * 0.5 + 0.5) * u_viewport.y);
+  gl_Position = vec4(a_corner.x * 2.0 - 1.0, -a_corner.y, 0.0, 1.0);
+}
+`;
+export const GRID_FRAGMENT = `precision highp float;
+uniform vec2 u_origin;
+uniform float u_scale;
+// the grid's origin (logical window pixels) and its pitch on screen
+uniform vec3 u_grid;
+// 0 dots, 1 lines, 2 cross; then a mark's size on screen (logical)
+uniform vec2 u_mark;
+uniform vec4 u_color;
+varying vec2 v_device;
+float cover(float edge, float dist) {
+  return clamp((edge - dist) * u_scale + 0.5, 0.0, 1.0);
+}
+void main() {
+  vec2 logical = v_device / u_scale + u_origin;
+  float step = u_grid.z;
+  vec2 rel = logical - u_grid.xy;
+  vec2 dist = abs(mod(rel + step * 0.5, step) - step * 0.5);
+  float a;
+  if (u_mark.x < 0.5) {
+    float h = u_mark.y * 0.5;
+    a = cover(h, dist.x) * cover(h, dist.y);
+  } else if (u_mark.x < 1.5) {
+    a = max(cover(0.5, dist.x), cover(0.5, dist.y));
+  } else {
+    float arm = u_mark.y;
+    a = max(cover(0.5, dist.x) * cover(arm, dist.y),
+            cover(0.5, dist.y) * cover(arm, dist.x));
+  }
+  if (a <= 0.0) discard;
+  gl_FragColor = u_color * a;
+}
+`;
+function compile(gl, type, source) {
+    const shader = gl.createShader(type);
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        const log = gl.getShaderInfoLog(shader);
+        gl.deleteShader(shader);
+        throw new Error(`@react-x11/components flow/gl: shader failed: ${log}`);
+    }
+    return shader;
+}
+/** Compile, bind the shared locations, link, and look the uniforms up. */
+export function linkProgram(gl, vertex, fragment, uniforms) {
+    const program = gl.createProgram();
+    const vs = compile(gl, gl.VERTEX_SHADER, vertex);
+    const fs = compile(gl, gl.FRAGMENT_SHADER, fragment);
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    for (const [name, location] of Object.entries(ATTRIBUTES)) {
+        gl.bindAttribLocation(program, location, name);
+    }
+    gl.linkProgram(program);
+    gl.deleteShader(vs);
+    gl.deleteShader(fs);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        const log = gl.getProgramInfoLog(program);
+        gl.deleteProgram(program);
+        throw new Error(`@react-x11/components flow/gl: link failed: ${log}`);
+    }
+    const found = {};
+    for (const name of uniforms) {
+        found[name] = gl.getUniformLocation(program, name);
+    }
+    return { program, uniforms: found };
+}
+//# sourceMappingURL=shaders.js.map

package/dist/flow/gl/shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.js","sourceRoot":"","sources":["../../../src/flow/gl/shaders.ts"],"names":[],"mappings":"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"}

package/dist/flow/gl/text.d.ts

@@ -0,0 +1,318 @@
+import type { PainterOptions } from '../draw.js';
+import type { SceneText } from '../scene.js';
+import type { FlowRect } from '../types.js';
+/**
+ * A label's quad and where its field sits in the atlas, all at the scene's
+ * zoom. `x`/`y` are the **text's** top-left, logical pixels in the scene's
+ * space — what the shader puts on the device grid, as the 2D painter puts
+ * the corner it draws a layout from — and the quad starts `margin` before
+ * it in both axes and is `w` by `h`. `texel` is the logical pixels one texel
+ * of the field covers; `u0`..`v1` are texture coordinates.
+ *
+ * A label whose field is still being set is a quad too, `ready` false and
+ * no place in the atlas: its size is known from the measurement before its
+ * field exists, so it is packed where it will be drawn, and its field is
+ * written in when it lands (`landed`) — without packing the world again.
+ */
+export interface GlyphQuad {
+    /** The field it draws from: its weight and the string, as cut. */
+    key: string;
+    ready: boolean;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    margin: number;
+    texel: number;
+    /** The page its field is on: which channel of the texture holds it. */
+    page: number;
+    /** Its field's placement (`LabelAtlas.slotOf`); 0 when not ready. */
+    slot: number;
+    u0: number;
+    v0: number;
+    u1: number;
+    v1: number;
+}
+/** What the atlas needs of the pane: its app, for the staging surface, and
+ *  the options its 2D painter measures with. */
+export interface TextSource {
+    app: unknown;
+    options: PainterOptions;
+}
+/** The atlas texture's side, texels: 16 MB of RGBA, four pages of fields —
+ *  some 8,000 titles at 1x and 2,600 at 2x. */
+export declare const ATLAS_SIZE = 2048;
+/**
+ * Texels the drawn quad leaves off each side of a field: a bilinear sample
+ * at its edge then stays inside the field's own margin, never reaching a
+ * neighbour's.
+ */
+export declare const QUAD_INSET = 1;
+/** The device size a display scale sets fields at: 16 at 1x, 32 at 2x. A
+ *  card's title is 13 at zoom 1, so a field is mostly drawn at or under the
+ *  size it was set at, where it is sharpest, and at twice it at the
+ *  default `maxZoom` of 2.5. */
+export declare const fieldBase: (scale: number) => number;
+/**
+ * A field's margin and spread at a base size, texels. A graph's labels have
+ * no halo, so the field only has to reach as far as the antialiasing ramp
+ * of the smallest label drawn: a handle's 10 at `LABEL_ZOOM`, under a
+ * third of the base, is a ramp of 2.3 texels, and a sixth of the base
+ * reaches three. A quarter, which the first cut used, drew the same pixels
+ * to within 5/255 from fields 12% larger, whose every texel was made.
+ */
+export declare const fieldPad: (base: number) => number;
+export declare class LabelAtlas {
+    private readonly source;
+    /** Measured and shaped in white, at device size — the scale is 1 here,
+     *  and a size is the base in device pixels — and cached apart from the
+     *  pane's own text: nothing measured here is a size the pane draws. */
+    private readonly white;
+    /** The device size every field is set at: a label drawn at `size`
+     *  scales its field by `size / base`. */
+    readonly base: number;
+    /** The margin set round every field, texels, which is also the distance
+     *  its values span — the shader's `u_spread`. */
+    readonly pad: number;
+    private readonly entries;
+    /** Wanted and not yet set: key → what to set it from, and where the
+     *  label nearest the view that asks for it is. */
+    private readonly missing;
+    /**
+     * Wanted, and waiting for room: the atlas is full of fields at least as
+     * near the view as these, so nothing is set for them until the view
+     * moves (`setView`) or a pack starts. Every key here is in `missing` too;
+     * what `wanting` counts is the rest.
+     */
+    private readonly stalled;
+    /**
+     * Requests measured: request → the string as cut. Measuring is what a
+     * label's first appearance costs the frame that packs it — 60-80 µs a
+     * string, on DirectWrite and on ntk alike, so a view of three hundred new
+     * labels was one frame 20 ms long before any of them could arrive. A pack
+     * measures for `shapeBudgetMs` and leaves the rest to the slices between
+     * frames; the ones it measured no pack measures again.
+     */
+    private readonly resolved;
+    /**
+     * What the pack under way has spent measuring, and how many strings it
+     * has measured — at least one a pack. Measuring alone is charged: a pack
+     * writes every edge before its first label, and a deadline from its start
+     * put off, after a zoom, labels whose cut had moved a fraction of a pixel
+     * and whose every measurement was cached.
+     */
+    private spent;
+    private measured;
+    /** Read back and waiting for their fields, oldest first — as wanted as
+     *  anything in `missing`, so a pack does not ask for them again. */
+    private fieldQueue;
+    private readonly queued;
+    /** The pages' shelves, and how far down each page they reach. */
+    private shelves;
+    private readonly tops;
+    /** Pages in the texture: one per channel, alpha first. */
+    private readonly pages;
+    /**
+     * The whole texture, four bytes a texel, made when the first field goes
+     * on a page past the first. An upload writes every channel of the rect
+     * it covers, so from then on a field is uploaded from here, with the
+     * fields of the other pages under it. An atlas that never fills its first
+     * page never makes it: 16 MB, paid only past the old limit.
+     */
+    private mirror;
+    /** The last placement found no room, and nothing has been freed since:
+     *  a want that cannot evict is stalled before it is shaped. */
+    private full;
+    /** Fields that may be dropped for a nearer one, farthest from the view
+     *  first — made when first needed in a slice, and consumed in order. */
+    private victims;
+    private victimAt;
+    /** Placements, counted: a field's `slot` changes whenever it lands, so a
+     *  box drawn from an old one is found by comparing the two. */
+    private nextSlot;
+    private staging;
+    private stagingCtx;
+    private busy;
+    /** Whether the layouts answer their own coverage (react-x11#673): unknown
+     *  until the first string asks, and false for good once one does not. */
+    private coverage;
+    /** Bumped whenever a field lands or is dropped — the renderer writes in
+     *  what landed, and uploads, when it moves. */
+    generation: number;
+    /** Bumped whenever a field is dropped: the renderer finds the boxes that
+     *  drew from it (`slotOf`) and draws them as nothing until it is back. */
+    moves: number;
+    /** Fields set are uploaded when the renderer next binds the atlas. */
+    private readonly pending;
+    /** Whether new strings may be set: false while the zoom is moving. */
+    admit: boolean;
+    /** Milliseconds of fields one slice may make, past the first field. */
+    fieldBudgetMs: number;
+    /** Milliseconds of measuring new strings a world pack may spend. */
+    shapeBudgetMs: number;
+    private texture;
+    private textureGeneration;
+    /** A field's rect as uploaded: widened to RGBA — the shader reads one
+     *  channel, and a one-channel texture is a format GLES 2 and a core
+     *  profile do not share. Grown to the largest field. */
+    private scratch;
+    /** Counts world packs; an entry stamped with the current one is drawn. */
+    private epoch;
+    /** The texture's side, texels. */
+    private readonly side;
+    /** `side` and `pages` are for tests, which fill an atlas without setting
+     *  thousands of labels. */
+    constructor(source: TextSource, side?: number, pages?: number);
+    /**
+     * A world pack is starting: the labels it asks for are the ones drawn
+     * until the next — and **all** that is wanted. What earlier packs asked
+     * for and nothing has set is forgotten here: the strings a pan went past
+     * are not worth a batch once it has.
+     */
+    beginPack(): void;
+    /**
+     * The view's centre, in the world's coordinates. What is wanted is set
+     * nearest it first: on a first appearance the labels arrive over a
+     * hundred milliseconds or more, and the ones in the middle of the view
+     * are the ones being read.
+     */
+    focus: {
+        x: number;
+        y: number;
+    } | null;
+    /** The view, in the world's coordinates — the surface says where each
+     *  frame. Null draws everything as if it were on screen. */
+    private view;
+    /**
+     * Where the view is now. A field on screen is never dropped for another;
+     * one off it is dropped for a label nearer the view, and a move of the
+     * view is what can make a stalled label nearer than one that is set.
+     */
+    setView(view: FlowRect | null): void;
+    /** How far a rect is from the view, in the world's units: 0 on it. */
+    private far;
+    /** How near a label is, for ordering what is wanted: from the view,
+     *  then from its middle. */
+    private nearness;
+    /** A want moved to the label asking for it nearest the view. */
+    private nearer;
+    /**
+     * A label's quad, or null when there is nothing to draw it from yet —
+     * which asks for its field.
+     */
+    quad(t: SceneText, lifted?: boolean): GlyphQuad | null;
+    /**
+     * The quad a label packed before its field existed draws from, now that
+     * it can be drawn — null until then. One the pack did not measure (a `?`
+     * key) is placed now, from the string its request resolved to: the pack
+     * gave it a box of no size, and this is its whole quad.
+     */
+    landing(key: string, t: SceneText, lifted?: boolean): GlyphQuad | null;
+    /** The placement a field is at now — -1 when it is not set — for a box
+     *  to tell whether the field it was drawn from is still there. */
+    slotOf(key: string): number;
+    /** A field a drawn label lost, wanted again from where that label is. */
+    want(key: string, t: SceneText): void;
+    /** A string cut to the width it fits, measured at the base size. */
+    private cut;
+    private remember;
+    /** No longer wanted: set, or given up on. */
+    private unwant;
+    /**
+     * A request the pack left unmeasured, measured: its string cut and
+     * shaped, and wanted under its field's key from then on. Null when that
+     * field is set, being set or waiting for room already — the request is
+     * answered, and a frame writes its labels in.
+     */
+    private resolve;
+    /** What is wanted and not waiting for room, nearest the view first. */
+    private wanted;
+    /** Whether any label drawn so far is still waiting for a field that can
+     *  be set — not counting those waiting for room. */
+    get wanting(): boolean;
+    /**
+     * Whether a want this far from the view is worth shaping: not when the
+     * atlas is full and holds nothing farther to drop for it.
+     */
+    private hopeful;
+    /**
+     * One slice of setting what was asked for: fields for what was read back
+     * already, in a task of their own, or else one batch drawn and read back
+     * and the first of its fields. Resolves true when any field landed — the
+     * caller asks for a frame then, which draws what landed — and does
+     * nothing while one is already in flight,
+     * while the zoom is moving, or with nothing to set.
+     */
+    pump(): Promise<boolean>;
+    /**
+     * One batch drawn onto the staging surface and read back, and the first
+     * of its fields: the way a string is set on an engine whose layouts do not
+     * answer their own coverage.
+     */
+    private readBack;
+    /**
+     * One slice of strings set from their layouts' own coverage, where the
+     * engine answers it: no staging surface and no readback, so a string
+     * shaped this slice is a field this slice, until the budget is spent — at
+     * least one. Null when the layouts cannot answer, and the batches read
+     * back instead from then on.
+     */
+    private coverageSlice;
+    /**
+     * Fields for what was read back, oldest first, until the slice's budget
+     * is spent — at least one. A field is 0.1-0.4 ms (more texels at 2x);
+     * a batch's worth made as it landed was a frame held back.
+     */
+    private makeFields;
+    /**
+     * Room for a field of a label this far from the view: free room, or room
+     * made by dropping fields — first the ones no pack draws, then the ones
+     * drawn farthest from the view, so long as they are farther than it.
+     * Nothing on screen is dropped for anything. Null when there is none, and
+     * the atlas is `full` until something is freed.
+     */
+    private room;
+    /**
+     * Room made by sliding a shelf's fields together over its gaps: fields
+     * of one height are not one width — `node 7` and `node 1234` — and a
+     * narrow one dropped leaves a gap a wide one does not fit, so gaps apart
+     * are room nothing uses. The fields moved are new placements: a box
+     * drawn from one is written again from where it is now, in the same
+     * frame (`slotOf`).
+     */
+    private squeeze;
+    /** The next field that may go for a label this far from the view, or
+     *  null — skipping the ones already gone, or set again since. */
+    private victim;
+    /** How far from the view the nearest label drawn from a field is. */
+    private reach;
+    /** A field into the place made for it — drawn, until a pack says where,
+     *  where the label that asked for it is. */
+    private put;
+    /** A field written into its channel of the mirror. */
+    private paint;
+    /** A field dropped, and its room given back to its shelf. */
+    private evict;
+    /**
+     * Shelves by height, in steps: a label's field is as tall as the base
+     * size's line and the margin, so nearly every field is one height, and a
+     * field dropped leaves a gap the next one fits. The first fit in a gap,
+     * then the end of a shelf, then a new shelf — on the first page with
+     * room, alpha first.
+     */
+    private allot;
+    /** A field's room back to its shelf, merged with the gaps beside it; a
+     *  shelf left empty at the bottom of its page goes back to the page. */
+    private free;
+    /**
+     * The atlas texture, bound to unit 0, with every field set since the last
+     * call uploaded into it. Made on first use — and made again for a new
+     * context, into which every field is uploaded again from the copies kept
+     * here.
+     */
+    bind(gl: GLLike, fresh: boolean): void;
+    dispose(gl?: GLLike): void;
+}
+type GLLike = any;
+export {};
+//# sourceMappingURL=text.d.ts.map

package/dist/flow/gl/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/flow/gl/text.ts"],"names":[],"mappings":"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"}