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

package/esm2022/lib/workers/spatial-math-ops.mjs

@@ -0,0 +1,43 @@
+import { rasterizeDensity } from '../spatial/spatial-density';
+import { expressionField, expressionVolume, } from '../spatial/spatial-expression';
+import { heatmapMatrix, } from '../spatial/spatial-heatmap';
+/** The coordinates of `obs`, without the per-observation strings the math never reads. */
+export function slimObservations(obs) {
+    return obs.z ? { count: obs.count, x: obs.x, y: obs.y, z: obs.z } : { count: obs.count, x: obs.x, y: obs.y };
+}
+/** Run one request synchronously — in the worker, or on the main thread as the fallback. */
+export function runSpatialMath(request) {
+    const r = request;
+    switch (r.op) {
+        case 'expressionField':
+            return expressionField(r.obs, r.opts);
+        case 'expressionVolume':
+            return expressionVolume(r.obs, r.grid, r.opts);
+        case 'rasterizeDensity':
+            return rasterizeDensity(r.obs, r.grid, r.opts);
+        case 'heatmapMatrix':
+            return heatmapMatrix(r.genes, r.groups, r.opts);
+        default:
+            throw new Error(`unknown spatial-math op "${r.op}"`);
+    }
+}
+/**
+ * The buffers of a result, to transfer rather than copy back: the worker made them and
+ * never reads them again. Deduplicated, since a transfer list may not name one twice.
+ */
+export function resultTransferables(result) {
+    const found = new Set();
+    const visit = (v) => {
+        if (ArrayBuffer.isView(v)) {
+            if (v.buffer instanceof ArrayBuffer)
+                found.add(v.buffer);
+        }
+        else if (v && typeof v === 'object') {
+            for (const value of Object.values(v))
+                visit(value);
+        }
+    };
+    visit(result);
+    return [...found];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/workers/spatial-math-worker.mjs

@@ -0,0 +1,10 @@
+/**
+ * Factory for the spatial-math 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 `spatial/tsne-worker.ts` and `region-editor/mask-worker.ts`.
+ */
+export function createSpatialMathWorker() {
+    return new Worker(new URL('./spatial-math.worker', import.meta.url), { type: 'module' });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhdGlhbC1tYXRoLXdvcmtlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvd29ya2Vycy9zcGF0aWFsLW1hdGgtd29ya2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QjtJQUNyQyxPQUFPLElBQUksTUFBTSxDQUFDLElBQUksR0FBRyxDQUFDLHVCQUF1QixFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztBQUMzRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBGYWN0b3J5IGZvciB0aGUgc3BhdGlhbC1tYXRoIFdlYiBXb3JrZXIsIGlzb2xhdGVkIGluIGl0cyBvd24gbW9kdWxlIHNvIHRoZVxuICogYGltcG9ydC5tZXRhLnVybGAgcmVmZXJlbmNlIOKAlCB3aGljaCB0aGUgYnVuZGxlciBuZWVkcyBpbiBvcmRlciB0byBsb2NhdGUgdGhlIHdvcmtlciDigJRcbiAqIGlzIG5ldmVyIHB1bGxlZCBpbnRvIHRoZSB0cy1qZXN0IENvbW1vbkpTIGNvbXBpbGUgb2YgYW55dGhpbmcgdGhhdCB1c2VzIGl0LiBTYW1lXG4gKiBhcnJhbmdlbWVudCBhcyBgc3BhdGlhbC90c25lLXdvcmtlci50c2AgYW5kIGByZWdpb24tZWRpdG9yL21hc2std29ya2VyLnRzYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVNwYXRpYWxNYXRoV29ya2VyKCk6IFdvcmtlciB7XG4gIHJldHVybiBuZXcgV29ya2VyKG5ldyBVUkwoJy4vc3BhdGlhbC1tYXRoLndvcmtlcicsIGltcG9ydC5tZXRhLnVybCksIHsgdHlwZTogJ21vZHVsZScgfSk7XG59XG4iXX0=

package/esm2022/lib/workers/spatial-math.mjs

@@ -0,0 +1,190 @@
+import { runSpatialMath, slimObservations, } from './spatial-math-ops';
+/**
+ * Async, off-main-thread versions of the pure spatial field and density math
+ * (`expressionField`, `expressionVolume`, `rasterizeDensity`, `heatmapMatrix`).
+ *
+ * Each call runs in `spatial-math.worker` when it is big enough to be worth posting, and
+ * on the main thread otherwise — below {@link SPATIAL_MATH_WORKER_MIN_OBSERVATIONS}, where
+ * Web Workers do not exist (jsdom, SSR), or when the worker fails to start. Same
+ * function, same answer either way; only where it runs changes.
+ *
+ * Inputs are copied to the worker, never transferred: they are the dataset's own arrays,
+ * which the caller keeps using. Results are transferred back.
+ *
+ * An `AbortSignal` (a `Supersede` task's, typically) rejects the call with an
+ * `AbortError` as soon as it fires. When that leaves the worker with nothing else to do,
+ * the worker is terminated so the abandoned computation stops using the CPU; the next
+ * call starts a fresh one.
+ */
+/**
+ * Below this many observations (genes × observations for a heatmap) a call runs on the
+ * main thread: copying the inputs to a worker would cost about what it saves.
+ */
+export const SPATIAL_MATH_WORKER_MIN_OBSERVATIONS = 50_000;
+function abortError() {
+    if (typeof DOMException !== 'undefined')
+        return new DOMException('The computation was aborted.', 'AbortError');
+    const err = new Error('The computation was aborted.');
+    err.name = 'AbortError';
+    return err;
+}
+/**
+ * Owns one spatial-math worker and the calls in flight on it. The module-level functions
+ * share one instance; a test, or a caller that wants its own worker, makes another.
+ */
+export class SpatialMathClient {
+    /**
+     * `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, so a static import would break every spec that reaches this file.
+     */
+    constructor(factory) {
+        this.factory = factory;
+        this.worker = null;
+        this.starting = null;
+        /** Set once the worker failed to start or crashed: every later call runs here. */
+        this.unavailable = false;
+        this.nextId = 1;
+        this.pending = new Map();
+    }
+    /** Run `request`, in the worker when `size` reaches the threshold and a worker can run. */
+    async run(request, size, options = {}) {
+        const { signal } = options;
+        if (signal?.aborted)
+            throw abortError();
+        const threshold = options.minObservations ?? SPATIAL_MATH_WORKER_MIN_OBSERVATIONS;
+        const worker = size >= threshold ? await this.ensureWorker() : null;
+        if (signal?.aborted)
+            throw abortError();
+        if (!worker)
+            return runSpatialMath(request);
+        return this.post(worker, request, signal);
+    }
+    /** Terminate the worker; calls still in flight reject with an `AbortError`. */
+    dispose() {
+        const calls = [...this.pending.values()];
+        this.pending.clear();
+        this.stopWorker();
+        for (const call of calls) {
+            call.detach();
+            call.reject(abortError());
+        }
+    }
+    post(worker, request, signal) {
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                if (!this.pending.delete(id))
+                    return;
+                reject(abortError());
+                // Nothing else waits on the worker: stop the abandoned computation outright.
+                if (this.pending.size === 0)
+                    this.stopWorker();
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            this.pending.set(id, {
+                request,
+                resolve,
+                reject,
+                detach: () => signal?.removeEventListener('abort', onAbort),
+            });
+            worker.postMessage({ ...request, id });
+        });
+    }
+    ensureWorker() {
+        if (this.worker)
+            return Promise.resolve(this.worker);
+        if (this.unavailable || (!this.factory && typeof Worker === 'undefined'))
+            return Promise.resolve(null);
+        if (!this.starting) {
+            // Shared by the calls that arrive while the worker is being made, and cleared once it
+            // settles (never by the start itself: a synchronous factory settles it at once).
+            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('./spatial-math-worker').then((m) => m.createSpatialMathWorker());
+            const worker = made instanceof Promise ? await made : made;
+            worker.onmessage = (event) => this.onReply(event.data);
+            worker.onerror = (event) => {
+                event.preventDefault?.();
+                this.onCrash(worker);
+            };
+            this.worker = worker;
+            return worker;
+        }
+        catch (err) {
+            console.warn('[spatial-math] worker unavailable; computing on the main thread', err);
+            this.unavailable = true;
+            return null;
+        }
+    }
+    onReply(reply) {
+        const call = this.pending.get(reply.id);
+        if (!call)
+            return; // aborted while it ran
+        this.pending.delete(reply.id);
+        call.detach();
+        if (reply.ok)
+            call.resolve(reply.result);
+        else
+            call.reject(new Error(reply.error));
+    }
+    /** The worker died (failed to load, or threw outside a request): answer every call here. */
+    onCrash(worker) {
+        if (worker !== this.worker)
+            return;
+        console.warn('[spatial-math] worker failed; computing on the main thread');
+        this.unavailable = true;
+        this.stopWorker();
+        const calls = [...this.pending.values()];
+        this.pending.clear();
+        for (const call of calls) {
+            call.detach();
+            try {
+                call.resolve(runSpatialMath(call.request));
+            }
+            catch (err) {
+                call.reject(err);
+            }
+        }
+    }
+    stopWorker() {
+        this.worker?.terminate();
+        this.worker = null;
+    }
+}
+let shared = null;
+function sharedClient() {
+    return (shared ??= new SpatialMathClient());
+}
+/** Observations a computation covers: its `indices`, or every observation. */
+function covered(indices, count) {
+    return indices ? indices.length : count;
+}
+/** {@link expressionField}, off the main thread when it is big enough to matter. */
+export function computeExpressionFieldAsync(obs, opts, options) {
+    return sharedClient().run({ op: 'expressionField', obs: slimObservations(obs), opts }, covered(opts.indices, obs.count), options);
+}
+/** {@link expressionVolume}, off the main thread when it is big enough to matter. */
+export function computeExpressionVolumeAsync(obs, grid, opts, options) {
+    return sharedClient().run({ op: 'expressionVolume', obs: slimObservations(obs), grid, opts }, covered(opts.indices, obs.count), options);
+}
+/** {@link rasterizeDensity}, off the main thread when it is big enough to matter. */
+export function rasterizeDensityAsync(obs, grid, opts, options) {
+    return sharedClient().run({ op: 'rasterizeDensity', obs: slimObservations(obs), grid, opts }, covered(opts.indices, obs.count), options);
+}
+/** {@link heatmapMatrix}, off the main thread when it is big enough to matter. */
+export function computeHeatmapMatrixAsync(genes, groups, opts = {}, options) {
+    return sharedClient().run({ op: 'heatmapMatrix', genes, groups, opts }, covered(opts.indices, groups.codes.length) * Math.max(1, genes.length), options);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-math.js","sourceRoot":"","sources":["../../../../src/lib/workers/spatial-math.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SpatialObservations } from '../contracts/spatial-dataset.contract';\nimport type { DensityGrid, DensityOptions } from '../spatial/spatial-density';\nimport type {\n  ExpressionField,\n  ExpressionFieldOptions,\n  ExpressionVolumeField,\n  ExpressionVolumeOptions,\n} from '../spatial/spatial-expression';\nimport type { HeatmapGene, HeatmapGroups, HeatmapMatrix, HeatmapMatrixOptions } from '../spatial/spatial-heatmap';\nimport {\n  SpatialMathMessage,\n  SpatialMathReply,\n  SpatialMathRequest,\n  SpatialMathResults,\n  runSpatialMath,\n  slimObservations,\n} from './spatial-math-ops';\n\n/**\n * Async, off-main-thread versions of the pure spatial field and density math\n * (`expressionField`, `expressionVolume`, `rasterizeDensity`, `heatmapMatrix`).\n *\n * Each call runs in `spatial-math.worker` when it is big enough to be worth posting, and\n * on the main thread otherwise — below {@link SPATIAL_MATH_WORKER_MIN_OBSERVATIONS}, where\n * Web Workers do not exist (jsdom, SSR), or when the worker fails to start. Same\n * function, same answer either way; only where it runs changes.\n *\n * Inputs are copied to the worker, never transferred: they are the dataset's own arrays,\n * which the caller keeps using. Results are transferred back.\n *\n * An `AbortSignal` (a `Supersede` task's, typically) rejects the call with an\n * `AbortError` as soon as it fires. When that leaves the worker with nothing else to do,\n * the worker is terminated so the abandoned computation stops using the CPU; the next\n * call starts a fresh one.\n */\n\n/**\n * Below this many observations (genes × observations for a heatmap) a call runs on the\n * main thread: copying the inputs to a worker would cost about what it saves.\n */\nexport const SPATIAL_MATH_WORKER_MIN_OBSERVATIONS = 50_000;\n\n/** Per-call options of the async spatial math. */\nexport interface SpatialMathCallOptions {\n  /** Abandon the call: it rejects with an `AbortError` and its result is dropped. */\n  signal?: AbortSignal;\n  /** Override {@link SPATIAL_MATH_WORKER_MIN_OBSERVATIONS} for this call (0 forces the worker). */\n  minObservations?: number;\n}\n\n/** Makes the worker; may be async, as the default one is (it imports the factory on demand). */\nexport type SpatialMathWorkerFactory = () => Worker | Promise<Worker>;\n\ninterface PendingCall {\n  request: SpatialMathRequest;\n  resolve: (value: unknown) => void;\n  reject: (reason: unknown) => void;\n  detach: () => void;\n}\n\nfunction abortError(): Error {\n  if (typeof DOMException !== 'undefined') return new DOMException('The computation was aborted.', 'AbortError');\n  const err = new Error('The computation was aborted.');\n  err.name = 'AbortError';\n  return err;\n}\n\n/**\n * Owns one spatial-math worker and the calls in flight on it. The module-level functions\n * share one instance; a test, or a caller that wants its own worker, makes another.\n */\nexport class SpatialMathClient {\n  private worker: Worker | null = null;\n  private starting: Promise<Worker | null> | null = null;\n  /** Set once the worker failed to start or crashed: every later call runs here. */\n  private unavailable = false;\n  private nextId = 1;\n  private readonly pending = new Map<number, PendingCall>();\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, so a static import would break every spec that reaches this file.\n   */\n  constructor(private readonly factory?: SpatialMathWorkerFactory) {}\n\n  /** Run `request`, in the worker when `size` reaches the threshold and a worker can run. */\n  async run<R extends SpatialMathRequest>(\n    request: R,\n    size: number,\n    options: SpatialMathCallOptions = {},\n  ): Promise<SpatialMathResults[R['op']]> {\n    const { signal } = options;\n    if (signal?.aborted) throw abortError();\n    const threshold = options.minObservations ?? SPATIAL_MATH_WORKER_MIN_OBSERVATIONS;\n    const worker = size >= threshold ? await this.ensureWorker() : null;\n    if (signal?.aborted) throw abortError();\n    if (!worker) return runSpatialMath(request);\n    return this.post(worker, request, signal) as Promise<SpatialMathResults[R['op']]>;\n  }\n\n  /** Terminate the worker; calls still in flight reject with an `AbortError`. */\n  dispose(): void {\n    const calls = [...this.pending.values()];\n    this.pending.clear();\n    this.stopWorker();\n    for (const call of calls) {\n      call.detach();\n      call.reject(abortError());\n    }\n  }\n\n  private post(worker: Worker, request: SpatialMathRequest, signal?: AbortSignal): Promise<unknown> {\n    const id = this.nextId++;\n    return new Promise((resolve, reject) => {\n      const onAbort = () => {\n        if (!this.pending.delete(id)) return;\n        reject(abortError());\n        // Nothing else waits on the worker: stop the abandoned computation outright.\n        if (this.pending.size === 0) this.stopWorker();\n      };\n      signal?.addEventListener('abort', onAbort, { once: true });\n      this.pending.set(id, {\n        request,\n        resolve,\n        reject,\n        detach: () => signal?.removeEventListener('abort', onAbort),\n      });\n      worker.postMessage({ ...request, id } as SpatialMathMessage);\n    });\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')) return Promise.resolve(null);\n    if (!this.starting) {\n      // Shared by the calls that arrive while the worker is being made, and cleared once it\n      // settles (never by the start itself: a synchronous factory settles it at once).\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('./spatial-math-worker').then((m) => m.createSpatialMathWorker());\n      const worker = made instanceof Promise ? await made : made;\n      worker.onmessage = (event: MessageEvent<SpatialMathReply>) => this.onReply(event.data);\n      worker.onerror = (event: Event) => {\n        event.preventDefault?.();\n        this.onCrash(worker);\n      };\n      this.worker = worker;\n      return worker;\n    } catch (err) {\n      console.warn('[spatial-math] worker unavailable; computing on the main thread', err);\n      this.unavailable = true;\n      return null;\n    }\n  }\n\n  private onReply(reply: SpatialMathReply): void {\n    const call = this.pending.get(reply.id);\n    if (!call) return; // aborted while it ran\n    this.pending.delete(reply.id);\n    call.detach();\n    if (reply.ok) call.resolve(reply.result);\n    else call.reject(new Error(reply.error));\n  }\n\n  /** The worker died (failed to load, or threw outside a request): answer every call here. */\n  private onCrash(worker: Worker): void {\n    if (worker !== this.worker) return;\n    console.warn('[spatial-math] worker failed; computing on the main thread');\n    this.unavailable = true;\n    this.stopWorker();\n    const calls = [...this.pending.values()];\n    this.pending.clear();\n    for (const call of calls) {\n      call.detach();\n      try {\n        call.resolve(runSpatialMath(call.request));\n      } catch (err) {\n        call.reject(err);\n      }\n    }\n  }\n\n  private stopWorker(): void {\n    this.worker?.terminate();\n    this.worker = null;\n  }\n}\n\nlet shared: SpatialMathClient | null = null;\nfunction sharedClient(): SpatialMathClient {\n  return (shared ??= new SpatialMathClient());\n}\n\n/** Observations a computation covers: its `indices`, or every observation. */\nfunction covered(indices: Uint32Array | undefined, count: number): number {\n  return indices ? indices.length : count;\n}\n\n/** {@link expressionField}, off the main thread when it is big enough to matter. */\nexport function computeExpressionFieldAsync(\n  obs: SpatialObservations,\n  opts: ExpressionFieldOptions,\n  options?: SpatialMathCallOptions,\n): Promise<ExpressionField | null> {\n  return sharedClient().run(\n    { op: 'expressionField', obs: slimObservations(obs), opts },\n    covered(opts.indices, obs.count),\n    options,\n  );\n}\n\n/** {@link expressionVolume}, off the main thread when it is big enough to matter. */\nexport function computeExpressionVolumeAsync(\n  obs: SpatialObservations,\n  grid: DensityGrid,\n  opts: ExpressionVolumeOptions,\n  options?: SpatialMathCallOptions,\n): Promise<ExpressionVolumeField | null> {\n  return sharedClient().run(\n    { op: 'expressionVolume', obs: slimObservations(obs), grid, opts },\n    covered(opts.indices, obs.count),\n    options,\n  );\n}\n\n/** {@link rasterizeDensity}, off the main thread when it is big enough to matter. */\nexport function rasterizeDensityAsync(\n  obs: SpatialObservations,\n  grid: DensityGrid,\n  opts: DensityOptions,\n  options?: SpatialMathCallOptions,\n): Promise<Uint8Array | null> {\n  return sharedClient().run(\n    { op: 'rasterizeDensity', obs: slimObservations(obs), grid, opts },\n    covered(opts.indices, obs.count),\n    options,\n  );\n}\n\n/** {@link heatmapMatrix}, off the main thread when it is big enough to matter. */\nexport function computeHeatmapMatrixAsync(\n  genes: readonly HeatmapGene[],\n  groups: HeatmapGroups,\n  opts: HeatmapMatrixOptions = {},\n  options?: SpatialMathCallOptions,\n): Promise<HeatmapMatrix | null> {\n  return sharedClient().run(\n    { op: 'heatmapMatrix', genes, groups, opts },\n    covered(opts.indices, groups.codes.length) * Math.max(1, genes.length),\n    options,\n  );\n}\n"]}