loom-browser 0.0.9 → 0.0.10

package/dist/loom-worker.js

@@ -1600,6 +1600,28 @@ async function handleTask(task) {
     }
 }
 
+/**
+ * Type-safe method dispatch for DataSource configuration.
+ *
+ * Centralizes setter calls by name (e.g., setCumulativeOffsets, setWindowFunction)
+ * on DataSource instances that may or may not implement ConfigurableDataSource.
+ *
+ * Previously used unsafe `Record<string, unknown>` casts — now constrained to
+ * known method names via `DataSourceConfigMethod`.
+ *
+ * Layer 1 (Data): no DOM, no canvas.
+ */
+/**
+ * Call a named configuration setter on a DataSource if it exists.
+ * The method name is constrained to known ConfigurableDataSource methods.
+ */
+function configureDataSource(ds, method, ...args) {
+    const fn = ds[method];
+    if (typeof fn === 'function') {
+        fn.call(ds, ...args);
+    }
+}
+
 // from https://github.com/yume-chan/ya-webadb/blob/main/libraries/dataview-bigint-polyfill
 // license:MIT
 // needed for browsers including safari 14
@@ -3688,9 +3710,6 @@ class BinaryParser {
     available() {
         return this.length - this.position;
     }
-    remLength() {
-        return this.length - this.position;
-    }
     getByte() {
         const retValue = this.view.getUint8(this.position);
         this.position++;
@@ -3914,6 +3933,62 @@ function isWholeGenomeView(locus) {
     return locus.chr.toLowerCase() === 'all';
 }
 
+/**
+ * Whole-genome coordinate transform utilities.
+ *
+ * Shared logic for converting per-chromosome features to genome-wide
+ * coordinates using CumulativeOffsets. Used by all DataSource implementations
+ * that support whole-genome view.
+ *
+ * Layer 1 (Data): no DOM, no canvas.
+ */
+/**
+ * Transform per-chromosome features to genome-wide coordinates.
+ *
+ * For each feature, replaces `chr` with `'all'` and shifts `start`/`end`
+ * by the chromosome's cumulative offset. Features on unknown chromosomes
+ * are silently dropped. Results are sorted by start position.
+ */
+/**
+ * Fetch features for all chromosomes in parallel, tolerating individual failures.
+ *
+ * Uses `Promise.allSettled` so a single chromosome failure doesn't abort the
+ * entire whole-genome view. If ALL chromosomes fail, the first error is re-thrown.
+ *
+ * @param chrNames - Chromosome names to fetch
+ * @param fetchChrom - Per-chromosome fetch function
+ * @param signal - AbortSignal for cancellation
+ * @returns Flattened array of features from all successful chromosome fetches
+ */
+async function fetchAllChromosomes(chrNames, fetchChrom, signal) {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+        return [];
+    const results = await Promise.allSettled(chrNames.map(chr => fetchChrom(chr)));
+    const fulfilled = results.filter((r) => r.status === 'fulfilled');
+    if (fulfilled.length === 0 && results.length > 0) {
+        throw results[0].reason;
+    }
+    return fulfilled.flatMap(r => r.value);
+}
+function transformToWholeGenome(features, offsets) {
+    const result = [];
+    for (const f of features) {
+        if (!f.chr)
+            continue;
+        const offset = offsets.offsets[f.chr];
+        if (offset === undefined)
+            continue;
+        result.push({
+            ...f,
+            chr: 'all',
+            start: offset + f.start,
+            end: offset + f.end,
+        });
+    }
+    result.sort((a, b) => a.start - b.start);
+    return result;
+}
+
 class BigWigDataSource {
     constructor(url, windowFunction = 'mean') {
         this.url = url;
@@ -3957,21 +4032,10 @@ class BigWigDataSource {
      */
     async fetchWG(bpPerPixel, signal) {
         const offsets = this._cumulativeOffsets;
+        if (!offsets)
+            throw new Error('fetchWG called without cumulativeOffsets');
         const features = await fetchBigWigWGFeatures(this.url, offsets.chromosomeNames, bpPerPixel, { windowFunction: this._windowFunction, signal });
-        // Transform to genome-wide coordinates
-        const wgFeatures = [];
-        for (const f of features) {
-            const offset = offsets.offsets[f.chr];
-            if (offset === undefined)
-                continue;
-            wgFeatures.push({
-                ...f,
-                chr: 'all',
-                start: offset + f.start,
-                end: offset + f.end,
-            });
-        }
-        wgFeatures.sort((a, b) => a.start - b.start);
+        const wgFeatures = transformToWholeGenome(features, offsets);
         // Summarize at genome-wide scale
         if (bpPerPixel > 1 && this._windowFunction !== 'none' && wgFeatures.length > 0) {
             return summarizeWigData(wgFeatures, 0, bpPerPixel, this._windowFunction);
@@ -4972,21 +5036,10 @@ class GtxDataSource {
      */
     async fetchWG(bpPerPixel, signal) {
         const offsets = this._cumulativeOffsets;
+        if (!offsets)
+            throw new Error('fetchWG called without cumulativeOffsets');
         const features = await fetchGtxWGFeatures(this.url, this.experimentId, offsets.chromosomeNames, bpPerPixel, { windowFunction: this._windowFunction, signal });
-        // Transform to genome-wide coordinates
-        const wgFeatures = [];
-        for (const f of features) {
-            const offset = offsets.offsets[f.chr];
-            if (offset === undefined)
-                continue;
-            wgFeatures.push({
-                ...f,
-                chr: 'all',
-                start: offset + f.start,
-                end: offset + f.end,
-            });
-        }
-        wgFeatures.sort((a, b) => a.start - b.start);
+        const wgFeatures = transformToWholeGenome(features, offsets);
         // Summarize at genome-wide scale
         if (bpPerPixel > 1 && this._windowFunction !== 'none' && wgFeatures.length > 0) {
             return summarizeWigData(wgFeatures, 0, bpPerPixel, this._windowFunction);
@@ -5023,11 +5076,12 @@ async function fetchGeneFeatures(locus, options = {}, signal) {
     return records.map(decodeRefGeneJson);
 }
 
-/** Maximum number of WG features to avoid rendering performance issues (reservoir sampling). */
-const MAX_WG_FEATURES = 10000;
+/** Default max WG features — reservoir-sampled to avoid rendering performance issues. */
+const DEFAULT_MAX_WG_FEATURES = 10000;
 class GeneDataSource {
-    constructor(options = {}) {
+    constructor(options = {}, maxWgFeatures = DEFAULT_MAX_WG_FEATURES) {
         this.options = options;
+        this.maxWgFeatures = maxWgFeatures;
     }
     /** Set cumulative offsets for whole genome view coordinate transformation. */
     setCumulativeOffsets(offsets) {
@@ -5045,34 +5099,17 @@ class GeneDataSource {
      */
     async fetchWG(signal) {
         const offsets = this._cumulativeOffsets;
-        // Fetch all chromosomes in parallel
-        const promises = offsets.chromosomeNames.map(chr => fetchGeneFeatures({ chr, start: 0, end: Number.MAX_SAFE_INTEGER }, this.options, signal)
-            .catch(() => []) // Skip chromosomes that fail
-        );
-        const perChromResults = await Promise.all(promises);
-        // Transform to genome-wide coordinates, strip exons for WG scale
-        const wgFeatures = [];
-        for (let i = 0; i < offsets.chromosomeNames.length; i++) {
-            const chr = offsets.chromosomeNames[i];
-            const offset = offsets.offsets[chr];
-            if (offset === undefined)
-                continue;
-            for (const f of perChromResults[i]) {
-                wgFeatures.push({
-                    ...f,
-                    chr: 'all',
-                    start: offset + f.start,
-                    end: offset + f.end,
-                    // Strip detailed structure — too zoomed out
-                    exons: undefined,
-                    cdStart: undefined,
-                    cdEnd: undefined,
-                });
-            }
-        }
+        if (!offsets)
+            throw new Error('fetchWG called without cumulativeOffsets');
+        const allFeatures = await fetchAllChromosomes(offsets.chromosomeNames, chr => fetchGeneFeatures({ chr, start: 0, end: Number.MAX_SAFE_INTEGER }, this.options, signal), signal);
+        // Strip detailed structure (too zoomed out for exons)
+        const flat = allFeatures.map(f => ({
+            ...f, exons: undefined, cdStart: undefined, cdEnd: undefined,
+        }));
+        const wgFeatures = transformToWholeGenome(flat, offsets);
         // Downsample with reservoir sampling if too many features
-        if (wgFeatures.length > MAX_WG_FEATURES) {
-            return reservoirSample(wgFeatures, MAX_WG_FEATURES);
+        if (wgFeatures.length > this.maxWgFeatures) {
+            return reservoirSample(wgFeatures, this.maxWgFeatures);
         }
         return wgFeatures;
     }
@@ -10346,6 +10383,9 @@ class TextFeatureSource {
         else {
             text = await response.text();
         }
+        // Check abort before expensive parsing
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+            return;
         const lines = text.split(/\r?\n/);
         // Parse header
         this.header = parseHeader(lines, this.format);
@@ -10366,32 +10406,16 @@ class TextFeatureSource {
     }
     async fetchWG(signal) {
         var _a, _b;
+        if (signal.aborted)
+            return [];
         const offsets = this._cumulativeOffsets;
+        if (!offsets)
+            throw new Error('fetchWG called without cumulativeOffsets');
         if (this._indexed) {
             // For indexed files, fetch all main chromosomes
             const chrNames = mainChromosomeNames(Object.fromEntries(offsets.chromosomeNames.map(name => { var _a; return [name, (_a = offsets.offsets[name]) !== null && _a !== void 0 ? _a : 0]; })));
-            const allFeatures = [];
-            for (const chrName of chrNames) {
-                try {
-                    const features = await this.fetchIndexed(chrName, 0, Number.MAX_SAFE_INTEGER, signal);
-                    const offset = offsets.offsets[chrName];
-                    if (offset === undefined)
-                        continue;
-                    for (const f of features) {
-                        allFeatures.push({
-                            ...f,
-                            chr: 'all',
-                            start: offset + f.start,
-                            end: offset + f.end,
-                        });
-                    }
-                }
-                catch (_c) {
-                    // Skip chromosomes that fail
-                }
-            }
-            allFeatures.sort((a, b) => a.start - b.start);
-            return allFeatures;
+            const allFeatures = await fetchAllChromosomes(chrNames, chrName => this.fetchIndexed(chrName, 0, Number.MAX_SAFE_INTEGER, signal), signal);
+            return transformToWholeGenome(allFeatures, offsets);
         }
         else {
             // Non-indexed: load all, transform coordinates
@@ -10399,24 +10423,54 @@ class TextFeatureSource {
                 await this.loadAllFeatures(signal);
             }
             const allByChrom = (_b = (_a = this.featureCache) === null || _a === void 0 ? void 0 : _a.getAllFeatures()) !== null && _b !== void 0 ? _b : {};
-            const wgFeatures = [];
-            for (const [chr, features] of Object.entries(allByChrom)) {
-                const offset = offsets.offsets[chr];
-                if (offset === undefined)
-                    continue;
-                for (const f of features) {
-                    wgFeatures.push({
-                        ...f,
-                        chr: 'all',
-                        start: offset + f.start,
-                        end: offset + f.end,
-                    });
-                }
+            const allFeatures = [];
+            for (const features of Object.values(allByChrom)) {
+                allFeatures.push(...features);
             }
-            wgFeatures.sort((a, b) => a.start - b.start);
-            return wgFeatures;
+            return transformToWholeGenome(allFeatures, offsets);
         }
     }
+    /** Release resources (TabixReader, feature cache). */
+    dispose() {
+        this.tabixReader = undefined;
+        this.featureCache = undefined;
+        this.allFeaturesLoaded = false;
+    }
+}
+
+/**
+ * Factory: create a DataSource from a serializable DataSourceConfig.
+ *
+ * Shared by MainThreadProvider and DataSourceRegistry (worker-side) to
+ * avoid duplicating the config → DataSource mapping logic.
+ *
+ * Does NOT handle 'memory' or 'sequence' configs — those require
+ * non-serializable inputs (in-memory features, SequenceProvider function)
+ * and must stay on the main thread.
+ *
+ * Layer 1 (Data): no DOM, no canvas.
+ */
+function createDataSource(config) {
+    var _a, _b;
+    switch (config.type) {
+        case 'bigwig':
+            return new BigWigDataSource(config.url, (_a = config.windowFunction) !== null && _a !== void 0 ? _a : 'mean');
+        case 'gtx':
+            return new GtxDataSource(config.url, config.experimentId, (_b = config.windowFunction) !== null && _b !== void 0 ? _b : 'mean');
+        case 'ucsc':
+            return new GeneDataSource({ genome: config.genome, track: config.track });
+        case 'text':
+            return new TextFeatureSource({
+                url: config.url,
+                format: config.format,
+                indexURL: config.indexURL,
+                indexed: config.indexed,
+            });
+        case 'memory':
+            throw new Error('MemoryDataSource cannot be created via provider — use MemoryDataSource directly');
+        default:
+            throw new Error(`Unknown DataSourceConfig type: ${config.type}`);
+    }
 }
 
 /**
@@ -10471,45 +10525,46 @@ class DataSourceRegistry {
         const ds = this.instances.get(instanceId);
         if (!ds)
             return;
-        const fn = ds[method];
-        if (typeof fn === 'function') {
-            fn.call(ds, ...args);
-        }
+        configureDataSource(ds, method, ...args);
     }
     /** Destroy a DataSource instance and clean up. */
     destroy(instanceId) {
+        var _a;
+        const ds = this.instances.get(instanceId);
+        (_a = ds === null || ds === void 0 ? void 0 : ds.dispose) === null || _a === void 0 ? void 0 : _a.call(ds);
         this.instances.delete(instanceId);
     }
 }
+
+/** Extract serializable fields from an error. */
+function serializeError(err) {
+    if (err instanceof Error) {
+        return { message: err.message, name: err.name, stack: err.stack };
+    }
+    return { message: String(err), name: 'Error' };
+}
+
 /**
- * Factory: create a DataSource from a serializable DataSourceConfig.
+ * Structured logger for the Loom genome browser.
  *
- * Does NOT handle 'memory' or 'sequence' configs — those require
- * non-serializable inputs (in-memory features, SequenceProvider function)
- * and must stay on the main thread.
+ * Replaces scattered `console.log/warn/error` calls with a level-gated logger
+ * that can be silenced or redirected by consumers.
+ *
+ * Default level: 'warn' — only warnings and errors are logged.
+ * Call `setLogLevel('silent')` to suppress all output in production.
  */
-function createDataSource(config) {
-    var _a, _b;
-    switch (config.type) {
-        case 'bigwig':
-            return new BigWigDataSource(config.url, (_a = config.windowFunction) !== null && _a !== void 0 ? _a : 'mean');
-        case 'gtx':
-            return new GtxDataSource(config.url, config.experimentId, (_b = config.windowFunction) !== null && _b !== void 0 ? _b : 'mean');
-        case 'ucsc':
-            return new GeneDataSource({ genome: config.genome, track: config.track });
-        case 'text':
-            return new TextFeatureSource({
-                url: config.url,
-                format: config.format,
-                indexURL: config.indexURL,
-                indexed: config.indexed,
-            });
-        case 'memory':
-            throw new Error('MemoryDataSource cannot be created in a worker — requires in-memory features');
-        default:
-            throw new Error(`Unknown DataSourceConfig type: ${config.type}`);
-    }
-}
+const log = {
+    debug(...args) {
+    },
+    info(...args) {
+    },
+    warn(...args) {
+        console.warn('[loom]', ...args);
+    },
+    error(...args) {
+        console.error('[loom]', ...args);
+    },
+};
 
 /**
  * Unified Web Worker entry point — handles both stateless tasks and stateful data sources.
@@ -10529,7 +10584,6 @@ function createDataSource(config) {
  */
 const workerSelf = self;
 const registry = new DataSourceRegistry();
-console.log('[loom worker] initialized');
 workerSelf.onmessage = async (e) => {
     const msg = e.data;
     switch (msg.type) {
@@ -10540,11 +10594,13 @@ workerSelf.onmessage = async (e) => {
                 if (result instanceof ArrayBuffer) {
                     transfer.push(result);
                 }
+                else if (ArrayBuffer.isView(result)) {
+                    transfer.push(result.buffer);
+                }
                 workerSelf.postMessage({ type: 'taskResult', id: msg.id, result }, { transfer });
             }
             catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                workerSelf.postMessage({ type: 'taskResult', id: msg.id, error: message });
+                workerSelf.postMessage({ type: 'taskResult', id: msg.id, error: serializeError(err) });
             }
             break;
         }
@@ -10553,7 +10609,7 @@ workerSelf.onmessage = async (e) => {
                 registry.create(msg.instanceId, msg.config);
             }
             catch (err) {
-                console.error(`[loom worker] create failed for ${msg.instanceId}:`, err);
+                log.error(`create failed for ${msg.instanceId}:`, err);
             }
             break;
         case 'fetch': {
@@ -10567,12 +10623,10 @@ workerSelf.onmessage = async (e) => {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                // Detect abort errors robustly: DOMException with name 'AbortError',
-                // or Error with name 'AbortError', or the browser's native abort
-                // message ("signal is aborted without reason" / "The operation was aborted").
+                // Detect abort errors via the standard AbortError name.
+                // Avoid fragile string matching on error messages.
                 const isAbort = (err instanceof DOMException && err.name === 'AbortError')
-                    || (err instanceof Error && err.name === 'AbortError')
-                    || message.includes('aborted');
+                    || (err instanceof Error && err.name === 'AbortError');
                 workerSelf.postMessage({
                     type: 'fetchError',
                     fetchId: msg.fetchId,