@genome-spy/core 0.40.0 → 0.42.0

package/dist/src/data/sources/dynamic/singleAxisLazySource.js

@@ -6,6 +6,12 @@ import { reconfigureScales } from "../../../view/scaleResolution.js";
  * Base class for data sources that listen a domain and propagate data lazily.
  */
 export default class SingleAxisLazySource extends DataSource {
+    /**
+     * Has to be resolved before any data can be requested upon domain changes.
+     * @protected
+     */
+    initializedPromise = Promise.resolve();
+
     /**
      * @param {import("../../../view/view.js").default} view
      * @param {import("../../../spec/channel.js").PrimaryPositionalChannel} channel
@@ -78,6 +84,8 @@ export default class SingleAxisLazySource extends DataSource {
 
     /**
      * Convenience getter for genome.
+     *
+     * @protected
      */
     get genome() {
         return this.scaleResolution.getGenome();
@@ -88,14 +96,27 @@ export default class SingleAxisLazySource extends DataSource {
      *
      * @param {number[]} domain Linearized domain
      * @param {import("../../../spec/genome.js").ChromosomalLocus[]} complexDomain Chrom/Pos domain
+     * @abstract
      */
     async onDomainChanged(domain, complexDomain) {
         // Override me
     }
 
+    /**
+     * Sets the loading status of the data source. The status is shown in the UI.
+     *
+     * @param {boolean} status true if loading, false otherwise
+     * @protected
+     */
+    setLoadingStatus(status) {
+        this.view.context.setDataLoadingStatus(this.view, status);
+    }
+
     /**
      * TODO: Get rid of this method.
      * Rendering should be requested by the collector.
+     *
+     * @protected
      */
     requestRender() {
         // An awfully hacky way.
@@ -109,15 +130,19 @@ export default class SingleAxisLazySource extends DataSource {
     }
 
     /**
+     * Resets the data flow and propagates the data.
      *
-     * @param {import("../../flowNode.js").Datum[]} data
+     * @param {import("../../flowNode.js").Datum[][]} chunks An array of data chunks.
+     * @protected
      */
-    publishData(data) {
+    publishData(chunks) {
         this.reset();
         this.beginBatch({ type: "file" });
 
-        for (const d of data) {
-            this._propagate(d);
+        for (const data of chunks) {
+            for (const d of data) {
+                this._propagate(d);
+            }
         }
 
         this.complete();

package/dist/src/data/sources/dynamic/singleAxisWindowedSource.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @abstract
+ */
+export default class SingleAxisWindowedSource extends SingleAxisLazySource {
+    /**
+     * @type {{windowSize?: number}}
+     * @protected
+     */
+    protected params: {
+        windowSize?: number;
+    };
+    /**
+     * @param {import("../../../spec/data.js").DebouncedData} debounceParams
+     * @protected
+     */
+    protected setupDebouncing(debounceParams: import("../../../spec/data.js").DebouncedData): void;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    onDomainChanged(domain: number[]): Promise<void>;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} interval linearized domain
+     * @protected
+     */
+    protected loadInterval(interval: number[]): Promise<void>;
+    /**
+     * Splits the interval into discrete chromosomal intervals – one for each chromosome –
+     * and loads the data for each of them. Handles abort signals and errors.
+     *
+     * @param {number[]} interval
+     * @param {(discreteInteval: import("@genome-spy/core/genome/genome.js").DiscreteChromosomeInterval, signal: AbortSignal) => Promise<T>} loader
+     * @return {Promise<T[]>}
+     * @template T
+     * @protected
+     */
+    protected discretizeAndLoad<T>(interval: number[], loader: (discreteInteval: import("@genome-spy/core/genome/genome.js").DiscreteChromosomeInterval, signal: AbortSignal) => Promise<T>): Promise<T[]>;
+    /**
+     * Returns three consecutive windows. The idea is to immediately have some data
+     * to show to the user when they pan the view. The windows are conceptually
+     * similar to "tiles" but they are never loaded separately.
+     *
+     * @param {number[]} interval
+     * @param {number} windowSize
+     * @protected
+     */
+    protected quantizeInterval(interval: number[], windowSize: number): number[];
+    /**
+     *
+     * @param {number[]} interval
+     * @protected
+     */
+    protected checkAndUpdateLastInterval(interval: number[]): boolean;
+    #private;
+}
+import SingleAxisLazySource from "./singleAxisLazySource.js";
+//# sourceMappingURL=singleAxisWindowedSource.d.ts.map

package/dist/src/data/sources/dynamic/singleAxisWindowedSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleAxisWindowedSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/singleAxisWindowedSource.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAQI;;;OAGG;IACH,kBAHU;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAC,CAGxB;IAEP;;;OAGG;IACH,0CAHW,OAAO,uBAAuB,EAAE,aAAa,QAmBvD;IAED;;;;OAIG;IACH,wBAFW,MAAM,EAAE,iBAiBlB;IAED;;;;;OAKG;IACH,iCAHW,MAAM,EAAE,iBAKlB;IAED;;;;;;;;;OASG;IACH,yCANW,MAAM,EAAE,4BACU,OAAO,mCAAmC,EAAE,0BAA0B,UAAU,WAAW,+BAqCvH;IAED;;;;;;;;OAQG;IACH,qCAJW,MAAM,EAAE,cACR,MAAM,YAWhB;IAED;;;;OAIG;IACH,+CAHW,MAAM,EAAE,WAUlB;;CACJ;iCAvJgC,2BAA2B"}

package/dist/src/data/sources/dynamic/singleAxisWindowedSource.js

@@ -0,0 +1,152 @@
+import SingleAxisLazySource from "./singleAxisLazySource.js";
+import { shallowArrayEquals } from "../../../utils/arrayUtils.js";
+import { debounce } from "@genome-spy/core/utils/debounce.js";
+
+/**
+ * @abstract
+ */
+export default class SingleAxisWindowedSource extends SingleAxisLazySource {
+    #abortController = new AbortController();
+
+    /**
+     * @type {number[]}
+     */
+    #lastQuantizedInterval = [0, 0];
+
+    /**
+     * @type {{windowSize?: number}}
+     * @protected
+     */
+    params;
+
+    /**
+     * @param {import("../../../spec/data.js").DebouncedData} debounceParams
+     * @protected
+     */
+    setupDebouncing(debounceParams) {
+        if (debounceParams.debounce > 0) {
+            if (debounceParams.debounceMode == "domain") {
+                this.onDomainChanged = debounce(
+                    this.onDomainChanged.bind(this),
+                    debounceParams.debounce,
+                    false
+                );
+            } else if (debounceParams.debounceMode == "window") {
+                this.loadInterval = debounce(
+                    this.loadInterval.bind(this),
+                    debounceParams.debounce,
+                    false
+                );
+            }
+        }
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    async onDomainChanged(domain) {
+        const windowSize = this.params?.windowSize ?? -1;
+
+        if (domain[1] - domain[0] > windowSize) {
+            return;
+        }
+
+        const quantizedInterval = this.quantizeInterval(domain, windowSize);
+
+        if (this.checkAndUpdateLastInterval(quantizedInterval)) {
+            // Possible metadata must be loaded before the first request.
+            await this.initializedPromise;
+
+            this.loadInterval(quantizedInterval);
+        }
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} interval linearized domain
+     * @protected
+     */
+    async loadInterval(interval) {
+        // Override me if needed
+    }
+
+    /**
+     * Splits the interval into discrete chromosomal intervals – one for each chromosome –
+     * and loads the data for each of them. Handles abort signals and errors.
+     *
+     * @param {number[]} interval
+     * @param {(discreteInteval: import("@genome-spy/core/genome/genome.js").DiscreteChromosomeInterval, signal: AbortSignal) => Promise<T>} loader
+     * @return {Promise<T[]>}
+     * @template T
+     * @protected
+     */
+    async discretizeAndLoad(interval, loader) {
+        // Abort previous requests
+        this.#abortController.abort();
+
+        this.setLoadingStatus(true);
+
+        this.#abortController = new AbortController();
+        const signal = this.#abortController.signal;
+
+        // GMOD libraries expect a single chromosome/sequence for each request.
+        // Thus, we split the interval into discrete intervals representing
+        // individual chromosomes and load the data for each of them separately
+        // but in parallel.
+        const discreteChromosomeIntervals =
+            this.genome.continuousToDiscreteChromosomeIntervals(interval);
+
+        try {
+            const resultByChrom = await Promise.all(
+                discreteChromosomeIntervals.map(async (d) => loader(d, signal))
+            );
+
+            if (!signal.aborted) {
+                this.setLoadingStatus(false);
+                return resultByChrom;
+            }
+        } catch (e) {
+            if (!signal.aborted) {
+                // TODO: Nice reporting of errors
+                this.setLoadingStatus(false);
+                throw e;
+            }
+        }
+    }
+
+    /**
+     * Returns three consecutive windows. The idea is to immediately have some data
+     * to show to the user when they pan the view. The windows are conceptually
+     * similar to "tiles" but they are never loaded separately.
+     *
+     * @param {number[]} interval
+     * @param {number} windowSize
+     * @protected
+     */
+    quantizeInterval(interval, windowSize) {
+        return [
+            Math.max(Math.floor(interval[0] / windowSize - 1) * windowSize, 0),
+            Math.min(
+                Math.ceil(interval[1] / windowSize + 1) * windowSize,
+                this.genome.totalSize // Perhaps scale domain should be used here
+            ),
+        ];
+    }
+
+    /**
+     *
+     * @param {number[]} interval
+     * @protected
+     */
+    checkAndUpdateLastInterval(interval) {
+        if (shallowArrayEquals(this.#lastQuantizedInterval, interval)) {
+            return false;
+        }
+
+        this.#lastQuantizedInterval = interval;
+        return true;
+    }
+}

package/dist/src/data/sources/dynamic/tabixSource.d.ts

@@ -1,57 +1,23 @@
-declare const TabixSource_base: {
-    new (...args: any[]): {
-        [x: string]: any;
-        lastQuantizedInterval: number[]; /**
-         * @param {import("../../../spec/data.js").TabixData} params
-         * @param {import("../../../view/view.js").default} view
-         */
-        quantizeInterval(interval: number[], windowSize: number): number[];
-        checkAndUpdateLastInterval(interval: number[]): boolean;
-    };
-} & typeof SingleAxisLazySource;
 /**
  * @template T
+ * @abstract
  */
-export default class TabixSource<T> extends TabixSource_base {
+export default class TabixSource<T> extends SingleAxisWindowedSource {
     /**
      * @param {import("../../../spec/data.js").TabixData} params
      * @param {import("../../../view/view.js").default} view
      */
     constructor(params: import("../../../spec/data.js").TabixData, view: import("../../../view/view.js").default);
-    /** Keep track of the order of the requests */
-    lastRequestId: number;
-    /** @type {import("@gmod/tabix").TabixIndexedFile} */
-    tbiIndex: import("@gmod/tabix").TabixIndexedFile;
     params: import("../../../spec/data.js").TabixData;
-    /**
-     * Listen to the domain change event and update data when the covered windows change.
-     *
-     * @param {number[]} domain Linearized domain
-     */
-    onDomainChanged(domain: number[]): Promise<void>;
     initializedPromise: Promise<any>;
-    /**
-     * Listen to the domain change event and update data when the covered windows change.
-     *
-     * @param {number[]} interval linearized domain
-     */
-    doRequest(interval: number[]): Promise<void>;
-    /**
-     *
-     * @param {number[]} interval
-     */
-    getFeatures(interval: number[]): Promise<{
-        requestId: number;
-        abort: () => void;
-        features: T[];
-    }>;
     /**
      * @abstract
+     * @protected
      * @param {string[]} lines
      * @returns {T[]}
      */
-    _parseFeatures(lines: string[]): T[];
+    protected _parseFeatures(lines: string[]): T[];
+    #private;
 }
-import SingleAxisLazySource from "./singleAxisLazySource.js";
-export {};
+import SingleAxisWindowedSource from "./singleAxisWindowedSource.js";
 //# sourceMappingURL=tabixSource.d.ts.map

package/dist/src/data/sources/dynamic/tabixSource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tabixSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/tabixSource.js"],"names":[],"mappings":";;;yCAeI;;;WAGG;;;;;AAbP;;GAEG;AACH;IAOI;;;OAGG;IACH,oBAHW,OAAO,uBAAuB,EAAE,SAAS,QACzC,OAAO,uBAAuB,EAAE,OAAO,EAmDjD;IA3DD,8CAA8C;IAC9C,sBAAkB;IAElB,qDAAqD;IACrD,UADW,OAAO,aAAa,EAAE,gBAAgB,CACxC;IAiBL,kDAAgC;IAwCpC;;;;OAIG;IACH,wBAFW,MAAM,EAAE,iBAclB;IA3CG,iCAuBE;IAsBN;;;;OAIG;IACH,oBAFW,MAAM,EAAE,iBAWlB;IAED;;;OAGG;IACH,sBAFW,MAAM,EAAE;;;;OAoClB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,CAAC,EAAE,CAIf;CACJ;iCAzJgC,2BAA2B"}
+{"version":3,"file":"tabixSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/tabixSource.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH;IAII;;;OAGG;IACH,oBAHW,OAAO,uBAAuB,EAAE,SAAS,QACzC,OAAO,uBAAuB,EAAE,OAAO,EA8CjD;IAhCG,kDAAgC;IAQhC,iCAuBE;IAoCN;;;;;OAKG;IACH,gCAHW,MAAM,EAAE,GACN,CAAC,EAAE,CAKf;;CACJ;qCAvGoC,+BAA+B"}

package/dist/src/data/sources/dynamic/tabixSource.js

@@ -1,17 +1,13 @@
-import SingleAxisLazySource from "./singleAxisLazySource.js";
-import windowedMixin from "./windowedMixin.js";
-import { debounce } from "../../../utils/debounce.js";
 import addBaseUrl from "../../../utils/addBaseUrl.js";
+import SingleAxisWindowedSource from "./singleAxisWindowedSource.js";
 
 /**
  * @template T
+ * @abstract
  */
-export default class TabixSource extends windowedMixin(SingleAxisLazySource) {
-    /** Keep track of the order of the requests */
-    lastRequestId = 0;
-
+export default class TabixSource extends SingleAxisWindowedSource {
     /** @type {import("@gmod/tabix").TabixIndexedFile} */
-    tbiIndex;
+    #tbiIndex;
 
     /**
      * @param {import("../../../spec/data.js").TabixData} params
@@ -22,7 +18,8 @@ export default class TabixSource extends windowedMixin(SingleAxisLazySource) {
         const paramsWithDefaults = {
             channel: "x",
             windowSize: 3_000_000,
-            debounceDomainChange: 200,
+            debounce: 200,
+            debounceMode: "domain",
             ...params,
         };
 
@@ -34,13 +31,7 @@ export default class TabixSource extends windowedMixin(SingleAxisLazySource) {
             throw new Error("No URL provided for TabixSource");
         }
 
-        if (this.params.debounceDomainChange > 0) {
-            this.onDomainChanged = debounce(
-                this.onDomainChanged.bind(this),
-                this.params.debounceDomainChange,
-                false
-            );
-        }
+        this.setupDebouncing(this.params);
 
         this.initializedPromise = new Promise((resolve) => {
             Promise.all([
@@ -56,7 +47,7 @@ export default class TabixSource extends windowedMixin(SingleAxisLazySource) {
                 const withBase = (/** @type {string} */ uri) =>
                     new RemoteFile(addBaseUrl(uri, this.view.getBaseUrl()));
 
-                this.tbiIndex = new TabixIndexedFile({
+                this.#tbiIndex = new TabixIndexedFile({
                     filehandle: withBase(this.params.url),
                     tbiFilehandle: withBase(
                         this.params.indexUrl ?? this.params.url + ".tbi"
@@ -68,87 +59,47 @@ export default class TabixSource extends windowedMixin(SingleAxisLazySource) {
         });
     }
 
-    /**
-     * Listen to the domain change event and update data when the covered windows change.
-     *
-     * @param {number[]} domain Linearized domain
-     */
-    async onDomainChanged(domain) {
-        const windowSize = this.params.windowSize;
-
-        if (domain[1] - domain[0] > windowSize) {
-            return;
-        }
-
-        const quantizedInterval = this.quantizeInterval(domain, windowSize);
-
-        if (this.checkAndUpdateLastInterval(quantizedInterval)) {
-            this.doRequest(quantizedInterval);
-        }
-    }
-
     /**
      * Listen to the domain change event and update data when the covered windows change.
      *
      * @param {number[]} interval linearized domain
      */
-    async doRequest(interval) {
-        const featureResponse = await this.getFeatures(interval);
-
-        // Discard late responses
-        if (featureResponse.requestId < this.lastRequestId) {
-            return;
-        }
-
-        this.publishData(featureResponse.features);
-    }
-
-    /**
-     *
-     * @param {number[]} interval
-     */
-    async getFeatures(interval) {
-        await this.initializedPromise;
-
-        let requestId = ++this.lastRequestId;
-
-        // TODO: Abort previous requests
-        const abortController = new AbortController();
-
-        const discreteChromosomeIntervals =
-            this.genome.continuousToDiscreteChromosomeIntervals(interval);
-
-        // TODO: Error handling
-        const featuresWithChrom = await Promise.all(
-            discreteChromosomeIntervals.map(async (d) => {
+    async loadInterval(interval) {
+        const featureChunks = await this.discretizeAndLoad(
+            interval,
+            async (discreteInterval, signal) => {
                 /** @type {string[]} */
                 const lines = [];
 
-                await this.tbiIndex.getLines(d.chrom, d.startPos, d.endPos, {
-                    lineCallback: (line) => {
-                        lines.push(line);
-                    },
-                    signal: abortController.signal,
-                });
+                await this.#tbiIndex.getLines(
+                    discreteInterval.chrom,
+                    discreteInterval.startPos,
+                    discreteInterval.endPos,
+                    {
+                        lineCallback: (line) => {
+                            lines.push(line);
+                        },
+                        signal,
+                    }
+                );
 
-                // Hmm. It's silly that we have to first collect individual lines and then join them.
                 return this._parseFeatures(lines);
-            })
+            }
         );
 
-        return {
-            requestId,
-            abort: () => abortController.abort(),
-            features: featuresWithChrom.flat(), // TODO: Use batches, not flat
-        };
+        if (featureChunks) {
+            this.publishData(featureChunks);
+        }
     }
 
     /**
      * @abstract
+     * @protected
      * @param {string[]} lines
      * @returns {T[]}
      */
     _parseFeatures(lines) {
+        // Override me
         return [];
     }
 }

package/dist/src/data/transforms/regexFold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regexFold.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/regexFold.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IAKI;;OAEG;IACH,oBAFW,OAAO,yBAAyB,EAAE,eAAe,EA2H3D;IAfO,gBALO,GAAG,UAKe;CAgBpC;qBAzIsD,gBAAgB"}
+{"version":3,"file":"regexFold.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/regexFold.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IAKI;;OAEG;IACH,oBAFW,OAAO,yBAAyB,EAAE,eAAe,EAmI3D;IAfO,gBALO,GAAG,UAKe;CAgBpC;qBAjJsD,gBAAgB"}

package/dist/src/data/transforms/regexFold.js

@@ -48,6 +48,14 @@ export default class RegexFoldTransform extends FlowNode {
         const detectColumns = (datum) => {
             const colNames = /** @type {string[]} */ (Object.keys(datum));
 
+            for (const re of columnRegex) {
+                if (!colNames.some((colName) => re.test(colName))) {
+                    throw new Error(
+                        `No columns matching the regex ${re.toString()} found in the data!`
+                    );
+                }
+            }
+
             /** @type {Map<string, string[]>} */
             const sampleColMap = new Map();
 

package/dist/src/data/transforms/regexFold.test.js

@@ -157,4 +157,32 @@ describe("RegexFold", () => {
             },
         ]);
     });
+
+    test("Throws error if no columns match the regex", () => {
+        const sampleData = [
+            {
+                row: 1,
+                sample1_a: "r1s1a",
+                sample2_a: "r1s2a",
+            },
+            {
+                row: 2,
+                sample1_a: "r2s1a",
+                sample2_a: "r2s2a",
+            },
+        ];
+
+        /** @type { import("../../spec/transform.js").RegexFoldParams } */
+        const singleGatherConfig = {
+            type: "regexFold",
+            columnRegex: "^(.*)_c$",
+            asValue: "a",
+        };
+
+        expect(() =>
+            processData(new RegexFoldTransform(singleGatherConfig), sampleData)
+        ).toThrowError(
+            "No columns matching the regex /^(.*)_c$/ found in the data!"
+        );
+    });
 });

package/dist/src/encoder/accessor.js

@@ -70,7 +70,9 @@ export default class AccessorFactory {
  * @param {string} expr
  */
 function createExpressionAccessor(expr) {
-    const accessor = /** @type {Accessor} */ (createFunction(expr));
-    accessor.constant = accessor.fields.length == 0; // Not bulletproof, eh
+    const fn = createFunction(expr);
+    const accessor = /** @type {Accessor} */ (/** @type {any} */ (fn));
+    // Not bulletproof and probably erroneous with global params
+    accessor.constant = accessor.fields.length == 0;
     return accessor;
 }

package/dist/src/genomeSpy.d.ts

@@ -13,6 +13,8 @@ export default class GenomeSpy {
      */
     constructor(container: HTMLElement, spec: import("./spec/root.js").RootSpec, options?: import("./types/embedApi.js").EmbedOptions);
     container: HTMLElement;
+    /** @type {(() => void)[]} */
+    _destructionCallbacks: (() => void)[];
     /** Root level configuration object */
     spec: import("./spec/root.js").RootSpec;
     accessorFactory: AccessorFactory;
@@ -67,6 +69,13 @@ export default class GenomeSpy {
     tooltipHandlers: Record<string, import("./tooltip/tooltipHandler.js").TooltipHandler>;
     /** @type {View} */
     viewRoot: import("./view/view.js").default;
+    _paramBroker: ParamBroker;
+    /**
+     * Views that are currently loading data using lazy sources.
+     *
+     * @type {Map<View, boolean>}
+     */
+    _loadingViews: Map<import("./view/view.js").default, boolean>;
     /**
      *
      * @param {(name: string) => any[]} provider
@@ -89,9 +98,15 @@ export default class GenomeSpy {
      * @param {any} [payload]
      */
     broadcast(type: BroadcastEventType, payload?: any): void;
+    /**
+     * Draw some layers on top of the canvas. It's easier to do fancy spinning
+     * animations with html elements than with WebGL.
+     */
+    _updateLoadingIndicators(): void;
     _prepareContainer(): void;
     _glHelper: WebGLHelper;
     loadingMessageElement: HTMLDivElement;
+    loadingIndicatorsElement: HTMLDivElement;
     tooltip: Tooltip;
     /**
      * Unregisters all listeners, removes all created dom elements, removes all css classes from the container
@@ -135,6 +150,7 @@ import Animator from "./utils/animator.js";
 import GenomeStore from "./genome/genomeStore.js";
 import BufferedViewRenderingContext from "./view/renderingContext/bufferedViewRenderingContext.js";
 import Inertia from "./utils/inertia.js";
+import ParamBroker from "./paramBroker.js";
 import WebGLHelper from "./gl/webGLHelper.js";
 import Tooltip from "./utils/ui/tooltip.js";
 import UnitView from "./view/unitView.js";

package/dist/src/genomeSpy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"genomeSpy.d.ts","sourceRoot":"","sources":["../../src/genomeSpy.js"],"names":[],"mappings":"AAyCA;IACI;;;;;OAKG;IAEH;;;;;OAKG;IACH,uBAJW,WAAW,qDAEX,OAAO,qBAAqB,EAAE,YAAY,EA6EpD;IA1EG,uBAA0B;IAM1B,sCAAsC;IACtC,wCAAgB;IAEhB,iCAA4C;IAC5C,yBAAoC;IAEpC,4CAA4C;IAC5C,oBADW,QAAU,MAAM,KAAE,MAAM,EAAE,CAAC,EAAE,CACZ;IAE5B,mBAAoD;IAEpD,0BAA0B;IAC1B,aADW,WAAW,CACM;IAE5B;;;;;OAKG;IACH,qEAF0B,OAAO,CAE8B;IAE/D,2CAA2C;IAC3C,mBADW,4BAA4B,CACL;IAClC,2CAA2C;IAC3C,iBADW,4BAA4B,CACP;IAEhC,oDAAoD;IACpD,6BAAgC;IAEhC;;;OAGG;IACH,eAFU;QAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,oBAAoB,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAEpF;IAE9B,uBAA+C;IAE/C;;;OAGG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAU,aAAa,KAAE,IAAI,CAAC,EAAE,CAAC,CAEpB;IAEnC;;;;;;OAMG;IACH,yCAFkC,GAAG,KAAK,IAAI,GAEd;IAEhC;;;OAGG;IACH,kDAFkC,GAAG,KAAK,IAAI,GAEL;IAEzC,oFAAoF;IACpF,iBADW,OAAO,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,CAK9E;IAED,mBAAmB;IACnB,2CAAyB;IAG7B;;;OAGG;IACH,2CAFkB,MAAM,KAAK,GAAG,EAAE,QAIjC;IAED;;OAEG;IACH,+BAFW,MAAM,YAShB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QACN,GAAG,EAAE,QAaf;IAED;;;;;OAKG;IACH,gBAHW,kBAAkB,YAClB,GAAG,QAQb;IAED,0BA2BC;IAvBG,uBAOC;IAED,sCAA0D;IAK1D,iBAA0C;IAW9C;;OAEG;IACH,gBAiBC;IAED,sCAuMC;IAED;;;OAGG;IACH,UAFa,QAAQ,OAAO,CAAC,CAqC5B;IAED,4BA6IC;IAjIe,iCAAoC;IAmIpD;;;OAGG;IACH,kBAHW,MAAM,KACN,MAAM,QAiEhB;IAED;;;;;;;OAOG;IACH,oDAHuB,QAAQ,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAYlF;IAED,sBAyCC;IAED,kBAIC;IAED,iCAOC;IAED,iCASC;IAED,qFAWC;CACJ;;;;iCAjvBY,eAAe,GAAG,YAAY,GAAG,QAAQ,GAAG,gBAAgB;4BA/B7C,uBAAuB;4BA0BP,uBAAuB;qBAZ9C,qBAAqB;wBAIlB,yBAAyB;yCARR,yDAAyD;oBAYvD,oBAAoB;wBAdvC,qBAAqB;oBAVzB,uBAAuB;qBAQtB,oBAAoB"}
+{"version":3,"file":"genomeSpy.d.ts","sourceRoot":"","sources":["../../src/genomeSpy.js"],"names":[],"mappings":"AA6CA;IACI;;;;;OAKG;IAEH;;;;;OAKG;IACH,uBAJW,WAAW,qDAEX,OAAO,qBAAqB,EAAE,YAAY,EAyFpD;IAtFG,uBAA0B;IAE1B,6BAA6B;IAC7B,uBADW,CAAC,MAAM,IAAI,CAAC,EAAE,CACM;IAM/B,sCAAsC;IACtC,wCAAgB;IAEhB,iCAA4C;IAC5C,yBAAoC;IAEpC,4CAA4C;IAC5C,oBADW,QAAU,MAAM,KAAE,MAAM,EAAE,CAAC,EAAE,CACZ;IAE5B,mBAAoD;IAEpD,0BAA0B;IAC1B,aADW,WAAW,CACM;IAE5B;;;;;OAKG;IACH,qEAF0B,OAAO,CAE8B;IAE/D,2CAA2C;IAC3C,mBADW,4BAA4B,CACL;IAClC,2CAA2C;IAC3C,iBADW,4BAA4B,CACP;IAEhC,oDAAoD;IACpD,6BAAgC;IAEhC;;;OAGG;IACH,eAFU;QAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,oBAAoB,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAEpF;IAE9B,uBAA+C;IAE/C;;;OAGG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAU,aAAa,KAAE,IAAI,CAAC,EAAE,CAAC,CAEpB;IAEnC;;;;;;OAMG;IACH,yCAFkC,GAAG,KAAK,IAAI,GAEd;IAEhC;;;OAGG;IACH,kDAFkC,GAAG,KAAK,IAAI,GAEL;IAEzC,oFAAoF;IACpF,iBADW,OAAO,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,CAK9E;IAED,mBAAmB;IACnB,2CAAyB;IAEzB,0BAAqC;IAErC;;;;OAIG;IACH,8DAA8B;IAGlC;;;OAGG;IACH,2CAFkB,MAAM,KAAK,GAAG,EAAE,QAIjC;IAED;;OAEG;IACH,+BAFW,MAAM,YAShB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QACN,GAAG,EAAE,QAaf;IAED;;;;;OAKG;IACH,gBAHW,kBAAkB,YAClB,GAAG,QAQb;IAED;;;OAGG;IACH,iCAyCC;IAED,0BA0EC;IAtEG,uBAOC;IAyCD,sCAA0D;IAS1D,yCAA6D;IAI7D,iBAA0C;IAW9C;;OAEG;IACH,gBAmBC;IAED,sCA8MC;IAED;;;OAGG;IACH,UAFa,QAAQ,OAAO,CAAC,CA6B5B;IAED,4BA6IC;IAjIe,iCAAoC;IAmIpD;;;OAGG;IACH,kBAHW,MAAM,KACN,MAAM,QAiEhB;IAED;;;;;;;OAOG;IACH,oDAHuB,QAAQ,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAYlF;IAED,sBAyCC;IAED,kBAIC;IAED,iCAOC;IAED,iCASC;IAED,qFAWC;CACJ;;;;iCA51BY,eAAe,GAAG,YAAY,GAAG,QAAQ,GAAG,gBAAgB;4BAhC7C,uBAAuB;4BA0BP,uBAAuB;qBAZ9C,qBAAqB;wBAIlB,yBAAyB;yCARR,yDAAyD;oBAYvD,oBAAoB;wBAMvC,kBAAkB;wBApBlB,qBAAqB;oBAVzB,uBAAuB;qBAQtB,oBAAoB"}