@genome-spy/core 0.73.0 → 0.75.0

package/dist/src/gl/vertexRangeIndex.js

@@ -0,0 +1,150 @@
+import clamp from "../utils/clamp.js";
+
+const MAX_INTEGER = 2 ** 31 - 1;
+const MIN_INTEGER = -(2 ** 31);
+
+/**
+ * @callback VertexReader
+ * @param {number} vertexIndex
+ * @returns {number}
+ */
+
+/**
+ * A binned index for vertex ranges that are already emitted into typed arrays.
+ * The readers operate on vertices, not source datums.
+ *
+ * The scan is run-based: consecutive vertices with the same effective x
+ * interval are collapsed into one range before binning.
+ *
+ * @param {number} size Number of bins
+ * @param {[number, number]} domain Domain of positions
+ * @param {VertexReader} readStart Reader for the start x value at a vertex
+ * @param {VertexReader} [readEnd=readStart] Reader for the end x value at a vertex
+ * @param {number} [startVertexIndex=0] First vertex index in the scanned range
+ * @param {number} [endVertexIndex=startVertexIndex] One past the last vertex index
+ * @returns {import("../utils/binnedIndex.js").Lookup | undefined}
+ */
+export function createVertexRangeIndexer(
+    size,
+    domain,
+    readStart,
+    readEnd = readStart,
+    startVertexIndex = 0,
+    endVertexIndex = startVertexIndex
+) {
+    if (endVertexIndex <= startVertexIndex) {
+        return undefined;
+    }
+
+    if (domain[1] <= domain[0]) {
+        return undefined;
+    }
+
+    const startIndices = new Array(size);
+    startIndices.fill(MAX_INTEGER);
+
+    const endIndices = new Array(size);
+    endIndices.fill(0);
+
+    const start = domain[0];
+    const domainLength = domain[1] - domain[0];
+    const divisor = domainLength / size;
+
+    /**
+     * @param {number} pos
+     * @param {boolean} end
+     */
+    const getBin = (pos, end) => {
+        const unfloored = (pos - start) / divisor;
+        const floored = Math.floor(unfloored);
+
+        // Special handling for the end coordinate because we are using half-open ranges.
+        return clamp(
+            end && floored == unfloored ? floored - 1 : floored,
+            0,
+            size - 1
+        );
+    };
+
+    let lastIndex = MIN_INTEGER;
+    let lastStart = -Infinity;
+    let unordered = false;
+
+    /**
+     * @type {import("../utils/binnedIndex.js").Lookup}
+     */
+    const lookup = (queryStart, queryEnd, arr = [0, 0]) => {
+        const startBin = getBin(queryStart, false);
+        const endBin = getBin(queryEnd, true);
+        const startIndex = startIndices[startBin];
+        const endIndex = Math.max(endIndices[endBin], startIndex);
+
+        arr[0] = startIndex;
+        arr[1] = endIndex;
+        return arr;
+    };
+
+    for (let i = startVertexIndex; i < endVertexIndex; ) {
+        const runStart = i;
+        const runX = readStart(i);
+        const runX2 = readEnd(i);
+
+        i += 1;
+        while (
+            i < endVertexIndex &&
+            readStart(i) === runX &&
+            readEnd(i) === runX2
+        ) {
+            i += 1;
+        }
+
+        if (runStart > lastIndex) {
+            lastIndex = runStart;
+        } else {
+            unordered = true;
+            break;
+        }
+
+        if (runX < lastStart || runX2 < runX) {
+            unordered = true;
+            break;
+        }
+        lastStart = runX;
+
+        const startBin = getBin(runX, false);
+        const endBin = getBin(runX2, true);
+
+        for (let bin = startBin; bin <= endBin; bin++) {
+            if (startIndices[bin] > runStart) {
+                startIndices[bin] = runStart;
+            }
+
+            if (endIndices[bin] < i) {
+                endIndices[bin] = i;
+            }
+        }
+    }
+
+    if (unordered) {
+        return undefined;
+    }
+
+    for (let i = 1; i < endIndices.length; i++) {
+        if (endIndices[i] < endIndices[i - 1]) {
+            endIndices[i] = endIndices[i - 1];
+        }
+    }
+
+    let tail = true;
+
+    for (let i = startIndices.length - 1; i > 0; i--) {
+        if (tail && startIndices[i] == MAX_INTEGER) {
+            startIndices[i] = endIndices[i];
+            tail = false;
+        } else if (startIndices[i - 1] > startIndices[i]) {
+            startIndices[i - 1] = startIndices[i];
+        }
+    }
+
+    return lookup;
+}

package/dist/src/index.d.ts

@@ -1,14 +1,8 @@
-export function embed(el: HTMLElement | string, spec: import("./spec/root.js").RootSpec | string, options?: import("./types/embedApi.js").EmbedOptions): import("./types/embedApi.js").EmbedResult;
-/**
- * Loads the spec from the given url and sets the baseUrl if it is not
- * defined in the spec.
- *
- * @param {string} url
- */
-export function loadSpec(url: string): Promise<any>;
+export const embed: (el: HTMLElement | string, spec: import("./spec/root.js").RootSpec | string, options?: import("./types/embedApi.js").EmbedOptions) => Promise<import("./types/embedApi.js").EmbedResult>;
 import GenomeSpy from "./genomeSpy.js";
 import { html } from "lit";
 import icon from "./img/bowtie.svg";
 import favIcon from "./img/genomespy-favicon.svg";
-export { GenomeSpy, html, icon, favIcon };
+import { loadSpec } from "./embedFactory.js";
+export { GenomeSpy, html, icon, favIcon, loadSpec };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";AAoGA;;;;;GAKG;AACH,8BAFW,MAAM,gBAkBhB;sBAvHqB,gBAAgB;qBAFjB,KAAK;iBAGT,kBAAkB;oBACf,6BAA6B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":"AAWA,6MAA4C;sBAPtB,gBAAgB;qBAJjB,KAAK;iBAKT,kBAAkB;oBACf,6BAA6B;yBACX,mBAAmB"}

package/dist/src/index.js

@@ -1,123 +1,14 @@
-import { isObject, isString } from "vega-util";
 import { html } from "lit";
 
+// Default core entry point: imports the fat GenomeSpy runtime with built-in
+// eager and lazy format registrations.
 import GenomeSpy from "./genomeSpy.js";
 import icon from "./img/bowtie.svg";
 import favIcon from "./img/genomespy-favicon.svg";
-import { fetchJson } from "./utils/fetchUtils.js";
-import inferSpecBaseUrl from "./utils/inferSpecBaseUrl.js";
+import { createEmbed, loadSpec } from "./embedFactory.js";
 
 export { GenomeSpy, html, icon, favIcon };
 
-/**
- * Embeds GenomeSpy into the DOM
- *
- * @type {import("./types/embedApi.js").EmbedFunction}
- * @returns {Promise<import("./types/embedApi.js").EmbedResult>}
- */
-export async function embed(el, spec, options = {}) {
-    /** @type {HTMLElement} */
-    let element;
+export const embed = createEmbed(GenomeSpy);
 
-    if (isString(el)) {
-        element = document.querySelector(el);
-        if (!element) {
-            throw new Error(`No such element: ${el}`);
-        }
-    } else if (el instanceof HTMLElement) {
-        element = el;
-    } else {
-        throw new Error(`Invalid element: ${el}`);
-    }
-
-    /** @type {GenomeSpy} */
-    let genomeSpy;
-
-    try {
-        const specObject = isObject(spec) ? spec : await loadSpec(spec);
-
-        specObject.baseUrl ??= "";
-        specObject.width ??= "container";
-        specObject.padding ??= 10;
-
-        if (element == document.body) {
-            // Need to add a wrapper to make sizing behavior more stable
-            const wrapper = document.createElement("div");
-            wrapper.style.position = "fixed";
-            wrapper.style.inset = "0";
-            wrapper.style.overflow = "hidden";
-            element.appendChild(wrapper);
-            element = wrapper;
-        }
-
-        genomeSpy = new GenomeSpy(element, specObject, options);
-        applyOptions(genomeSpy, options);
-        await genomeSpy.launch();
-    } catch (e) {
-        // eslint-disable-next-line require-atomic-updates
-        element.innerText = e.toString();
-        console.error(e);
-    }
-
-    return {
-        finalize() {
-            genomeSpy.destroy();
-            while (element.firstChild) {
-                element.firstChild.remove();
-            }
-        },
-
-        addEventListener(type, listener) {
-            genomeSpy.addEventListener(type, listener);
-        },
-
-        removeEventListener(type, listener) {
-            genomeSpy.removeEventListener(type, listener);
-        },
-
-        getScaleResolutionByName(name) {
-            return genomeSpy.getNamedScaleResolutions().get(name);
-        },
-
-        awaitVisibleLazyData: genomeSpy.awaitVisibleLazyData.bind(genomeSpy),
-        getRenderedBounds: genomeSpy.getRenderedBounds.bind(genomeSpy),
-        updateNamedData: genomeSpy.updateNamedData.bind(genomeSpy),
-        getLogicalCanvasSize: genomeSpy.getLogicalCanvasSize.bind(genomeSpy),
-        exportCanvas: genomeSpy.exportCanvas.bind(genomeSpy),
-    };
-}
-
-/**
- *
- * @param {import("./genomeSpy.js").default} genomeSpy
- * @param {import("./types/embedApi.js").EmbedOptions} options options
- */
-function applyOptions(genomeSpy, options) {
-    if (options.namedDataProvider) {
-        genomeSpy.registerNamedDataProvider(options.namedDataProvider);
-    }
-}
-
-/**
- * Loads the spec from the given url and sets the baseUrl if it is not
- * defined in the spec.
- *
- * @param {string} url
- */
-export async function loadSpec(url) {
-    let spec;
-
-    try {
-        spec = /** @type {any} */ (await fetchJson(url));
-    } catch (e) {
-        throw new Error(
-            `Could not load or parse configuration: ${url}, reason: ${e.message}`
-        );
-    }
-
-    if (!spec.baseUrl) {
-        spec.baseUrl = inferSpecBaseUrl(url);
-    }
-
-    return spec;
-}
+export { loadSpec };