@genome-spy/core 0.72.0 → 0.73.0

package/dist/src/data/formats/bedpe.js

@@ -0,0 +1,160 @@
+const blankLinePattern = /^\s*$/;
+const controlLinePattern = /^\s*(?:browser\b|track\b|#)/;
+
+const defaultColumns = [
+    "chrom1",
+    "start1",
+    "end1",
+    "chrom2",
+    "start2",
+    "end2",
+    "name",
+    "score",
+    "strand1",
+    "strand2",
+];
+
+const requiredColumns = defaultColumns.slice(0, 6);
+
+const normalizeNone = (/** @type {string} */ value) => value;
+const normalizeStringSentinel = (/** @type {string} */ value) =>
+    value == "." ? null : value;
+const normalizeStrand = (/** @type {string} */ value) => {
+    if (value == "+") {
+        return 1;
+    }
+    if (value == "-") {
+        return -1;
+    }
+    return 0;
+};
+const normalizeCoordinate = (/** @type {string} */ value) => {
+    if (value == "." || value == "-1" || value == "") {
+        return null;
+    }
+    const parsed = Number(value);
+    return Number.isInteger(parsed) ? parsed : null;
+};
+const normalizeScore = (/** @type {string} */ value) => {
+    if (value == "." || value == "") {
+        return null;
+    }
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? value : parsed;
+};
+
+/** @type {Record<string, (value: string) => any>} */
+const columnNormalizers = {
+    chrom1: normalizeStringSentinel,
+    chrom2: normalizeStringSentinel,
+    name: normalizeStringSentinel,
+    strand1: normalizeStrand,
+    strand2: normalizeStrand,
+    start1: normalizeCoordinate,
+    end1: normalizeCoordinate,
+    start2: normalizeCoordinate,
+    end2: normalizeCoordinate,
+    score: normalizeScore,
+};
+
+/**
+ * BEDPE has fixed required leading columns; optional tail columns vary by producer.
+ * Detect a header row by matching only the required prefix.
+ *
+ * @param {string[]} row
+ */
+function looksLikeHeaderRow(row) {
+    if (row.length < requiredColumns.length) {
+        return false;
+    }
+
+    for (let i = 0; i < requiredColumns.length; i++) {
+        if (row[i] != requiredColumns[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * @param {string} data
+ * @param {{ columns?: string[] }} [format]
+ */
+export default function bedpe(data, format = {}) {
+    const lines = data.split(/\r?\n/);
+    const explicitColumns = format.columns;
+    let dataStarted = false;
+    let columnsInitialized = false;
+    let lineNumber = 0;
+
+    /** @type {string[]} */
+    const columns = [];
+    /** @type {((value: string) => any)[]} */
+    const normalizers = [];
+    /** @type {Record<string, any>[]} */
+    const rows = [];
+
+    for (const line of lines) {
+        lineNumber++;
+
+        if (line.length == 0) {
+            continue;
+        }
+
+        if (!dataStarted) {
+            if (blankLinePattern.test(line) || controlLinePattern.test(line)) {
+                continue;
+            }
+            dataStarted = true;
+        }
+
+        if (blankLinePattern.test(line)) {
+            continue;
+        }
+
+        const row = line.split("\t");
+
+        if (!columnsInitialized) {
+            const baseColumns = explicitColumns
+                ? explicitColumns
+                : looksLikeHeaderRow(row)
+                  ? row
+                  : defaultColumns;
+
+            for (const column of baseColumns) {
+                columns.push(column);
+                normalizers.push(columnNormalizers[column] ?? normalizeNone);
+            }
+
+            columnsInitialized = true;
+
+            if (!explicitColumns && baseColumns == row) {
+                continue;
+            }
+        }
+
+        while (columns.length < row.length) {
+            columns.push("field" + (columns.length + 1));
+            normalizers.push(normalizeNone);
+        }
+
+        if (row.length < requiredColumns.length) {
+            throw new Error(
+                `BEDPE line ${lineNumber} has ${row.length} columns, expected at least ${requiredColumns.length}.`
+            );
+        }
+
+        /** @type {Record<string, any>} */
+        const datum = {};
+
+        for (let i = 0; i < row.length; i++) {
+            const columnName = columns[i];
+            datum[columnName] = normalizers[i](row[i]);
+        }
+
+        rows.push(datum);
+    }
+
+    return rows;
+}

package/dist/src/data/sources/dataUtils.d.ts

@@ -17,8 +17,16 @@ export function getFormat(params: import("../../spec/data.js").DataSource, urls?
     type?: "json";
     property?: string;
     parse?: import("../../spec/data.js").Parse | null;
+} | {
+    type: "bed";
+    parse?: import("../../spec/data.js").Parse | null;
+} | {
+    type: "bedpe";
+    columns?: string[];
+    parse?: import("../../spec/data.js").Parse | null;
 } | {
     type: string;
+    parse?: import("../../spec/data.js").Parse | null;
 };
 /**
  * @param {string} type
@@ -29,6 +37,10 @@ export function responseType(type: string): string;
  * @param {string | string[]} url
  */
 export function extractTypeFromUrl(url: string | string[]): string;
+/**
+ * @param {string} url
+ */
+export function hasGzipExtension(url: string): boolean;
 /**
  * @param {import("../../spec/data.js").DataFormat} dataFormat
  * @return {dataFormat is import("../../spec/data.js").CsvDataFormat}
@@ -50,6 +62,10 @@ export function isJsonDataFormat(dataFormat: import("../../spec/data.js").DataFo
  * @return {dataSource is import("../../spec/data.js").UrlData}
  */
 export function isUrlData(dataSource: import("../../spec/data.js").DataSource): dataSource is import("../../spec/data.js").UrlData;
+/**
+ * @param {string | undefined} type
+ */
+export function isAutoParseFormat(type: string | undefined): boolean;
 export function makeWrapper(d: any): ((x: import("../../spec/channel.js").Scalar) => {
     data: import("../../spec/channel.js").Scalar;
 }) | ((x: import("../flowNode.js").Datum) => import("../flowNode.js").Datum);

package/dist/src/data/sources/dataUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataUtils.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataUtils.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,kCAJW,OAAO,oBAAoB,EAAE,UAAU,SAEvC,MAAM,GAAG,MAAM,EAAE;;;;;;;;;;;;;EAoB3B;AAED;;;GAGG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;GAEG;AACH,wCAFW,MAAM,GAAG,MAAM,EAAE,UAU3B;AAWD;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,aAAa,CAInE;AAED;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,aAAa,CAInE;AAED;;;GAGG;AACH,6CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,cAAc,CAIpE;AAED;;;;GAIG;AACH,sCAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,OAAO,CAI7D;AAxCM,+BAAgC,GAAG,QAI3B,OAAO,uBAAuB,EAAE,MAAM;;UAGtB,OAAO,gBAAgB,EAAE,KAAK,qCANR"}
+{"version":3,"file":"dataUtils.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/dataUtils.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,kCAJW,OAAO,oBAAoB,EAAE,UAAU,SAEvC,MAAM,GAAG,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;EAsB3B;AAED;;;GAGG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;GAEG;AACH,wCAFW,MAAM,GAAG,MAAM,EAAE,UA2B3B;AAED;;GAEG;AACH,sCAFW,MAAM,WAWhB;AAkBD;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,aAAa,CAInE;AAED;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,aAAa,CAInE;AAED;;;GAGG;AACH,6CAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,cAAc,CAIpE;AAED;;;;GAIG;AACH,sCAHW,OAAO,oBAAoB,EAAE,UAAU,GACtC,UAAU,IAAI,OAAO,oBAAoB,EAAE,OAAO,CAI7D;AAED;;GAEG;AACH,wCAFW,MAAM,GAAG,SAAS,WAI5B;AA/CM,+BAAgC,GAAG,QAI3B,OAAO,uBAAuB,EAAE,MAAM;;UAGtB,OAAO,gBAAgB,EAAE,KAAK,qCANR"}

package/dist/src/data/sources/dataUtils.js

@@ -1,6 +1,9 @@
 import { formats } from "vega-loader";
 import { isInlineData } from "./inlineSource.js";
 
+const autoParseFormats = new Set(["csv", "tsv", "dsv"]);
+const compressionExtensions = new Set(["gz", "bgz", "bgzf"]);
+
 /**
  * Validates data source params, infers format if not specified explicitly,
  * returns a complete DataSource params object.
@@ -16,8 +19,10 @@ export function getFormat(params, urls = []) {
     const format = { ...params.format };
 
     format.type ??= isUrlData(params) && extractTypeFromUrl(urls);
-    // @ts-ignore TODO: Fix typing
-    format.parse ??= "auto";
+    if (format.parse === undefined && isAutoParseFormat(format.type)) {
+        // @ts-ignore TODO: Fix typing
+        format.parse = "auto";
+    }
 
     if (!format.type) {
         throw new Error(
@@ -46,8 +51,46 @@ export function extractTypeFromUrl(url) {
     }
 
     if (url) {
-        return url.match(/\.(csv|tsv|json)/)?.[1];
+        const path = stripUrlQueryAndHash(url).split("/").pop()?.toLowerCase();
+
+        if (!path) {
+            return;
+        }
+
+        const extensions = path.split(".");
+        while (
+            extensions.length > 1 &&
+            compressionExtensions.has(extensions.at(-1))
+        ) {
+            extensions.pop();
+        }
+
+        const extension = extensions.at(-1);
+        if (extension && formats(extension)) {
+            return extension;
+        }
+    }
+}
+
+/**
+ * @param {string} url
+ */
+export function hasGzipExtension(url) {
+    const path = stripUrlQueryAndHash(url).split("/").pop()?.toLowerCase();
+
+    if (!path) {
+        return false;
     }
+
+    const extension = path.split(".").at(-1);
+    return !!extension && compressionExtensions.has(extension);
+}
+
+/**
+ * @param {string} url
+ */
+function stripUrlQueryAndHash(url) {
+    return url.replace(/[?#].*$/, "");
 }
 
 export const makeWrapper = (/** @type {any} */ d) =>
@@ -91,3 +134,10 @@ export function isJsonDataFormat(dataFormat) {
 export function isUrlData(dataSource) {
     return "url" in dataSource;
 }
+
+/**
+ * @param {string | undefined} type
+ */
+export function isAutoParseFormat(type) {
+    return autoParseFormats.has(type);
+}

package/dist/src/data/sources/urlSource.d.ts

@@ -3,6 +3,10 @@
  * @returns {data is import("../../spec/data.js").UrlData}
  */
 export function isUrlData(data: Partial<import("../../spec/data.js").Data>): data is import("../../spec/data.js").UrlData;
+/**
+ * Loads eager data from URLs and transparently decompresses gzip-compatible
+ * payloads before handing them to the registered format reader.
+ */
 export default class UrlSource extends DataSource {
     /**
      * @param {import("../../spec/data.js").UrlData} params

package/dist/src/data/sources/urlSource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"urlSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/urlSource.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,gCAHW,OAAO,CAAC,OAAO,oBAAoB,EAAE,IAAI,CAAC,GACxC,IAAI,IAAI,OAAO,oBAAoB,EAAE,OAAO,CAIxD;AAED;IACI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,OAAO,QACpC,OAAO,oBAAoB,EAAE,OAAO,EAc9C;IATG,6CAMC;IAED,gBAAiC;;CA4GxC;uBA3IsB,iBAAiB"}
+{"version":3,"file":"urlSource.d.ts","sourceRoot":"","sources":["../../../../src/data/sources/urlSource.js"],"names":[],"mappings":"AA+IA;;;GAGG;AACH,gCAHW,OAAO,CAAC,OAAO,oBAAoB,EAAE,IAAI,CAAC,GACxC,IAAI,IAAI,OAAO,oBAAoB,EAAE,OAAO,CAIxD;AAzID;;;GAGG;AACH;IACI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,OAAO,QACpC,OAAO,oBAAoB,EAAE,OAAO,EAc9C;IATG,6CAMC;IAED,gBAAiC;;CA6GxC;uBA3IsB,iBAAiB"}

package/dist/src/data/sources/urlSource.js

@@ -1,5 +1,5 @@
 import { read } from "vega-loader";
-import { getFormat, responseType } from "./dataUtils.js";
+import { getFormat, hasGzipExtension, responseType } from "./dataUtils.js";
 import DataSource from "./dataSource.js";
 import {
     activateExprRefProps,
@@ -7,14 +7,13 @@ import {
 } from "../../paramRuntime/paramUtils.js";
 import { concatUrl } from "../../utils/url.js";
 
+const gzipMimeTypes = new Set(["application/gzip", "application/x-gzip"]);
+const textDecoder = new TextDecoder();
+
 /**
- * @param {Partial<import("../../spec/data.js").Data>} data
- * @returns {data is import("../../spec/data.js").UrlData}
+ * Loads eager data from URLs and transparently decompresses gzip-compatible
+ * payloads before handing them to the registered format reader.
  */
-export function isUrlData(data) {
-    return "url" in data;
-}
-
 export default class UrlSource extends DataSource {
     /**
      * @param {import("../../spec/data.js").UrlData} params
@@ -48,6 +47,7 @@ export default class UrlSource extends DataSource {
      */
     async #loadUrlsFromFile(props) {
         const listUrl = concatUrl(this.baseUrl, props.urlsFromFile);
+        const format = { type: props.type ?? "tsv" };
 
         const result = await fetch(listUrl);
 
@@ -56,10 +56,14 @@ export default class UrlSource extends DataSource {
                 `Cannot load "${listUrl}": ${result.status} ${result.statusText}`
             );
         }
-        const text = await result.text();
+        const content = await readResponseBody(
+            result,
+            listUrl,
+            responseType(format.type)
+        );
 
         const files = /** @type {string[] | {url: string}[]} */ (
-            read(text, { type: props.type ?? "tsv" })
+            read(content, format)
         )
             .map((u) => (typeof u === "string" ? u : u.url))
             .map((u) => concatUrl(listUrl, u));
@@ -94,11 +98,7 @@ export default class UrlSource extends DataSource {
                 if (!result.ok) {
                     throw new Error(`${result.status} ${result.statusText}`);
                 }
-                // @ts-ignore
-                return typeof result[type] == "function"
-                    ? // @ts-ignore
-                      result[type]()
-                    : result.text();
+                return await readResponseBody(result, url, type);
             } catch (e) {
                 throw new Error(
                     `Could not load data: ${url}. Reason: ${e.message}`
@@ -140,3 +140,122 @@ export default class UrlSource extends DataSource {
         this.complete();
     }
 }
+
+/**
+ * @param {Partial<import("../../spec/data.js").Data>} data
+ * @returns {data is import("../../spec/data.js").UrlData}
+ */
+export function isUrlData(data) {
+    return "url" in data;
+}
+
+/**
+ * @param {Uint8Array} bytes
+ */
+function hasGzipMagic(bytes) {
+    return (
+        bytes.length >= 10 &&
+        bytes[0] == 0x1f &&
+        bytes[1] == 0x8b &&
+        bytes[2] == 0x08 &&
+        (bytes[3] & 0xe0) == 0
+    );
+}
+
+/**
+ * @param {string | null} contentType
+ */
+function isGzipMimeType(contentType) {
+    if (!contentType) {
+        return false;
+    }
+
+    return gzipMimeTypes.has(contentType.split(";")[0].trim().toLowerCase());
+}
+
+/**
+ * @param {string | null} contentEncoding
+ */
+function hasGzipContentEncoding(contentEncoding) {
+    if (!contentEncoding) {
+        return false;
+    }
+
+    return contentEncoding
+        .toLowerCase()
+        .split(",")
+        .some((encoding) => encoding.trim() == "gzip");
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {ArrayBuffer}
+ */
+function toArrayBuffer(bytes) {
+    return new Uint8Array(bytes).buffer;
+}
+
+/**
+ * @param {Uint8Array} bytes
+ */
+async function decompressGzip(bytes) {
+    if (typeof DecompressionStream != "function") {
+        throw new Error(
+            "Gzip-compressed URL data requires DecompressionStream support."
+        );
+    }
+
+    const body = new Response(toArrayBuffer(bytes)).body;
+    if (!body) {
+        throw new Error(
+            "Cannot create a readable stream for gzip decompression."
+        );
+    }
+
+    const stream = body.pipeThrough(new DecompressionStream("gzip"));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+
+/**
+ * @param {Response} response
+ * @param {string} url
+ * @param {string} type
+ */
+async function readResponseBody(response, url, type) {
+    const gzipHint =
+        hasGzipExtension(url) ||
+        isGzipMimeType(response.headers.get("content-type")) ||
+        hasGzipContentEncoding(response.headers.get("content-encoding"));
+
+    if (!gzipHint) {
+        return readResponseUsingType(response, type);
+    }
+
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const bodyBytes = hasGzipMagic(bytes) ? await decompressGzip(bytes) : bytes;
+    return deserializeBytes(bodyBytes, type);
+}
+
+/**
+ * @param {Response} response
+ * @param {string} type
+ */
+function readResponseUsingType(response, type) {
+    // @ts-ignore
+    return typeof response[type] == "function"
+        ? // @ts-ignore
+          response[type]()
+        : response.text();
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @param {string} type
+ */
+function deserializeBytes(bytes, type) {
+    if (type == "arrayBuffer") {
+        return toArrayBuffer(bytes);
+    } else {
+        return textDecoder.decode(bytes);
+    }
+}

package/dist/src/genome/assemblyPreflight.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @typedef {import("../spec/scale.js").Scale["assembly"]} AssemblyReference
+ */
+/**
+ * @typedef {object} AssemblyPreflightResult
+ * @prop {AssemblyReference[]} assemblies
+ * @prop {boolean} needsDefaultAssembly
+ */
+/**
+ * @param {import("../view/view.js").default} viewRoot
+ * @returns {AssemblyPreflightResult}
+ */
+export function collectAssembliesFromViewHierarchy(viewRoot: import("../view/view.js").default): AssemblyPreflightResult;
+/**
+ * Ensures that all assemblies required by the given view hierarchy are loaded
+ * before any scale initialization path can run.
+ *
+ * Reminder: call this immediately after view hierarchy creation and before
+ * operations that can implicitly initialize scales (for example, step-based
+ * size resolution, dynamic opacity setup, or encoder initialization).
+ *
+ * @param {import("../view/view.js").default} viewRoot
+ * @param {import("./genomeStore.js").default} genomeStore
+ */
+export function ensureAssembliesForView(viewRoot: import("../view/view.js").default, genomeStore: import("./genomeStore.js").default): Promise<void>;
+export type AssemblyReference = import("../spec/scale.js").Scale["assembly"];
+export type AssemblyPreflightResult = {
+    assemblies: AssemblyReference[];
+    needsDefaultAssembly: boolean;
+};
+//# sourceMappingURL=assemblyPreflight.d.ts.map

package/dist/src/genome/assemblyPreflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assemblyPreflight.d.ts","sourceRoot":"","sources":["../../../src/genome/assemblyPreflight.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;GAIG;AAEH;;;GAGG;AACH,6DAHW,OAAO,iBAAiB,EAAE,OAAO,GAC/B,uBAAuB,CAsBnC;AAED;;;;;;;;;;GAUG;AACH,kDAHW,OAAO,iBAAiB,EAAE,OAAO,eACjC,OAAO,kBAAkB,EAAE,OAAO,iBAgB5C;gCA5DY,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC;;gBAK/C,iBAAiB,EAAE;0BACnB,OAAO"}

package/dist/src/genome/assemblyPreflight.js

@@ -0,0 +1,99 @@
+import { visitAddressableViews } from "../view/viewSelectors.js";
+
+/**
+ * @typedef {import("../spec/scale.js").Scale["assembly"]} AssemblyReference
+ */
+
+/**
+ * @typedef {object} AssemblyPreflightResult
+ * @prop {AssemblyReference[]} assemblies
+ * @prop {boolean} needsDefaultAssembly
+ */
+
+/**
+ * @param {import("../view/view.js").default} viewRoot
+ * @returns {AssemblyPreflightResult}
+ */
+export function collectAssembliesFromViewHierarchy(viewRoot) {
+    /** @type {AssemblyReference[]} */
+    const assemblies = [];
+    let needsDefaultAssembly = false;
+
+    const resolutions = collectRelevantScaleResolutions(viewRoot);
+    for (const resolution of resolutions) {
+        const requirement = resolution.getAssemblyRequirement();
+        if (requirement.assembly) {
+            assemblies.push(requirement.assembly);
+        }
+        if (requirement.needsDefaultAssembly) {
+            needsDefaultAssembly = true;
+        }
+    }
+
+    return {
+        assemblies,
+        needsDefaultAssembly,
+    };
+}
+
+/**
+ * Ensures that all assemblies required by the given view hierarchy are loaded
+ * before any scale initialization path can run.
+ *
+ * Reminder: call this immediately after view hierarchy creation and before
+ * operations that can implicitly initialize scales (for example, step-based
+ * size resolution, dynamic opacity setup, or encoder initialization).
+ *
+ * @param {import("../view/view.js").default} viewRoot
+ * @param {import("./genomeStore.js").default} genomeStore
+ */
+export async function ensureAssembliesForView(viewRoot, genomeStore) {
+    const { assemblies, needsDefaultAssembly } =
+        collectAssembliesFromViewHierarchy(viewRoot);
+    if (needsDefaultAssembly) {
+        const defaultAssembly = genomeStore.getDefaultAssemblyName();
+        if (!defaultAssembly) {
+            throw new Error(
+                "No default assembly has been configured. Set root `assembly`, define exactly one entry in root `genomes`, or set `scale.assembly` on each locus scale."
+            );
+        }
+        assemblies.push(defaultAssembly);
+    }
+
+    await genomeStore.ensureAssemblies(assemblies);
+}
+
+/**
+ * Collects scale resolutions that can influence user-authored views while
+ * excluding internal helper subtrees (axis/grid/etc.).
+ *
+ * Reminder: implicit root wrappers are marked non-addressable, so include the
+ * root ancestry explicitly before traversing addressable views.
+ *
+ * @param {import("../view/view.js").default} viewRoot
+ * @returns {Set<import("../scales/scaleResolution.js").default>}
+ */
+function collectRelevantScaleResolutions(viewRoot) {
+    /** @type {Set<import("../scales/scaleResolution.js").default>} */
+    const resolutions = new Set();
+
+    /** @type {import("../spec/channel.js").PrimaryPositionalChannel[]} */
+    const locusChannels = ["x", "y"];
+
+    /**
+     * @param {import("../view/view.js").default} view
+     */
+    const collectFromView = (view) => {
+        for (const channel of locusChannels) {
+            const resolution = view.getScaleResolution(channel);
+            if (resolution) {
+                resolutions.add(resolution);
+            }
+        }
+    };
+
+    collectFromView(viewRoot);
+    visitAddressableViews(viewRoot, collectFromView);
+
+    return resolutions;
+}

package/dist/src/genome/genome.d.ts

@@ -60,13 +60,13 @@ export default class Genome {
      */
     constructor(config: GenomeConfig);
     config: {
-        url: string;
         name: string;
     } | {
         name: string;
+        url: string;
     } | {
-        contigs: import("../spec/genome.js").Contig[];
         name: string;
+        contigs: import("../spec/genome.js").Contig[];
     };
     /** @type {(Chromosome & ChromosomeAnnotation)[]} */
     chromosomes: (Chromosome & ChromosomeAnnotation)[];

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

@@ -1 +1 @@
-{"version":3,"file":"genome.d.ts","sourceRoot":"","sources":["../../../src/genome/genome.js"],"names":[],"mappings":"AAuXA;;;GAGG;AACH,gDAFW,MAAM;;;IAOhB;AAED;;;;GAIG;AACH,0CAHW,GAAG,GACF,KAAK,IAAI,gBAAgB,CAIpC;AAED;;;;GAIG;AACH,kDAHW,GAAG,EAAE,GACJ,KAAK,IAAI,gBAAgB,EAAE,CAItC;AAED;;;GAGG;AACH,sCAHW,GAAG,GACD,KAAK,IAAI,YAAY,CASjC;AAED;;;GAGG;AACH,yCAHW,GAAG,GACD,KAAK,IAAI,OAAO,mBAAmB,EAAE,eAAe,CAIhE;AAED;;;GAGG;AACH,4CAHW,GAAG,GACD,KAAK,IAAI,OAAO,mBAAmB,EAAE,kBAAkB,CAInE;AAxaD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;IACI;;OAEG;IACH,oBAFW,YAAY,EA6CtB;IA1CG;;;;;;;;MAA2C;IAc3C,oDAAoD;IACpD,aADW,CAAC,UAAU,GAAG,oBAAoB,CAAC,EAAE,CAC3B;IAErB,2CAA2C;IAC3C,0BADW,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CACE;IAEzC,sEAAsE;IACtE,mBADW,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,UAAU,GAAG,oBAAoB,CAAC,CAChC;IAElC,uBAAuB;IACvB,cADW,MAAM,EAAE,CACG;IAEtB,kBAAkB;IAkBtB,mBAEC;IAED;;OAEG;IACH,cAFW,MAAM,iBAmBhB;IAED,wBAEC;IAED;;;OAGG;IACH,0BAFW,UAAU,EAAE,QA2CtB;IAED,sBAEC;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GAAG,MAAM,OACf,MAAM,UAShB;IAED;;;OAGG;IACH,4BAFW,MAAM,qCAgBhB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,gBAAgB,CAY5B;IAED;;;OAGG;IACH,oBAFW,MAAM,qCAIhB;IAED;;;;;;;;;;OAUG;IACH,yBAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,gCAHW,MAAM,EAAE,GACN,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAUhD;IAED;;;;;;OAMG;IACH,kCAFW,gBAAgB,EAAE,YAgB5B;IAED;;;;;OAKG;IACH,wCAHW,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,GAClC,0BAA0B,EAAE,CAiCxC;IAED;;;;OAIG;IACH,4DAFW,MAAM,EAAE,gCAOlB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,CAAC,CAgC5B;CACJ;2BA7WY,OAAO,mBAAmB,EAAE,YAAY;+BACxC,OAAO,mBAAmB,EAAE,gBAAgB;;UAG/C,MAAM;UACN,MAAM;;;;;;WAGN,MAAM;;;;YACN,MAAM;;;;qBACN,MAAM;;;;mBACN,MAAM;wBACN,MAAM,EAAE;;;;SACR,OAAO;;;WAGP,MAAM;cACN,MAAM;YACN,MAAM"}
+{"version":3,"file":"genome.d.ts","sourceRoot":"","sources":["../../../src/genome/genome.js"],"names":[],"mappings":"AA2XA;;;GAGG;AACH,gDAFW,MAAM;;;IAOhB;AAED;;;;GAIG;AACH,0CAHW,GAAG,GACF,KAAK,IAAI,gBAAgB,CAIpC;AAED;;;;GAIG;AACH,kDAHW,GAAG,EAAE,GACJ,KAAK,IAAI,gBAAgB,EAAE,CAItC;AAED;;;GAGG;AACH,sCAHW,GAAG,GACD,KAAK,IAAI,YAAY,CASjC;AAED;;;GAGG;AACH,yCAHW,GAAG,GACD,KAAK,IAAI,OAAO,mBAAmB,EAAE,eAAe,CAIhE;AAED;;;GAGG;AACH,4CAHW,GAAG,GACD,KAAK,IAAI,OAAO,mBAAmB,EAAE,kBAAkB,CAInE;AA5aD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;IACI;;OAEG;IACH,oBAFW,YAAY,EA6CtB;IA1CG;;;;;;;;MAA2C;IAc3C,oDAAoD;IACpD,aADW,CAAC,UAAU,GAAG,oBAAoB,CAAC,EAAE,CAC3B;IAErB,2CAA2C;IAC3C,0BADW,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CACE;IAEzC,sEAAsE;IACtE,mBADW,GAAG,CAAC,MAAM,GAAG,MAAM,EAAE,UAAU,GAAG,oBAAoB,CAAC,CAChC;IAElC,uBAAuB;IACvB,cADW,MAAM,EAAE,CACG;IAEtB,kBAAkB;IAkBtB,mBAEC;IAED;;OAEG;IACH,cAFW,MAAM,iBAmBhB;IAED,wBAEC;IAED;;;OAGG;IACH,0BAFW,UAAU,EAAE,QA+CtB;IAED,sBAEC;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GAAG,MAAM,OACf,MAAM,UAShB;IAED;;;OAGG;IACH,4BAFW,MAAM,qCAgBhB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,gBAAgB,CAY5B;IAED;;;OAGG;IACH,oBAFW,MAAM,qCAIhB;IAED;;;;;;;;;;OAUG;IACH,yBAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,2BAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,gCAHW,MAAM,EAAE,GACN,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAUhD;IAED;;;;;;OAMG;IACH,kCAFW,gBAAgB,EAAE,YAgB5B;IAED;;;;;OAKG;IACH,wCAHW,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,GAClC,0BAA0B,EAAE,CAiCxC;IAED;;;;OAIG;IACH,4DAFW,MAAM,EAAE,gCAOlB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,CAAC,CAgC5B;CACJ;2BAjXY,OAAO,mBAAmB,EAAE,YAAY;+BACxC,OAAO,mBAAmB,EAAE,gBAAgB;;UAG/C,MAAM;UACN,MAAM;;;;;;WAGN,MAAM;;;;YACN,MAAM;;;;qBACN,MAAM;;;;mBACN,MAAM;wBACN,MAAM,EAAE;;;;SACR,OAAO;;;WAGP,MAAM;cACN,MAAM;YACN,MAAM"}

package/dist/src/genome/genome.js

@@ -111,6 +111,10 @@ export default class Genome {
      * @param {Chromosome[]} chromSizes
      */
     setChromSizes(chromSizes) {
+        this.chromosomes = [];
+        this.cumulativeChromPositions = new Map();
+        this.chromosomesByName = new Map();
+
         let pos = 0;
         this.startByIndex = [0];