@jax-data-science/sci-image-visualizer 0.9.0 → 0.11.0

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":"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","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"]}