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

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

@@ -0,0 +1,229 @@
+/**
+ * A {@link RegionSource} over a GeoJSON string, parsed and tiled in the region-source Web Worker.
+ *
+ * One worker serves every open source. Where no worker can start (jsdom, SSR, a blocked worker
+ * URL) the same tables run on the main thread; if the worker dies, each source re-opens itself
+ * there from its text (which the host holds anyway: it handed it over) and carries on — whether
+ * it had a call in flight then or not (see {@link RegionSourceWorkerClient.generation}).
+ */
+import { RegionTileCache, abortable } from './region-source';
+import { RegionSourceTables, } from './region-source-ops';
+/** The worker died under a call; the caller re-opens on the main thread. */
+class WorkerLostError extends Error {
+    constructor() {
+        super('The region-source worker stopped.');
+        this.name = 'WorkerLostError';
+    }
+}
+/** Owns the region-source worker and the calls in flight on it. */
+export class RegionSourceWorkerClient {
+    /**
+     * `factory` is optional: without one the real worker module is imported on demand —
+     * dynamically, because it holds an `import.meta.url` that ts-jest's CommonJS compile
+     * rejects.
+     */
+    constructor(factory) {
+        this.factory = factory;
+        this.worker = null;
+        this.starting = null;
+        this.unavailable = false;
+        this.nextId = 1;
+        this.pending = new Map();
+        /** The main-thread tables, once anything runs here. */
+        this.local = null;
+        this.tables = 0;
+    }
+    /** Whether calls now run on the main thread. */
+    get inThread() {
+        return this.unavailable;
+    }
+    /**
+     * Which table set calls run on: bumped when the worker is lost. A handle opened under another
+     * names a table that is gone (or, here, another source's), so its source must open again.
+     */
+    get generation() {
+        return this.tables;
+    }
+    /** Run `request` in the worker, or here when there is none. */
+    async call(request) {
+        return (await this.run(request)).result;
+    }
+    /** {@link call}, with the {@link generation} the request ran on. */
+    async run(request) {
+        const started = await this.ensureWorker();
+        // The worker may have been lost while this waited for it.
+        const worker = started === this.worker ? started : null;
+        const generation = this.tables;
+        if (!worker)
+            return { result: (this.local ??= new RegionSourceTables()).run(request), generation };
+        const id = this.nextId++;
+        const result = await new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: resolve, reject });
+            worker.postMessage({ ...request, id });
+        });
+        return { result, generation };
+    }
+    /** Terminate the worker; calls in flight reject. */
+    dispose() {
+        this.lose();
+    }
+    ensureWorker() {
+        if (this.worker)
+            return Promise.resolve(this.worker);
+        if (this.unavailable || (!this.factory && typeof Worker === 'undefined')) {
+            this.unavailable = true;
+            return Promise.resolve(null);
+        }
+        if (!this.starting) {
+            const starting = this.startWorker();
+            this.starting = starting;
+            void starting.then(() => {
+                if (this.starting === starting)
+                    this.starting = null;
+            });
+        }
+        return this.starting;
+    }
+    async startWorker() {
+        try {
+            const made = this.factory
+                ? this.factory()
+                : import('./region-source-worker').then((m) => m.createRegionSourceWorker());
+            const worker = made instanceof Promise ? await made : made;
+            worker.onmessage = (event) => this.onReply(event.data);
+            worker.onerror = (event) => {
+                event.preventDefault?.();
+                if (worker === this.worker) {
+                    console.warn('[region-source] worker failed; tiling on the main thread');
+                    this.lose();
+                }
+            };
+            this.worker = worker;
+            return worker;
+        }
+        catch (err) {
+            console.warn('[region-source] worker unavailable; tiling on the main thread', err);
+            this.unavailable = true;
+            return null;
+        }
+    }
+    onReply(reply) {
+        const call = this.pending.get(reply.id);
+        if (!call)
+            return;
+        this.pending.delete(reply.id);
+        if (reply.ok)
+            call.resolve(reply.result);
+        else
+            call.reject(new Error(reply.error));
+    }
+    /** Stop the worker for good: every later call runs here, every call in flight is lost. */
+    lose() {
+        if (this.worker)
+            this.tables++;
+        this.unavailable = true;
+        this.worker?.terminate();
+        this.worker = null;
+        const calls = [...this.pending.values()];
+        this.pending.clear();
+        for (const call of calls)
+            call.reject(new WorkerLostError());
+    }
+}
+let shared = null;
+/** The worker client every GeoJSON source shares. */
+export function sharedRegionSourceClient() {
+    return (shared ??= new RegionSourceWorkerClient());
+}
+/**
+ * Open a GeoJSON FeatureCollection string as a tiled region source. Rejects on invalid JSON or
+ * a collection without `features`.
+ */
+export async function openGeoJsonRegionSource(text, client = sharedRegionSourceClient()) {
+    // The worker lost under the open: open on the main thread instead.
+    const opened = await client
+        .run({ op: 'open', text })
+        .catch((err) => (err instanceof WorkerLostError ? client.run({ op: 'open', text }) : Promise.reject(err)));
+    const { handle, info } = opened.result;
+    return new WorkerRegionSource(client, text, handle, opened.generation, info);
+}
+/**
+ * The 3D reconstruction of a region from its outlines on a stack (see `geometry/reconstruct`),
+ * meshed in the region-source worker (on the main thread where there is none).
+ */
+export function reconstructInWorker(slices, options, client = sharedRegionSourceClient()) {
+    return client.call({ op: 'mesh', slices, options });
+}
+class WorkerRegionSource {
+    constructor(client, text, handle, 
+    /** The client's {@link RegionSourceWorkerClient.generation} {@link handle} was opened under. */
+    generation, info) {
+        this.client = client;
+        this.text = text;
+        this.handle = handle;
+        this.generation = generation;
+        this.info = info;
+        this.cache = new RegionTileCache();
+        this.disposed = false;
+        /** The main-thread re-open after the worker died, shared by every call that finds it so. */
+        this.reopening = null;
+    }
+    getTile(z, key, signal) {
+        const tile = this.cache.get(z, key, () => this.call((handle) => ({ op: 'tile', handle, z, level: key.level, gx: key.gx, gy: key.gy })));
+        return abortable(tile, signal);
+    }
+    getFeatures(ids) {
+        return this.call((handle) => ({ op: 'features', handle, ids }));
+    }
+    getIndex(z, query) {
+        return this.call((handle) => ({ op: 'index', handle, z, query }));
+    }
+    getClassOutlines(classes, level, exclude) {
+        return this.call((handle) => ({ op: 'outlines', handle, classes, level, exclude }));
+    }
+    getClassCounts(z, exclude) {
+        return this.call((handle) => ({ op: 'classes', handle, z, exclude }));
+    }
+    exportGeoJson(exclude, extra) {
+        return this.call((handle) => ({ op: 'export', handle, exclude, extra }));
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.cache.clear();
+        // A handle from a lost worker's tables names nothing here, or another source's table.
+        if (this.generation !== this.client.generation)
+            return;
+        void this.client.call({ op: 'close', handle: this.handle }).catch(() => undefined);
+    }
+    /**
+     * Run a request on this source's table; when the worker died (under this call or before it),
+     * re-open here and run it there.
+     */
+    async call(make) {
+        for (let attempt = 0;; attempt++) {
+            if (this.generation !== this.client.generation)
+                await this.reopen();
+            try {
+                return await this.client.call(make(this.handle));
+            }
+            catch (err) {
+                if (!(err instanceof WorkerLostError) || attempt > 0)
+                    throw err;
+            }
+        }
+    }
+    /** Open this source's text again on the client's current tables, once for every call waiting. */
+    reopen() {
+        this.reopening ??= this.client
+            .run({ op: 'open', text: this.text })
+            .then(({ result, generation }) => {
+            this.handle = result.handle;
+            this.generation = generation;
+        })
+            .finally(() => (this.reopening = null));
+        return this.reopening;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker-region-source.js","sourceRoot":"","sources":["../../../../src/lib/region-source/worker-region-source.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A {@link RegionSource} over a GeoJSON string, parsed and tiled in the region-source Web Worker.\n *\n * One worker serves every open source. Where no worker can start (jsdom, SSR, a blocked worker\n * URL) the same tables run on the main thread; if the worker dies, each source re-opens itself\n * there from its text (which the host holds anyway: it handed it over) and carries on — whether\n * it had a call in flight then or not (see {@link RegionSourceWorkerClient.generation}).\n */\nimport { RegionSource, RegionTileCache, SourceFeature, abortable } from './region-source';\nimport {\n  RegionSourceMessage,\n  RegionSourceReply,\n  RegionSourceRequest,\n  RegionSourceResults,\n  RegionSourceTables,\n} from './region-source-ops';\nimport type {\n  ClassOutlines,\n  RegionIndexPage,\n  RegionIndexQuery,\n  RegionSourceInfo,\n  RegionTile,\n  RegionTileKey,\n} from './region-tiles';\nimport type { ReconstructOptions, SliceOutlines } from '../geometry/reconstruct';\nimport type { Mesh } from 'napari-js/geometry';\n\n/** Makes the worker; may be async, as the default one is (it imports the factory on demand). */\nexport type RegionSourceWorkerFactory = () => Worker | Promise<Worker>;\n\n/** The worker died under a call; the caller re-opens on the main thread. */\nclass WorkerLostError extends Error {\n  constructor() {\n    super('The region-source worker stopped.');\n    this.name = 'WorkerLostError';\n  }\n}\n\ninterface PendingCall {\n  resolve: (value: unknown) => void;\n  reject: (reason: unknown) => void;\n}\n\n/** Owns the region-source worker and the calls in flight on it. */\nexport class RegionSourceWorkerClient {\n  private worker: Worker | null = null;\n  private starting: Promise<Worker | null> | null = null;\n  private unavailable = false;\n  private nextId = 1;\n  private readonly pending = new Map<number, PendingCall>();\n  /** The main-thread tables, once anything runs here. */\n  private local: RegionSourceTables | null = null;\n  private tables = 0;\n\n  /**\n   * `factory` is optional: without one the real worker module is imported on demand —\n   * dynamically, because it holds an `import.meta.url` that ts-jest's CommonJS compile\n   * rejects.\n   */\n  constructor(private readonly factory?: RegionSourceWorkerFactory) {}\n\n  /** Whether calls now run on the main thread. */\n  get inThread(): boolean {\n    return this.unavailable;\n  }\n\n  /**\n   * Which table set calls run on: bumped when the worker is lost. A handle opened under another\n   * names a table that is gone (or, here, another source's), so its source must open again.\n   */\n  get generation(): number {\n    return this.tables;\n  }\n\n  /** Run `request` in the worker, or here when there is none. */\n  async call<R extends RegionSourceRequest>(request: R): Promise<RegionSourceResults[R['op']]> {\n    return (await this.run(request)).result;\n  }\n\n  /** {@link call}, with the {@link generation} the request ran on. */\n  async run<R extends RegionSourceRequest>(\n    request: R,\n  ): Promise<{ result: RegionSourceResults[R['op']]; generation: number }> {\n    const started = await this.ensureWorker();\n    // The worker may have been lost while this waited for it.\n    const worker = started === this.worker ? started : null;\n    const generation = this.tables;\n    if (!worker) return { result: (this.local ??= new RegionSourceTables()).run(request), generation };\n    const id = this.nextId++;\n    const result = await new Promise<RegionSourceResults[R['op']]>((resolve, reject) => {\n      this.pending.set(id, { resolve: resolve as (v: unknown) => void, reject });\n      worker.postMessage({ ...request, id } as RegionSourceMessage);\n    });\n    return { result, generation };\n  }\n\n  /** Terminate the worker; calls in flight reject. */\n  dispose(): void {\n    this.lose();\n  }\n\n  private ensureWorker(): Promise<Worker | null> {\n    if (this.worker) return Promise.resolve(this.worker);\n    if (this.unavailable || (!this.factory && typeof Worker === 'undefined')) {\n      this.unavailable = true;\n      return Promise.resolve(null);\n    }\n    if (!this.starting) {\n      const starting = this.startWorker();\n      this.starting = starting;\n      void starting.then(() => {\n        if (this.starting === starting) this.starting = null;\n      });\n    }\n    return this.starting;\n  }\n\n  private async startWorker(): Promise<Worker | null> {\n    try {\n      const made = this.factory\n        ? this.factory()\n        : import('./region-source-worker').then((m) => m.createRegionSourceWorker());\n      const worker = made instanceof Promise ? await made : made;\n      worker.onmessage = (event: MessageEvent<RegionSourceReply>) => this.onReply(event.data);\n      worker.onerror = (event: Event) => {\n        event.preventDefault?.();\n        if (worker === this.worker) {\n          console.warn('[region-source] worker failed; tiling on the main thread');\n          this.lose();\n        }\n      };\n      this.worker = worker;\n      return worker;\n    } catch (err) {\n      console.warn('[region-source] worker unavailable; tiling on the main thread', err);\n      this.unavailable = true;\n      return null;\n    }\n  }\n\n  private onReply(reply: RegionSourceReply): void {\n    const call = this.pending.get(reply.id);\n    if (!call) return;\n    this.pending.delete(reply.id);\n    if (reply.ok) call.resolve(reply.result);\n    else call.reject(new Error(reply.error));\n  }\n\n  /** Stop the worker for good: every later call runs here, every call in flight is lost. */\n  private lose(): void {\n    if (this.worker) this.tables++;\n    this.unavailable = true;\n    this.worker?.terminate();\n    this.worker = null;\n    const calls = [...this.pending.values()];\n    this.pending.clear();\n    for (const call of calls) call.reject(new WorkerLostError());\n  }\n}\n\nlet shared: RegionSourceWorkerClient | null = null;\n\n/** The worker client every GeoJSON source shares. */\nexport function sharedRegionSourceClient(): RegionSourceWorkerClient {\n  return (shared ??= new RegionSourceWorkerClient());\n}\n\n/**\n * Open a GeoJSON FeatureCollection string as a tiled region source. Rejects on invalid JSON or\n * a collection without `features`.\n */\nexport async function openGeoJsonRegionSource(\n  text: string,\n  client: RegionSourceWorkerClient = sharedRegionSourceClient(),\n): Promise<RegionSource> {\n  // The worker lost under the open: open on the main thread instead.\n  const opened = await client\n    .run({ op: 'open', text })\n    .catch((err) => (err instanceof WorkerLostError ? client.run({ op: 'open', text }) : Promise.reject(err)));\n  const { handle, info } = opened.result;\n  return new WorkerRegionSource(client, text, handle, opened.generation, info);\n}\n\n/**\n * The 3D reconstruction of a region from its outlines on a stack (see `geometry/reconstruct`),\n * meshed in the region-source worker (on the main thread where there is none).\n */\nexport function reconstructInWorker(\n  slices: readonly SliceOutlines[],\n  options?: ReconstructOptions,\n  client: RegionSourceWorkerClient = sharedRegionSourceClient(),\n): Promise<Mesh> {\n  return client.call({ op: 'mesh', slices, options });\n}\n\nclass WorkerRegionSource implements RegionSource {\n  private readonly cache = new RegionTileCache();\n  private disposed = false;\n  /** The main-thread re-open after the worker died, shared by every call that finds it so. */\n  private reopening: Promise<void> | null = null;\n\n  constructor(\n    private readonly client: RegionSourceWorkerClient,\n    private readonly text: string,\n    private handle: number,\n    /** The client's {@link RegionSourceWorkerClient.generation} {@link handle} was opened under. */\n    private generation: number,\n    readonly info: RegionSourceInfo,\n  ) {}\n\n  getTile(z: number, key: RegionTileKey, signal?: AbortSignal): Promise<RegionTile> {\n    const tile = this.cache.get(z, key, () =>\n      this.call((handle) => ({ op: 'tile', handle, z, level: key.level, gx: key.gx, gy: key.gy })),\n    );\n    return abortable(tile, signal);\n  }\n\n  getFeatures(ids: readonly string[]): Promise<SourceFeature[]> {\n    return this.call((handle) => ({ op: 'features', handle, ids }));\n  }\n\n  getIndex(z: number, query: RegionIndexQuery): Promise<RegionIndexPage> {\n    return this.call((handle) => ({ op: 'index', handle, z, query }));\n  }\n\n  getClassOutlines(\n    classes: readonly string[] | null,\n    level: number,\n    exclude?: readonly string[],\n  ): Promise<ClassOutlines[]> {\n    return this.call((handle) => ({ op: 'outlines', handle, classes, level, exclude }));\n  }\n\n  getClassCounts(z: number | null, exclude?: readonly string[]): Promise<Record<string, number>> {\n    return this.call((handle) => ({ op: 'classes', handle, z, exclude }));\n  }\n\n  exportGeoJson(exclude: readonly string[], extra: readonly object[]): Promise<string> {\n    return this.call((handle) => ({ op: 'export', handle, exclude, extra }));\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.cache.clear();\n    // A handle from a lost worker's tables names nothing here, or another source's table.\n    if (this.generation !== this.client.generation) return;\n    void this.client.call({ op: 'close', handle: this.handle }).catch(() => undefined);\n  }\n\n  /**\n   * Run a request on this source's table; when the worker died (under this call or before it),\n   * re-open here and run it there.\n   */\n  private async call<R extends RegionSourceRequest>(\n    make: (handle: number) => R,\n  ): Promise<RegionSourceResults[R['op']]> {\n    for (let attempt = 0; ; attempt++) {\n      if (this.generation !== this.client.generation) await this.reopen();\n      try {\n        return await this.client.call(make(this.handle));\n      } catch (err) {\n        if (!(err instanceof WorkerLostError) || attempt > 0) throw err;\n      }\n    }\n  }\n\n  /** Open this source's text again on the client's current tables, once for every call waiting. */\n  private reopen(): Promise<void> {\n    this.reopening ??= this.client\n      .run({ op: 'open', text: this.text })\n      .then(({ result, generation }) => {\n        this.handle = result.handle;\n        this.generation = generation;\n      })\n      .finally(() => (this.reopening = null));\n    return this.reopening;\n  }\n}\n"]}