@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/region-overlay/svg-region-renderer.mjs

@@ -0,0 +1,228 @@
+import { WORLD, boundsKind, regionHasHoles, regionPathD } from './region-geometry';
+const SVG_NS = 'http://www.w3.org/2000/svg';
+export const IDENTITY_AFFINE = [1, 0, 0, 1, 0, 0];
+/**
+ * The affine of a projection that is affine (pan/zoom/rotate/flip), read from
+ * where it sends (0,0), (1,0) and (0,1) — how the OSD overlay gets its matrix
+ * from the viewport transform without depending on viewer internals. (napari-js
+ * hands the napari overlay its matrix directly: `Viewer.canvasTransform()`.)
+ */
+export function affineFromProjection(project) {
+    const [ox, oy] = project(0, 0);
+    const [ux, uy] = project(1, 0);
+    const [vx, vy] = project(0, 1);
+    return [ux - ox, uy - oy, vx - ox, vy - oy, ox, oy];
+}
+/** Apply an affine to a point. */
+export function applyAffine(m, x, y) {
+    return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+}
+/**
+ * A screen-space layer: elements positioned from world anchors through the
+ * current camera, re-positioned (not rebuilt) on every camera change.
+ */
+export class ScreenLayer {
+    constructor(group, project) {
+        this.group = group;
+        this.project = project;
+        this.placed = [];
+    }
+    /** Append `el`, positioned by `place` now and after every camera change. */
+    place(el, place) {
+        place(el, this.project);
+        this.group.appendChild(el);
+        this.placed.push({ el, place: place });
+        return el;
+    }
+    /** Append `el` with attributes `x`/`y` (e.g. `'cx'`/`'cy'`) at a world point, offset in pixels. */
+    at(el, wx, wy, attrs = {}) {
+        const { x = 'x', y = 'y', dx = 0, dy = 0 } = attrs;
+        return this.place(el, (e, project) => {
+            const [sx, sy] = project(wx, wy);
+            e.setAttribute(x, `${sx + dx}`);
+            e.setAttribute(y, `${sy + dy}`);
+        });
+    }
+    /** A `<line>` between two world points. */
+    line(ax, ay, bx, by) {
+        return this.place(svgEl('line'), (e, project) => {
+            const [x1, y1] = project(ax, ay);
+            const [x2, y2] = project(bx, by);
+            e.setAttribute('x1', `${x1}`);
+            e.setAttribute('y1', `${y1}`);
+            e.setAttribute('x2', `${x2}`);
+            e.setAttribute('y2', `${y2}`);
+        });
+    }
+    /** A `<polygon>` / `<polyline>` through world points. */
+    poly(tag, pts) {
+        return this.place(svgEl(tag), (e, project) => {
+            e.setAttribute('points', pts.map((p) => project(p.x, p.y).join(',')).join(' '));
+        });
+    }
+    /** Re-position every element for the current camera. */
+    reproject() {
+        for (const { el, place } of this.placed)
+            place(el, this.project);
+    }
+    get isEmpty() {
+        return !this.group.firstChild;
+    }
+    clear() {
+        this.placed.length = 0;
+        while (this.group.firstChild)
+            this.group.removeChild(this.group.firstChild);
+    }
+}
+/** Create an SVG element. */
+export function svgEl(tag) {
+    return document.createElementNS(SVG_NS, tag);
+}
+export class SvgRegionRenderer {
+    constructor(svg, opts) {
+        this.svg = svg;
+        this.opts = opts;
+        this.camera = IDENTITY_AFFINE;
+        this.world = svgEl('g');
+        /** World → svg-local pixels through the current camera. */
+        this.project = (x, y) => applyAffine(this.camera, x, y);
+        this.world.setAttribute('data-layer', 'regions');
+        this.labels = new ScreenLayer(svgEl('g'), this.project);
+        this.labels.group.setAttribute('data-layer', 'labels');
+        this.overlay = new ScreenLayer(svgEl('g'), this.project);
+        this.overlay.group.setAttribute('data-layer', 'overlay');
+        this.applyCamera();
+    }
+    /** The current world → svg-local affine. */
+    get affine() {
+        return this.camera;
+    }
+    /**
+     * Move the camera: rewrite the world group's transform and re-position the
+     * screen-space elements. No element is created or removed. Returns false
+     * (and touches nothing) when the affine did not change.
+     */
+    setCamera(affine) {
+        if (!affine.every(Number.isFinite))
+            return false;
+        if (affine.every((v, i) => v === this.camera[i]))
+            return false;
+        this.camera = affine;
+        this.applyCamera();
+        this.labels.reproject();
+        this.overlay.reproject();
+        return true;
+    }
+    /** Rebuild the region shapes (world space) and their decorations. */
+    render(regions, selected) {
+        const shapes = document.createDocumentFragment();
+        this.labels.clear();
+        const sel = new Set(selected);
+        regions.forEach((region, i) => {
+            if (this.opts.skip?.(region))
+                return;
+            const isSel = sel.has(i);
+            const el = this.shapeOf(region);
+            if (el) {
+                el.setAttribute('vector-effect', 'non-scaling-stroke');
+                this.opts.styleShape(el, region, isSel);
+                shapes.appendChild(el);
+            }
+            this.opts.decorate?.(region, i, isSel, this.labels);
+        });
+        while (this.world.firstChild)
+            this.world.removeChild(this.world.firstChild);
+        this.world.appendChild(shapes);
+        this.sync();
+    }
+    /** Rebuild the overlay layer (the selected region's handles, drafts). */
+    renderOverlay(build) {
+        this.overlay.clear();
+        build(this.overlay);
+        this.sync();
+    }
+    /** Remove every layer from the svg. */
+    destroy() {
+        for (const g of [this.world, this.labels.group, this.overlay.group])
+            g.parentNode?.removeChild(g);
+    }
+    applyCamera() {
+        this.world.setAttribute('transform', `matrix(${this.camera.join(' ')})`);
+    }
+    /** Attach the layers that have content (in order) and detach the empty ones. */
+    sync() {
+        const layers = [
+            [this.world, !!this.world.firstChild],
+            [this.labels.group, !this.labels.isEmpty],
+            [this.overlay.group, !this.overlay.isEmpty],
+        ];
+        let before = null;
+        for (let i = layers.length - 1; i >= 0; i--) {
+            const [g, show] = layers[i];
+            if (!show) {
+                g.parentNode?.removeChild(g);
+                continue;
+            }
+            if (g.parentNode !== this.svg || g.nextSibling !== before) {
+                if (before)
+                    this.svg.insertBefore(g, before);
+                else if (g.parentNode !== this.svg)
+                    this.svg.appendChild(g);
+            }
+            before = g;
+        }
+    }
+    /** The world-space element for a region's geometry, or null when it has none. */
+    shapeOf(region) {
+        const b = region.bounds;
+        switch (boundsKind(b)) {
+            case 'rect': {
+                const r = b;
+                const x0 = Math.min(r.x, r.x + r.width), y0 = Math.min(r.y, r.y + r.height);
+                const w = Math.abs(r.width), h = Math.abs(r.height);
+                if (this.opts.rectElement === 'rect') {
+                    const el = svgEl('rect');
+                    el.setAttribute('x', `${x0}`);
+                    el.setAttribute('y', `${y0}`);
+                    el.setAttribute('width', `${w}`);
+                    el.setAttribute('height', `${h}`);
+                    return el;
+                }
+                const el = svgEl('polygon');
+                el.setAttribute('points', `${x0},${y0} ${x0 + w},${y0} ${x0 + w},${y0 + h} ${x0},${y0 + h}`);
+                return el;
+            }
+            case 'poly': {
+                const p = b;
+                const n = p.xpoints?.length ?? 0;
+                if (n === 0)
+                    return null;
+                const holes = regionHasHoles(region);
+                if ((p.bezier && n >= 2) || holes)
+                    return pathEl(regionPathD(region, WORLD), holes);
+                const el = svgEl(p.closed === false ? 'polyline' : 'polygon');
+                let pts = '';
+                for (let i = 0; i < n; i++)
+                    pts += `${i ? ' ' : ''}${p.xpoints[i]},${p.ypoints[i]}`;
+                el.setAttribute('points', pts);
+                return el;
+            }
+            case 'multi': {
+                const parts = b.polygons;
+                if (!parts.some((p) => (p.xpoints?.length ?? 0) >= 3))
+                    return null;
+                return pathEl(regionPathD(region, WORLD), true);
+            }
+            default:
+                return null;
+        }
+    }
+}
+function pathEl(d, evenOdd) {
+    const el = svgEl('path');
+    el.setAttribute('d', d);
+    if (evenOdd)
+        el.setAttribute('fill-rule', 'evenodd');
+    return el;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"svg-region-renderer.js","sourceRoot":"","sources":["../../../../src/lib/region-overlay/svg-region-renderer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * World-space SVG region renderer shared by the OpenSeadragon and napari\n * overlays (review NAPARI-BOUNDARY-10, OSD-PLOTLY-11).\n *\n * The overlays used to delete and rebuild every region element on every camera\n * frame, projecting every vertex to screen pixels (napari also read the layout\n * once per vertex). Here region geometry is drawn ONCE, in world coordinates,\n * inside a single `<g transform=\"matrix(a b c d e f)\">`, with\n * `vector-effect: non-scaling-stroke` so strokes keep their pixel width. A\n * camera change rewrites that one attribute and re-positions the few\n * screen-sized elements (labels, the selected region's handles, a draft) —\n * nothing is created or removed. Region nodes are rebuilt only when the\n * regions or the selection change ({@link render}).\n *\n * Layers, bottom to top, each attached only while it has content:\n *  1. world   — region shapes, in world coordinates (transformed group);\n *  2. labels  — screen-space text pinned to world anchors, rebuilt with the regions;\n *  3. overlay — screen-space handles/drafts, rebuilt by the overlay on demand\n *     ({@link renderOverlay}).\n */\nimport { MultiPolygon, Polygon, Rectangle, Region } from '../models/region';\nimport { WORLD, boundsKind, regionHasHoles, regionPathD } from './region-geometry';\n\nconst SVG_NS = 'http://www.w3.org/2000/svg';\n\n/** An SVG affine `matrix(a b c d e f)`: x' = a·x + c·y + e, y' = b·x + d·y + f. */\nexport type Affine = readonly [number, number, number, number, number, number];\n\n/** World → svg-local pixel projection. */\nexport type Project = (x: number, y: number) => [number, number];\n\nexport const IDENTITY_AFFINE: Affine = [1, 0, 0, 1, 0, 0];\n\n/**\n * The affine of a projection that is affine (pan/zoom/rotate/flip), read from\n * where it sends (0,0), (1,0) and (0,1) — how the OSD overlay gets its matrix\n * from the viewport transform without depending on viewer internals. (napari-js\n * hands the napari overlay its matrix directly: `Viewer.canvasTransform()`.)\n */\nexport function affineFromProjection(project: (x: number, y: number) => readonly [number, number]): Affine {\n  const [ox, oy] = project(0, 0);\n  const [ux, uy] = project(1, 0);\n  const [vx, vy] = project(0, 1);\n  return [ux - ox, uy - oy, vx - ox, vy - oy, ox, oy];\n}\n\n/** Apply an affine to a point. */\nexport function applyAffine(m: Affine, x: number, y: number): [number, number] {\n  return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];\n}\n\n/** How a placed screen element is (re)positioned for the current camera. */\nexport type Placement<T extends SVGElement> = (el: T, project: Project) => void;\n\n/** Options for {@link SvgRegionRenderer}. */\nexport interface SvgRegionRendererOptions {\n  /** Draw a {@link Rectangle} as a `<rect>` or as a four-point `<polygon>`. Default polygon. */\n  rectElement?: 'rect' | 'polygon';\n  /** Stroke and fill for one region's shape element. */\n  styleShape(el: SVGElement, region: Region, selected: boolean): void;\n  /** Add a region's screen-space decorations (its label) — once per {@link render}. */\n  decorate?(region: Region, index: number, selected: boolean, layer: ScreenLayer): void;\n  /** Leave a region out entirely (it keeps its index). */\n  skip?(region: Region): boolean;\n}\n\n/**\n * A screen-space layer: elements positioned from world anchors through the\n * current camera, re-positioned (not rebuilt) on every camera change.\n */\nexport class ScreenLayer {\n  private readonly placed: Array<{ el: SVGElement; place: Placement<SVGElement> }> = [];\n\n  constructor(\n    readonly group: SVGGElement,\n    private readonly project: Project,\n  ) {}\n\n  /** Append `el`, positioned by `place` now and after every camera change. */\n  place<T extends SVGElement>(el: T, place: Placement<T>): T {\n    place(el, this.project);\n    this.group.appendChild(el);\n    this.placed.push({ el, place: place as Placement<SVGElement> });\n    return el;\n  }\n\n  /** Append `el` with attributes `x`/`y` (e.g. `'cx'`/`'cy'`) at a world point, offset in pixels. */\n  at<T extends SVGElement>(\n    el: T,\n    wx: number,\n    wy: number,\n    attrs: { x?: string; y?: string; dx?: number; dy?: number } = {},\n  ): T {\n    const { x = 'x', y = 'y', dx = 0, dy = 0 } = attrs;\n    return this.place(el, (e, project) => {\n      const [sx, sy] = project(wx, wy);\n      e.setAttribute(x, `${sx + dx}`);\n      e.setAttribute(y, `${sy + dy}`);\n    });\n  }\n\n  /** A `<line>` between two world points. */\n  line(ax: number, ay: number, bx: number, by: number): SVGLineElement {\n    return this.place(svgEl('line'), (e, project) => {\n      const [x1, y1] = project(ax, ay);\n      const [x2, y2] = project(bx, by);\n      e.setAttribute('x1', `${x1}`);\n      e.setAttribute('y1', `${y1}`);\n      e.setAttribute('x2', `${x2}`);\n      e.setAttribute('y2', `${y2}`);\n    });\n  }\n\n  /** A `<polygon>` / `<polyline>` through world points. */\n  poly(tag: 'polygon' | 'polyline', pts: ReadonlyArray<{ x: number; y: number }>): SVGElement {\n    return this.place(svgEl(tag), (e, project) => {\n      e.setAttribute('points', pts.map((p) => project(p.x, p.y).join(',')).join(' '));\n    });\n  }\n\n  /** Re-position every element for the current camera. */\n  reproject(): void {\n    for (const { el, place } of this.placed) place(el, this.project);\n  }\n\n  get isEmpty(): boolean {\n    return !this.group.firstChild;\n  }\n\n  clear(): void {\n    this.placed.length = 0;\n    while (this.group.firstChild) this.group.removeChild(this.group.firstChild);\n  }\n}\n\n/** Create an SVG element. */\nexport function svgEl<K extends keyof SVGElementTagNameMap>(tag: K): SVGElementTagNameMap[K] {\n  return document.createElementNS(SVG_NS, tag);\n}\n\nexport class SvgRegionRenderer {\n  private camera: Affine = IDENTITY_AFFINE;\n  private readonly world = svgEl('g');\n  private readonly labels: ScreenLayer;\n  private readonly overlay: ScreenLayer;\n\n  /** World → svg-local pixels through the current camera. */\n  readonly project: Project = (x, y) => applyAffine(this.camera, x, y);\n\n  constructor(\n    private readonly svg: SVGSVGElement,\n    private readonly opts: SvgRegionRendererOptions,\n  ) {\n    this.world.setAttribute('data-layer', 'regions');\n    this.labels = new ScreenLayer(svgEl('g'), this.project);\n    this.labels.group.setAttribute('data-layer', 'labels');\n    this.overlay = new ScreenLayer(svgEl('g'), this.project);\n    this.overlay.group.setAttribute('data-layer', 'overlay');\n    this.applyCamera();\n  }\n\n  /** The current world → svg-local affine. */\n  get affine(): Affine {\n    return this.camera;\n  }\n\n  /**\n   * Move the camera: rewrite the world group's transform and re-position the\n   * screen-space elements. No element is created or removed. Returns false\n   * (and touches nothing) when the affine did not change.\n   */\n  setCamera(affine: Affine): boolean {\n    if (!affine.every(Number.isFinite)) return false;\n    if (affine.every((v, i) => v === this.camera[i])) return false;\n    this.camera = affine;\n    this.applyCamera();\n    this.labels.reproject();\n    this.overlay.reproject();\n    return true;\n  }\n\n  /** Rebuild the region shapes (world space) and their decorations. */\n  render(regions: ReadonlyArray<Region>, selected: ReadonlyArray<number>): void {\n    const shapes = document.createDocumentFragment();\n    this.labels.clear();\n    const sel = new Set(selected);\n    regions.forEach((region, i) => {\n      if (this.opts.skip?.(region)) return;\n      const isSel = sel.has(i);\n      const el = this.shapeOf(region);\n      if (el) {\n        el.setAttribute('vector-effect', 'non-scaling-stroke');\n        this.opts.styleShape(el, region, isSel);\n        shapes.appendChild(el);\n      }\n      this.opts.decorate?.(region, i, isSel, this.labels);\n    });\n    while (this.world.firstChild) this.world.removeChild(this.world.firstChild);\n    this.world.appendChild(shapes);\n    this.sync();\n  }\n\n  /** Rebuild the overlay layer (the selected region's handles, drafts). */\n  renderOverlay(build: (layer: ScreenLayer) => void): void {\n    this.overlay.clear();\n    build(this.overlay);\n    this.sync();\n  }\n\n  /** Remove every layer from the svg. */\n  destroy(): void {\n    for (const g of [this.world, this.labels.group, this.overlay.group]) g.parentNode?.removeChild(g);\n  }\n\n  private applyCamera(): void {\n    this.world.setAttribute('transform', `matrix(${this.camera.join(' ')})`);\n  }\n\n  /** Attach the layers that have content (in order) and detach the empty ones. */\n  private sync(): void {\n    const layers: Array<[SVGGElement, boolean]> = [\n      [this.world, !!this.world.firstChild],\n      [this.labels.group, !this.labels.isEmpty],\n      [this.overlay.group, !this.overlay.isEmpty],\n    ];\n    let before: ChildNode | null = null;\n    for (let i = layers.length - 1; i >= 0; i--) {\n      const [g, show] = layers[i];\n      if (!show) {\n        g.parentNode?.removeChild(g);\n        continue;\n      }\n      if (g.parentNode !== this.svg || g.nextSibling !== before) {\n        if (before) this.svg.insertBefore(g, before);\n        else if (g.parentNode !== this.svg) this.svg.appendChild(g);\n      }\n      before = g;\n    }\n  }\n\n  /** The world-space element for a region's geometry, or null when it has none. */\n  private shapeOf(region: Region): SVGElement | null {\n    const b = region.bounds;\n    switch (boundsKind(b)) {\n      case 'rect': {\n        const r = b as Rectangle;\n        const x0 = Math.min(r.x, r.x + r.width),\n          y0 = Math.min(r.y, r.y + r.height);\n        const w = Math.abs(r.width),\n          h = Math.abs(r.height);\n        if (this.opts.rectElement === 'rect') {\n          const el = svgEl('rect');\n          el.setAttribute('x', `${x0}`);\n          el.setAttribute('y', `${y0}`);\n          el.setAttribute('width', `${w}`);\n          el.setAttribute('height', `${h}`);\n          return el;\n        }\n        const el = svgEl('polygon');\n        el.setAttribute('points', `${x0},${y0} ${x0 + w},${y0} ${x0 + w},${y0 + h} ${x0},${y0 + h}`);\n        return el;\n      }\n      case 'poly': {\n        const p = b as Polygon;\n        const n = p.xpoints?.length ?? 0;\n        if (n === 0) return null;\n        const holes = regionHasHoles(region);\n        if ((p.bezier && n >= 2) || holes) return pathEl(regionPathD(region, WORLD), holes);\n        const el = svgEl(p.closed === false ? 'polyline' : 'polygon');\n        let pts = '';\n        for (let i = 0; i < n; i++) pts += `${i ? ' ' : ''}${p.xpoints[i]},${p.ypoints[i]}`;\n        el.setAttribute('points', pts);\n        return el;\n      }\n      case 'multi': {\n        const parts = (b as MultiPolygon).polygons;\n        if (!parts.some((p) => (p.xpoints?.length ?? 0) >= 3)) return null;\n        return pathEl(regionPathD(region, WORLD), true);\n      }\n      default:\n        return null;\n    }\n  }\n}\n\nfunction pathEl(d: string, evenOdd: boolean): SVGPathElement {\n  const el = svgEl('path');\n  el.setAttribute('d', d);\n  if (evenOdd) el.setAttribute('fill-rule', 'evenodd');\n  return el;\n}\n"]}

package/esm2022/lib/region-source/http-region-source.mjs

@@ -0,0 +1,104 @@
+import { firstValueFrom } from 'rxjs';
+import { RegionTileCache, abortable } from './region-source';
+/** Open the region source at `baseUrl` (its `info` is fetched first). */
+export async function openHttpRegionSource(baseUrl, options = {}) {
+    const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    const http = new Http(base, options);
+    const info = await http.json('info');
+    return new HttpRegionSource(http, info);
+}
+class Http {
+    constructor(base, options) {
+        this.base = base;
+        this.options = options;
+        this.fetchFn = options.fetch ?? ((input, init) => fetch(input, init));
+    }
+    async json(path, body) {
+        return JSON.parse(await this.text(path, body));
+    }
+    async text(path, body) {
+        const http = this.options.http;
+        if (http) {
+            const url = this.base + path;
+            try {
+                return await firstValueFrom(body === undefined
+                    ? http.get(url, { responseType: 'text' })
+                    : http.post(url, body, { responseType: 'text' }));
+            }
+            catch (err) {
+                const status = err?.status;
+                throw new Error(`Region source ${path}: HTTP ${status ?? 'error'}`);
+            }
+        }
+        const init = { ...this.options.init };
+        if (body !== undefined) {
+            init.method = 'POST';
+            init.body = JSON.stringify(body);
+            init.headers = {
+                ...this.options.init?.headers,
+                'Content-Type': 'application/json',
+            };
+        }
+        const res = await this.fetchFn(this.base + path, init);
+        if (!res.ok)
+            throw new Error(`Region source ${path}: HTTP ${res.status}`);
+        return res.text();
+    }
+}
+class HttpRegionSource {
+    constructor(http, info) {
+        this.http = http;
+        this.info = info;
+        this.cache = new RegionTileCache();
+    }
+    getTile(z, key, signal) {
+        // The fetch itself is not aborted: another view (the other backend) may be waiting on the
+        // same cached tile, and a tile is small. Only this caller stops waiting.
+        const tile = this.cache.get(z, key, async () => {
+            const wire = await this.http.json(`tile/${z}/${key.level}/${key.gx}/${key.gy}`);
+            return { z, ...key, features: wire.features.map(fromWire) };
+        });
+        return abortable(tile, signal);
+    }
+    async getFeatures(ids) {
+        if (!ids.length)
+            return [];
+        return (await this.http.json('features', { ids })).features;
+    }
+    getIndex(z, query) {
+        return this.http.json('index', { z, ...query });
+    }
+    async getClassOutlines(classes, level, exclude = []) {
+        const wire = await this.http.json('outlines', { classes, level, exclude });
+        return wire.slices.map((s) => ({
+            z: s.z,
+            rings: s.rings.map((r) => Float32Array.from(r)),
+            ...(s.lines?.length ? { lines: s.lines.map((l) => Float32Array.from(l)) } : {}),
+            ...(s.ringGroups ? { ringGroups: s.ringGroups } : {}),
+            ...(s.ringLabels ? { ringLabels: s.ringLabels } : {}),
+            ...(s.lineLabels ? { lineLabels: s.lineLabels } : {}),
+        }));
+    }
+    getClassCounts(z, exclude = []) {
+        // Every plane is `all` (a plane must be a number: a server that predates it answers 400).
+        return this.http.json('classes', z === null ? { all: true, exclude } : { z, exclude });
+    }
+    exportGeoJson(exclude, extra) {
+        return this.http.text('export', { exclude, extra });
+    }
+    dispose() {
+        this.cache.clear();
+    }
+}
+function fromWire(f) {
+    return {
+        id: f.id,
+        label: f.label ?? null,
+        color: f.color ?? null,
+        bbox: f.bbox,
+        rings: f.rings.map((r) => Float32Array.from(r)),
+        open: !!f.open,
+        ...(f.labels?.length ? { labels: Float32Array.from(f.labels) } : {}),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-region-source.js","sourceRoot":"","sources":["../../../../src/lib/region-source/http-region-source.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A {@link RegionSource} served over HTTP, by a server that tiles a region set as `region-tiles`\n * does (the example tile server's `/regions/…` routes). Relative to the source's base URL:\n *\n *  - `GET  info`                       → {@link RegionSourceInfo}\n *  - `GET  tile/{z}/{level}/{gx}/{gy}` → `{ features: WireTileFeature[] }`\n *  - `POST features` `{ ids }`         → `{ features: SourceFeature[] }`\n *  - `POST index` `{ z, ...query }`    → {@link RegionIndexPage}\n *  - `POST classes` `{ z, exclude }`    → features per class on plane z\n *  - `POST outlines` `{ classes, level, exclude }` → `{ slices: [{ z, rings }] }`\n *  - `POST export` `{ exclude, extra }`→ a GeoJSON FeatureCollection\n *\n * Tile rings travel as flat `[x, y, x, y, …]` arrays, label points as flat `[x, y, room, …]`.\n *\n * Given the host's Angular `HttpClient` (as the visualizer passes it), every request goes through\n * it, so the host's interceptors apply — its auth header above all — as for the image tiles and\n * the spatial data. The library itself knows nothing of authentication.\n */\nimport type { HttpClient } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\nimport { RegionSource, RegionTileCache, SourceFeature, abortable } from './region-source';\nimport type {\n  Bbox,\n  ClassOutlines,\n  RegionIndexPage,\n  RegionIndexQuery,\n  RegionSourceInfo,\n  RegionTile,\n  RegionTileKey,\n  TileFeature,\n} from './region-tiles';\n\n/** A tile feature on the wire: rings as plain arrays. */\nexport interface WireTileFeature {\n  id: string;\n  label: string | null;\n  color: string | null;\n  bbox: Bbox;\n  rings: number[][];\n  open?: boolean;\n  labels?: number[];\n}\n\n/** Options of {@link openHttpRegionSource}. */\nexport interface HttpRegionSourceOptions {\n  /**\n   * The host's `HttpClient`: requests then go through it and its interceptors (the host's auth),\n   * not `fetch`, and `init` and `fetch` are not used.\n   */\n  http?: HttpClient;\n  /** Extra request options (credentials, headers) for every `fetch` request. */\n  init?: RequestInit;\n  /** The fetch to use (default the global one). */\n  fetch?: typeof fetch;\n}\n\n/** Open the region source at `baseUrl` (its `info` is fetched first). */\nexport async function openHttpRegionSource(\n  baseUrl: string,\n  options: HttpRegionSourceOptions = {},\n): Promise<RegionSource> {\n  const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;\n  const http = new Http(base, options);\n  const info = await http.json<RegionSourceInfo>('info');\n  return new HttpRegionSource(http, info);\n}\n\nclass Http {\n  private readonly fetchFn: typeof fetch;\n\n  constructor(\n    private readonly base: string,\n    private readonly options: HttpRegionSourceOptions,\n  ) {\n    this.fetchFn = options.fetch ?? ((input, init) => fetch(input, init));\n  }\n\n  async json<T>(path: string, body?: unknown): Promise<T> {\n    return JSON.parse(await this.text(path, body)) as T;\n  }\n\n  async text(path: string, body?: unknown): Promise<string> {\n    const http = this.options.http;\n    if (http) {\n      const url = this.base + path;\n      try {\n        return await firstValueFrom(\n          body === undefined\n            ? http.get(url, { responseType: 'text' })\n            : http.post(url, body, { responseType: 'text' }),\n        );\n      } catch (err) {\n        const status = (err as { status?: number } | null)?.status;\n        throw new Error(`Region source ${path}: HTTP ${status ?? 'error'}`);\n      }\n    }\n    const init: RequestInit = { ...this.options.init };\n    if (body !== undefined) {\n      init.method = 'POST';\n      init.body = JSON.stringify(body);\n      init.headers = {\n        ...(this.options.init?.headers as Record<string, string>),\n        'Content-Type': 'application/json',\n      };\n    }\n    const res = await this.fetchFn(this.base + path, init);\n    if (!res.ok) throw new Error(`Region source ${path}: HTTP ${res.status}`);\n    return res.text();\n  }\n}\n\nclass HttpRegionSource implements RegionSource {\n  private readonly cache = new RegionTileCache();\n\n  constructor(\n    private readonly http: Http,\n    readonly info: RegionSourceInfo,\n  ) {}\n\n  getTile(z: number, key: RegionTileKey, signal?: AbortSignal): Promise<RegionTile> {\n    // The fetch itself is not aborted: another view (the other backend) may be waiting on the\n    // same cached tile, and a tile is small. Only this caller stops waiting.\n    const tile = this.cache.get(z, key, async () => {\n      const wire = await this.http.json<{ features: WireTileFeature[] }>(\n        `tile/${z}/${key.level}/${key.gx}/${key.gy}`,\n      );\n      return { z, ...key, features: wire.features.map(fromWire) };\n    });\n    return abortable(tile, signal);\n  }\n\n  async getFeatures(ids: readonly string[]): Promise<SourceFeature[]> {\n    if (!ids.length) return [];\n    return (await this.http.json<{ features: SourceFeature[] }>('features', { ids })).features;\n  }\n\n  getIndex(z: number, query: RegionIndexQuery): Promise<RegionIndexPage> {\n    return this.http.json<RegionIndexPage>('index', { z, ...query });\n  }\n\n  async getClassOutlines(\n    classes: readonly string[] | null,\n    level: number,\n    exclude: readonly string[] = [],\n  ): Promise<ClassOutlines[]> {\n    const wire = await this.http.json<{\n      slices: Array<{\n        z: number;\n        rings: number[][];\n        lines?: number[][];\n        ringGroups?: number[];\n        ringLabels?: string[];\n        lineLabels?: string[];\n      }>;\n    }>('outlines', { classes, level, exclude });\n    return wire.slices.map((s) => ({\n      z: s.z,\n      rings: s.rings.map((r) => Float32Array.from(r)),\n      ...(s.lines?.length ? { lines: s.lines.map((l) => Float32Array.from(l)) } : {}),\n      ...(s.ringGroups ? { ringGroups: s.ringGroups } : {}),\n      ...(s.ringLabels ? { ringLabels: s.ringLabels } : {}),\n      ...(s.lineLabels ? { lineLabels: s.lineLabels } : {}),\n    }));\n  }\n\n  getClassCounts(z: number | null, exclude: readonly string[] = []): Promise<Record<string, number>> {\n    // Every plane is `all` (a plane must be a number: a server that predates it answers 400).\n    return this.http.json<Record<string, number>>('classes', z === null ? { all: true, exclude } : { z, exclude });\n  }\n\n  exportGeoJson(exclude: readonly string[], extra: readonly object[]): Promise<string> {\n    return this.http.text('export', { exclude, extra });\n  }\n\n  dispose(): void {\n    this.cache.clear();\n  }\n}\n\nfunction fromWire(f: WireTileFeature): TileFeature {\n  return {\n    id: f.id,\n    label: f.label ?? null,\n    color: f.color ?? null,\n    bbox: f.bbox,\n    rings: f.rings.map((r) => Float32Array.from(r)),\n    open: !!f.open,\n    ...(f.labels?.length ? { labels: Float32Array.from(f.labels) } : {}),\n  };\n}\n"]}

package/esm2022/lib/region-source/region-source-ops.mjs

@@ -0,0 +1,53 @@
+/**
+ * The region-source worker's protocol and the tables it holds, shared by the worker and the
+ * main-thread fallback (which runs the very same {@link RegionSourceTables} where no worker can
+ * start).
+ *
+ * Protocol: `{ id, op, ...args }` → `{ id, ok: true, result }` | `{ id, ok: false, error }`.
+ */
+import { reconstruct } from '../geometry/reconstruct';
+import { RegionFeatureTable, } from './region-tiles';
+/** The open tables, by handle. */
+export class RegionSourceTables {
+    constructor() {
+        this.tables = new Map();
+        this.nextHandle = 1;
+    }
+    run(request) {
+        return this.dispatch(request);
+    }
+    dispatch(r) {
+        switch (r.op) {
+            case 'open': {
+                const table = RegionFeatureTable.fromGeoJson(r.text, r.tileSize);
+                const handle = this.nextHandle++;
+                this.tables.set(handle, table);
+                return { handle, info: table.info() };
+            }
+            case 'tile':
+                return this.table(r.handle).tile(r.z, r.level, r.gx, r.gy);
+            case 'features':
+                return this.table(r.handle).features(r.ids);
+            case 'index':
+                return this.table(r.handle).index(r.z, r.query);
+            case 'classes':
+                return this.table(r.handle).classCounts(r.z, r.exclude);
+            case 'outlines':
+                return this.table(r.handle).classOutlines(r.classes, r.level, r.exclude);
+            case 'mesh':
+                return reconstruct(r.slices, r.options);
+            case 'export':
+                return this.table(r.handle).exportGeoJson(r.exclude, r.extra);
+            case 'close':
+                this.tables.delete(r.handle);
+                return null;
+        }
+    }
+    table(handle) {
+        const table = this.tables.get(handle);
+        if (!table)
+            throw new Error(`No open region source ${handle}.`);
+        return table;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/region-source/region-source-worker.mjs

@@ -0,0 +1,10 @@
+/**
+ * Factory for the region-source Web Worker, isolated in its own module so the `import.meta.url`
+ * reference — which the bundler needs in order to locate the worker — is never pulled into the
+ * ts-jest CommonJS compile of anything that uses it. Same arrangement as
+ * `workers/spatial-math-worker.ts`.
+ */
+export function createRegionSourceWorker() {
+    return new Worker(new URL('./region-source.worker', import.meta.url), { type: 'module' });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaW9uLXNvdXJjZS13b3JrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlZ2lvbi1zb3VyY2UvcmVnaW9uLXNvdXJjZS13b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsd0JBQXdCO0lBQ3RDLE9BQU8sSUFBSSxNQUFNLENBQUMsSUFBSSxHQUFHLENBQUMsd0JBQXdCLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO0FBQzVGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEZhY3RvcnkgZm9yIHRoZSByZWdpb24tc291cmNlIFdlYiBXb3JrZXIsIGlzb2xhdGVkIGluIGl0cyBvd24gbW9kdWxlIHNvIHRoZSBgaW1wb3J0Lm1ldGEudXJsYFxuICogcmVmZXJlbmNlIOKAlCB3aGljaCB0aGUgYnVuZGxlciBuZWVkcyBpbiBvcmRlciB0byBsb2NhdGUgdGhlIHdvcmtlciDigJQgaXMgbmV2ZXIgcHVsbGVkIGludG8gdGhlXG4gKiB0cy1qZXN0IENvbW1vbkpTIGNvbXBpbGUgb2YgYW55dGhpbmcgdGhhdCB1c2VzIGl0LiBTYW1lIGFycmFuZ2VtZW50IGFzXG4gKiBgd29ya2Vycy9zcGF0aWFsLW1hdGgtd29ya2VyLnRzYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVJlZ2lvblNvdXJjZVdvcmtlcigpOiBXb3JrZXIge1xuICByZXR1cm4gbmV3IFdvcmtlcihuZXcgVVJMKCcuL3JlZ2lvbi1zb3VyY2Uud29ya2VyJywgaW1wb3J0Lm1ldGEudXJsKSwgeyB0eXBlOiAnbW9kdWxlJyB9KTtcbn1cbiJdfQ==

package/esm2022/lib/region-source/region-source.mjs

@@ -0,0 +1,67 @@
+/**
+ * ROI GeoJSON at least this many characters long loads as a tiled region source rather than as
+ * regions (see `VizConfig.regionSourceMinChars`).
+ */
+export const REGION_SOURCE_MIN_CHARS = 1_000_000;
+/** Tiles a source keeps, most recently used last. */
+export const REGION_TILE_CACHE_SIZE = 384;
+/** A least-recently-used cache of tile requests. A request that fails is forgotten. */
+export class RegionTileCache {
+    constructor(limit = REGION_TILE_CACHE_SIZE) {
+        this.limit = limit;
+        this.tiles = new Map();
+    }
+    /** The cached tile, else `load()`'s, cached. */
+    get(z, key, load) {
+        const id = `${z}/${key.level}/${key.gx}/${key.gy}`;
+        const hit = this.tiles.get(id);
+        if (hit) {
+            this.tiles.delete(id);
+            this.tiles.set(id, hit);
+            return hit;
+        }
+        const tile = load();
+        this.tiles.set(id, tile);
+        tile.catch(() => {
+            if (this.tiles.get(id) === tile)
+                this.tiles.delete(id);
+        });
+        while (this.tiles.size > this.limit)
+            this.tiles.delete(this.tiles.keys().next().value);
+        return tile;
+    }
+    clear() {
+        this.tiles.clear();
+    }
+}
+/** An `AbortError`, as `fetch` and the workers reject with. */
+export function abortError() {
+    if (typeof DOMException !== 'undefined')
+        return new DOMException('The request was aborted.', 'AbortError');
+    const err = new Error('The request was aborted.');
+    err.name = 'AbortError';
+    return err;
+}
+/** True for the rejection of an aborted request. */
+export function isAbortError(err) {
+    return err?.name === 'AbortError';
+}
+/** `promise`, rejected with an `AbortError` as soon as `signal` fires (the work goes on). */
+export function abortable(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abortError());
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError());
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise.then((v) => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(v);
+        }, (e) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(e);
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-source.js","sourceRoot":"","sources":["../../../../src/lib/region-source/region-source.ts"],"names":[],"mappings":"AA6EA;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,SAAS,CAAC;AAEjD,qDAAqD;AACrD,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAC;AAE1C,uFAAuF;AACvF,MAAM,OAAO,eAAe;IAG1B,YAA6B,QAAQ,sBAAsB;QAA9B,UAAK,GAAL,KAAK,CAAyB;QAF1C,UAAK,GAAG,IAAI,GAAG,EAA+B,CAAC;IAEF,CAAC;IAE/D,gDAAgD;IAChD,GAAG,CAAC,CAAS,EAAE,GAAkB,EAAE,IAA+B;QAChE,MAAM,EAAE,GAAG,GAAG,CAAC,IAAI,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC;QACnD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC/B,IAAI,GAAG,EAAE,CAAC;YACR,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACtB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;YACxB,OAAO,GAAG,CAAC;QACb,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,EAAE,CAAC;QACpB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE;YACd,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI;gBAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACzD,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK;YAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAe,CAAC,CAAC;QACjG,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;CACF;AAED,+DAA+D;AAC/D,MAAM,UAAU,UAAU;IACxB,IAAI,OAAO,YAAY,KAAK,WAAW;QAAE,OAAO,IAAI,YAAY,CAAC,0BAA0B,EAAE,YAAY,CAAC,CAAC;IAC3G,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;IAClD,GAAG,CAAC,IAAI,GAAG,YAAY,CAAC;IACxB,OAAO,GAAG,CAAC;AACb,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,YAAY,CAAC,GAAY;IACvC,OAAQ,GAAgC,EAAE,IAAI,KAAK,YAAY,CAAC;AAClE,CAAC;AAED,6FAA6F;AAC7F,MAAM,UAAU,SAAS,CAAI,OAAmB,EAAE,MAAoB;IACpE,IAAI,CAAC,MAAM;QAAE,OAAO,OAAO,CAAC;IAC5B,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;IACxD,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;QAC3C,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAC1D,OAAO,CAAC,IAAI,CACV,CAAC,CAAC,EAAE,EAAE;YACJ,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC7C,OAAO,CAAC,CAAC,CAAC,CAAC;QACb,CAAC,EACD,CAAC,CAAC,EAAE,EAAE;YACJ,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC7C,MAAM,CAAC,CAAC,CAAC,CAAC;QACZ,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * A tiled region source: one image's large region set, served as level-of-detail tiles so a view\n * never holds or draws the whole set (see `region-tiles` for the levels and tiles).\n *\n * Two implementations behind {@link RegionSource}: a GeoJSON source parsed and tiled in a Web\n * Worker (`openGeoJsonRegionSource`, the main thread only ever sees tiles), and an HTTP source\n * for a server that serves the same tiles (`openHttpRegionSource`).\n */\nimport type {\n  ClassOutlines,\n  GeoJsonFeatureLike,\n  RegionIndexPage,\n  RegionIndexQuery,\n  RegionSourceInfo,\n  RegionTile,\n  RegionTileKey,\n  TileFeature,\n} from './region-tiles';\nimport type { RegionStyle } from '../region-overlay/region-style';\n\n/** A feature's exact GeoJSON with the source's id for it. */\nexport interface SourceFeature {\n  id: string;\n  feature: GeoJsonFeatureLike;\n}\n\n/** One image's tiled region set. */\nexport interface RegionSource {\n  /** What the source holds; known once it is open. */\n  readonly info: RegionSourceInfo;\n  /** One tile of plane `z`. Cached: asking again for a tile in view costs nothing. */\n  getTile(z: number, key: RegionTileKey, signal?: AbortSignal): Promise<RegionTile>;\n  /** The exact features with these ids (unknown ids are skipped). */\n  getFeatures(ids: readonly string[]): Promise<SourceFeature[]>;\n  /** A page of plane `z`'s feature index. */\n  getIndex(z: number, query: RegionIndexQuery): Promise<RegionIndexPage>;\n  /**\n   * Every plane's outlines of the features of these classes, simplified for `level`, without the\n   * `exclude`d ids: what a 3D reconstruction of the classes stacks. `classes` null reads every\n   * class, each outline labelled with its own (what a section through the stack draws).\n   */\n  getClassOutlines(\n    classes: readonly string[] | null,\n    level: number,\n    exclude?: readonly string[],\n  ): Promise<ClassOutlines[]>;\n  /**\n   * How many features of each class plane `z` has (null: every plane, the whole stack), without\n   * the `exclude`d ids.\n   */\n  getClassCounts(z: number | null, exclude?: readonly string[]): Promise<Record<string, number>>;\n  /**\n   * The whole set as a GeoJSON FeatureCollection string, through the working set: `exclude`d\n   * features (taken for editing, or deleted) left out, `extra` features appended.\n   */\n  exportGeoJson(exclude: readonly string[], extra: readonly object[]): Promise<string>;\n  /** Release the source (its worker table, its cache). */\n  dispose(): void;\n}\n\n/** What the store shows of the current slice's region source: what a source layer draws. */\nexport interface RegionSourceView {\n  source: RegionSource;\n  /** The source plane the slice shows. */\n  plane: number;\n  /** Ids the source no longer draws: taken into the working set, or deleted. */\n  taken: ReadonlySet<string>;\n  /** The colour a feature is drawn in (its class colour, as a region of that class gets). */\n  colorOf(feature: Pick<TileFeature, 'label' | 'color'>): string;\n  /** The region look, the regions' own (so a feature looks the same once taken). */\n  style: RegionStyle;\n  /** Whether class labels are shown. */\n  labels: boolean;\n  /** Whether a class's features are hidden (see `RegionStore.setClassesHidden`); default: none is. */\n  isHidden?(label: string | null | undefined): boolean;\n}\n\n/**\n * ROI GeoJSON at least this many characters long loads as a tiled region source rather than as\n * regions (see `VizConfig.regionSourceMinChars`).\n */\nexport const REGION_SOURCE_MIN_CHARS = 1_000_000;\n\n/** Tiles a source keeps, most recently used last. */\nexport const REGION_TILE_CACHE_SIZE = 384;\n\n/** A least-recently-used cache of tile requests. A request that fails is forgotten. */\nexport class RegionTileCache {\n  private readonly tiles = new Map<string, Promise<RegionTile>>();\n\n  constructor(private readonly limit = REGION_TILE_CACHE_SIZE) {}\n\n  /** The cached tile, else `load()`'s, cached. */\n  get(z: number, key: RegionTileKey, load: () => Promise<RegionTile>): Promise<RegionTile> {\n    const id = `${z}/${key.level}/${key.gx}/${key.gy}`;\n    const hit = this.tiles.get(id);\n    if (hit) {\n      this.tiles.delete(id);\n      this.tiles.set(id, hit);\n      return hit;\n    }\n    const tile = load();\n    this.tiles.set(id, tile);\n    tile.catch(() => {\n      if (this.tiles.get(id) === tile) this.tiles.delete(id);\n    });\n    while (this.tiles.size > this.limit) this.tiles.delete(this.tiles.keys().next().value as string);\n    return tile;\n  }\n\n  clear(): void {\n    this.tiles.clear();\n  }\n}\n\n/** An `AbortError`, as `fetch` and the workers reject with. */\nexport function abortError(): Error {\n  if (typeof DOMException !== 'undefined') return new DOMException('The request was aborted.', 'AbortError');\n  const err = new Error('The request was aborted.');\n  err.name = 'AbortError';\n  return err;\n}\n\n/** True for the rejection of an aborted request. */\nexport function isAbortError(err: unknown): boolean {\n  return (err as { name?: string } | null)?.name === 'AbortError';\n}\n\n/** `promise`, rejected with an `AbortError` as soon as `signal` fires (the work goes on). */\nexport function abortable<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {\n  if (!signal) return promise;\n  if (signal.aborted) return Promise.reject(abortError());\n  return new Promise<T>((resolve, reject) => {\n    const onAbort = () => reject(abortError());\n    signal.addEventListener('abort', onAbort, { once: true });\n    promise.then(\n      (v) => {\n        signal.removeEventListener('abort', onAbort);\n        resolve(v);\n      },\n      (e) => {\n        signal.removeEventListener('abort', onAbort);\n        reject(e);\n      },\n    );\n  });\n}\n"]}