@genome-spy/core 0.72.0 → 0.74.0

package/dist/src/scales/scaleResolutionTestUtils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @param {import("../spec/view.js").ViewSpec} spec
+ * @param {{ new(...args: any[]): import("../view/view.js").default }} [viewType]
+ * @returns {Promise<import("../view/view.js").default>}
+ */
+export function initView(spec: import("../spec/view.js").ViewSpec, viewType?: {
+    new (...args: any[]): import("../view/view.js").default;
+}): Promise<import("../view/view.js").default>;
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @returns {import("./scaleResolution.js").default}
+ */
+export function getRequiredScaleResolution(view: import("../view/view.js").default, channel: import("../spec/channel.js").ChannelWithScale): import("./scaleResolution.js").default;
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @returns {any[]}
+ */
+export function getScaleDomain(view: import("../view/view.js").default, channel: import("../spec/channel.js").ChannelWithScale): any[];
+//# sourceMappingURL=scaleResolutionTestUtils.d.ts.map

package/dist/src/scales/scaleResolutionTestUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaleResolutionTestUtils.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolutionTestUtils.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,+BAJW,OAAO,iBAAiB,EAAE,QAAQ,aAClC;IAAE,KAAI,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,iBAAiB,EAAE,OAAO,CAAA;CAAE,GACxD,OAAO,CAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC,CAQtD;AAED;;;;GAIG;AACH,iDAJW,OAAO,iBAAiB,EAAE,OAAO,WACjC,OAAO,oBAAoB,EAAE,gBAAgB,GAC3C,OAAO,sBAAsB,EAAE,OAAO,CAQlD;AAED;;;;GAIG;AACH,qCAJW,OAAO,iBAAiB,EAAE,OAAO,WACjC,OAAO,oBAAoB,EAAE,gBAAgB,GAC3C,GAAG,EAAE,CAIjB"}

package/dist/src/scales/scaleResolutionTestUtils.js

@@ -0,0 +1,37 @@
+import { createHeadlessEngine } from "../genomeSpy/headlessBootstrap.js";
+import UnitView from "../view/unitView.js";
+
+/**
+ * @param {import("../spec/view.js").ViewSpec} spec
+ * @param {{ new(...args: any[]): import("../view/view.js").default }} [viewType]
+ * @returns {Promise<import("../view/view.js").default>}
+ */
+export async function initView(spec, viewType = UnitView) {
+    const { view } = await createHeadlessEngine(spec);
+    if (!(view instanceof viewType)) {
+        throw new Error("ViewClass and the spec do not match!");
+    }
+    return view;
+}
+
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @returns {import("./scaleResolution.js").default}
+ */
+export function getRequiredScaleResolution(view, channel) {
+    const resolution = view.getScaleResolution(channel);
+    if (!resolution) {
+        throw new Error(`Expected ${channel} scale resolution.`);
+    }
+    return resolution;
+}
+
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @returns {any[]}
+ */
+export function getScaleDomain(view, channel) {
+    return getRequiredScaleResolution(view, channel).scale.domain();
+}

package/dist/src/scales/scaleRules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaleRules.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleRules.js"],"names":[],"mappings":"AAcA;;GAEG;AAEH;;;;GAIG;AACH,6CAJW,OAAO,YACP,OAAO,oBAAoB,EAAE,IAAI,GAC/B,OAAO,kBAAkB,EAAE,SAAS,CAkEhD;AAED;;;GAGG;AACH,6CAHW,OAAO,kBAAkB,EAAE,KAAK,WAChC,OAAO,QAWjB;sBAvFY,OAAO,oBAAoB,EAAE,OAAO"}
+{"version":3,"file":"scaleRules.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleRules.js"],"names":[],"mappings":"AAcA;;GAEG;AAEH;;;;GAIG;AACH,6CAJW,OAAO,YACP,OAAO,oBAAoB,EAAE,IAAI,GAC/B,OAAO,kBAAkB,EAAE,SAAS,CA2EhD;AAED;;;GAGG;AACH,6CAHW,OAAO,kBAAkB,EAAE,KAAK,WAChC,OAAO,QAgBjB;sBArGY,OAAO,oBAAoB,EAAE,OAAO"}

package/dist/src/scales/scaleRules.js

@@ -22,6 +22,15 @@ import {
  * @returns {import("../spec/scale.js").ScaleType}
  */
 export function getDefaultScaleType(channel, dataType) {
+    // TODO: Follow up with Vega-Lite-like discrete positional scale inference.
+    // For nominal/ordinal x/y channels, the default should not always be "band".
+    // The choice should depend on resolved mark usage and related signals:
+    // - rect/bar/rule/tick-like coverage -> "band"
+    // - point/text/link-like centered positions -> "point"
+    // - explicit relative band sizing / axis tickBand / nested offsets -> "band"
+    // This requires passing richer context than just channel + dataType.
+    //
+    // Keep the current behavior in this branch to avoid changing existing specs.
     // TODO: Band scale, Bin-Quantitative
 
     if (dataType == INDEX || dataType == LOCUS) {
@@ -93,11 +102,16 @@ export function getDefaultScaleType(channel, dataType) {
  */
 export function applyLockedProperties(props, channel) {
     if (isPositionalChannel(channel) && props.type !== "ordinal") {
-        // Unit ranges are a temporary default until pixel ranges are adopted.
+        // Positional scales currently operate in unit coordinates.
+        // Keep this invariant until pixel ranges are adopted.
         props.range = [0, 1];
     }
 
-    if (channel == "opacity" && isContinuous(props.type)) {
+    if (
+        channel == "opacity" &&
+        isContinuous(props.type) &&
+        props.clamp === undefined
+    ) {
         props.clamp = true;
     }
 }

package/dist/src/scales/selectionDomainUtils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @param {{ findRuntimeForParam: (name: string) => any }} paramRuntime
+ * @param {string} paramName
+ */
+export function requireParamRuntime(paramRuntime: {
+    findRuntimeForParam: (name: string) => any;
+}, paramName: string): any;
+/**
+ * @param {any} selection
+ * @param {string} paramName
+ */
+export function requireIntervalSelection(selection: any, paramName: string): import("../types/selectionTypes.js").IntervalSelection;
+/**
+ * Resolves the runtime-backed interval selection binding used by a linked
+ * domain. Matching is based on the actual resolved runtime slot instead of
+ * parameter name alone, so scoped params with the same name remain distinct.
+ *
+ * @param {import("../view/view.js").default} view
+ * @param {string} paramName
+ * @param {"x" | "y"} encoding
+ */
+export function resolveIntervalSelectionBinding(view: import("../view/view.js").default, paramName: string, encoding: "x" | "y"): {
+    runtime: any;
+    selection: import("../types/selectionTypes.js").IntervalSelection;
+};
+/**
+ * @param {import("../view/view.js").default} root
+ * @param {any} runtime
+ * @param {string} paramName
+ * @param {"x" | "y"} encoding
+ */
+export function findIntervalSelectionBindingOwners(root: import("../view/view.js").default, runtime: any, paramName: string, encoding: "x" | "y"): {
+    view: import("../view/view.js").default;
+    param: import("../spec/parameter.js").SelectionParameter;
+}[];
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {any} runtime
+ * @param {string} paramName
+ * @param {"x" | "y"} encoding
+ */
+export function hasIntervalSelectionBindingInScope(view: import("../view/view.js").default, runtime: any, paramName: string, encoding: "x" | "y"): boolean;
+/**
+ * @param {number[]} interval
+ * @param {number[]} zoomExtent
+ * @param {{ roundToIntegers?: boolean }} [options]
+ * @returns {[number, number] | undefined}
+ */
+export function normalizeIntervalForSelection(interval: number[], zoomExtent: number[], options?: {
+    roundToIntegers?: boolean;
+}): [number, number] | undefined;
+//# sourceMappingURL=selectionDomainUtils.d.ts.map

package/dist/src/scales/selectionDomainUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionDomainUtils.d.ts","sourceRoot":"","sources":["../../../src/scales/selectionDomainUtils.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,kDAHW;IAAE,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,GAAG,CAAA;CAAE,aAC9C,MAAM,OAUhB;AAED;;;GAGG;AACH,oDAHW,GAAG,aACH,MAAM,0DAgBhB;AAED;;;;;;;;GAQG;AACH,sDAJW,OAAO,iBAAiB,EAAE,OAAO,aACjC,MAAM,YACN,GAAG,GAAG,GAAG;;;EAiBnB;AAED;;;;;GAKG;AACH,yDALW,OAAO,iBAAiB,EAAE,OAAO,WACjC,GAAG,aACH,MAAM,YACN,GAAG,GAAG,GAAG;UAGG,OAAO,iBAAiB,EAAE,OAAO;WAAS,OAAO,sBAAsB,EAAE,kBAAkB;IAuBjH;AAED;;;;;GAKG;AACH,yDALW,OAAO,iBAAiB,EAAE,OAAO,WACjC,GAAG,aACH,MAAM,YACN,GAAG,GAAG,GAAG,WA8CnB;AAED;;;;;GAKG;AACH,wDALW,MAAM,EAAE,cACR,MAAM,EAAE,YACR;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3B,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAsCxC"}

package/dist/src/scales/selectionDomainUtils.js

@@ -0,0 +1,194 @@
+import { isSelectionParameter } from "../paramRuntime/paramUtils.js";
+import {
+    asSelectionConfig,
+    isIntervalSelection,
+    isIntervalSelectionConfig,
+} from "../selection/selection.js";
+
+/**
+ * @param {{ findRuntimeForParam: (name: string) => any }} paramRuntime
+ * @param {string} paramName
+ */
+export function requireParamRuntime(paramRuntime, paramName) {
+    const runtime = paramRuntime.findRuntimeForParam(paramName);
+    if (!runtime) {
+        throw new Error(
+            `Selection domain parameter "${paramName}" was not found.`
+        );
+    }
+    return runtime;
+}
+
+/**
+ * @param {any} selection
+ * @param {string} paramName
+ */
+export function requireIntervalSelection(selection, paramName) {
+    if (!selection) {
+        throw new Error(
+            `Selection domain parameter "${paramName}" was not found.`
+        );
+    }
+
+    if (!isIntervalSelection(selection)) {
+        throw new Error(
+            `Selection domain parameter "${paramName}" must be an interval selection.`
+        );
+    }
+
+    return selection;
+}
+
+/**
+ * Resolves the runtime-backed interval selection binding used by a linked
+ * domain. Matching is based on the actual resolved runtime slot instead of
+ * parameter name alone, so scoped params with the same name remain distinct.
+ *
+ * @param {import("../view/view.js").default} view
+ * @param {string} paramName
+ * @param {"x" | "y"} encoding
+ */
+export function resolveIntervalSelectionBinding(view, paramName, encoding) {
+    const runtime = view.paramRuntime.findRuntimeForParam
+        ? requireParamRuntime(view.paramRuntime, paramName)
+        : view.paramRuntime;
+    const selection = requireIntervalSelection(
+        runtime.getValue
+            ? runtime.getValue(paramName)
+            : view.paramRuntime.findValue(paramName),
+        paramName
+    );
+
+    return {
+        runtime,
+        selection,
+    };
+}
+
+/**
+ * @param {import("../view/view.js").default} root
+ * @param {any} runtime
+ * @param {string} paramName
+ * @param {"x" | "y"} encoding
+ */
+export function findIntervalSelectionBindingOwners(root, runtime, paramName, encoding) {
+    /** @type {{ view: import("../view/view.js").default, param: import("../spec/parameter.js").SelectionParameter }[]} */
+    const owners = [];
+
+    root.visit((view) => {
+        const param = view.paramRuntime?.paramConfigs?.get(paramName);
+        if (!param || !isSelectionParameter(param)) {
+            return;
+        }
+
+        const select = asSelectionConfig(param.select);
+        if (
+            !isIntervalSelectionConfig(select) ||
+            !select.encodings?.includes(encoding)
+        ) {
+            return;
+        }
+
+        if (view.paramRuntime.findRuntimeForParam(paramName) === runtime) {
+            owners.push({ view, param });
+        }
+    });
+
+    return owners;
+}
+
+/**
+ * @param {import("../view/view.js").default} view
+ * @param {any} runtime
+ * @param {string} paramName
+ * @param {"x" | "y"} encoding
+ */
+export function hasIntervalSelectionBindingInScope(
+    view,
+    runtime,
+    paramName,
+    encoding
+) {
+    const seen = new Set();
+    const ancestorGroups = [
+        view.getLayoutAncestors?.(),
+        view.getDataAncestors?.(),
+        [view],
+    ];
+
+    for (const views of ancestorGroups) {
+        for (const candidateView of views ?? []) {
+            if (!candidateView || seen.has(candidateView)) {
+                continue;
+            }
+
+            seen.add(candidateView);
+
+            const param = candidateView.paramRuntime?.paramConfigs?.get(paramName);
+            if (!param || !isSelectionParameter(param)) {
+                continue;
+            }
+
+            const select = asSelectionConfig(param.select);
+            if (
+                !isIntervalSelectionConfig(select) ||
+                !select.encodings?.includes(encoding)
+            ) {
+                continue;
+            }
+
+            if (
+                candidateView.paramRuntime.findRuntimeForParam?.(paramName) ===
+                runtime
+            ) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+/**
+ * @param {number[]} interval
+ * @param {number[]} zoomExtent
+ * @param {{ roundToIntegers?: boolean }} [options]
+ * @returns {[number, number] | undefined}
+ */
+export function normalizeIntervalForSelection(
+    interval,
+    zoomExtent,
+    options = {}
+) {
+    if (!interval || interval.length !== 2) {
+        return;
+    }
+
+    const a = Number(interval[0]);
+    const b = Number(interval[1]);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        return;
+    }
+
+    let min = Math.min(a, b);
+    let max = Math.max(a, b);
+
+    min = Math.max(zoomExtent[0], min);
+    max = Math.min(zoomExtent[1], max);
+
+    if (min > max) {
+        return;
+    }
+
+    if (options.roundToIntegers) {
+        min = Math.ceil(min);
+        max = Math.ceil(max);
+        min = Math.max(zoomExtent[0], min);
+        max = Math.min(zoomExtent[1], max);
+        if (min > max) {
+            return;
+        }
+    }
+
+    return [min, max];
+}

package/dist/src/scales/zoomDomainUtils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @typedef {import("../types/encoder.js").VegaScale} VegaScale
+ */
+/**
+ * Zooms a numeric two-point domain according to scale type.
+ *
+ * @param {VegaScale} scale
+ * @param {[number, number]} domain
+ * @param {number} anchor
+ * @param {number} scaleFactor
+ * @param {{ onUnsupported?: "throw" | "identity" }} [options]
+ * @returns {[number, number]}
+ */
+export function zoomDomainByScaleType(scale: VegaScale, domain: [number, number], anchor: number, scaleFactor: number, options?: {
+    onUnsupported?: "throw" | "identity";
+}): [number, number];
+export type VegaScale = import("../types/encoder.js").VegaScale;
+//# sourceMappingURL=zoomDomainUtils.d.ts.map

package/dist/src/scales/zoomDomainUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoomDomainUtils.d.ts","sourceRoot":"","sources":["../../../src/scales/zoomDomainUtils.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;GASG;AACH,6CAPW,SAAS,UACT,CAAC,MAAM,EAAE,MAAM,CAAC,UAChB,MAAM,eACN,MAAM,YACN;IAAE,aAAa,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;CAAE,GACtC,CAAC,MAAM,EAAE,MAAM,CAAC,CAsD5B;wBAjEY,OAAO,qBAAqB,EAAE,SAAS"}

package/dist/src/scales/zoomDomainUtils.js

@@ -0,0 +1,69 @@
+import { zoomLinear, zoomLog, zoomPow, zoomSymlog } from "vega-util";
+
+/**
+ * @typedef {import("../types/encoder.js").VegaScale} VegaScale
+ */
+
+/**
+ * Zooms a numeric two-point domain according to scale type.
+ *
+ * @param {VegaScale} scale
+ * @param {[number, number]} domain
+ * @param {number} anchor
+ * @param {number} scaleFactor
+ * @param {{ onUnsupported?: "throw" | "identity" }} [options]
+ * @returns {[number, number]}
+ */
+export function zoomDomainByScaleType(
+    scale,
+    domain,
+    anchor,
+    scaleFactor,
+    options = {}
+) {
+    const onUnsupported = options.onUnsupported ?? "throw";
+
+    switch (scale.type) {
+        case "linear":
+        case "index":
+        case "locus":
+            return /** @type {[number, number]} */ (
+                zoomLinear(domain, anchor, scaleFactor)
+            );
+
+        case "log":
+            return /** @type {[number, number]} */ (
+                zoomLog(domain, anchor, scaleFactor)
+            );
+
+        case "pow":
+        case "sqrt": {
+            const powScale =
+                /** @type {import("d3-scale").ScalePower<number, number>} */ (
+                    /** @type {any} */ (scale)
+                );
+            return /** @type {[number, number]} */ (
+                zoomPow(domain, anchor, scaleFactor, powScale.exponent())
+            );
+        }
+
+        case "symlog": {
+            const symlogScale =
+                /** @type {import("d3-scale").ScaleSymLog<number, number>} */ (
+                    /** @type {any} */ (scale)
+                );
+            return /** @type {[number, number]} */ (
+                zoomSymlog(domain, anchor, scaleFactor, symlogScale.constant())
+            );
+        }
+
+        default:
+            if (onUnsupported === "identity") {
+                return domain;
+            } else {
+                throw new Error(
+                    "Zooming is not implemented for: " + scale.type
+                );
+            }
+    }
+}

package/dist/src/screenshotHarness.d.ts

@@ -0,0 +1,16 @@
+export type ScreenshotState = {
+    status: string;
+    detail: string;
+    error: string;
+    capture: () => Promise<{
+        logicalSize: {
+            width: number;
+            height: number;
+        };
+        dataUrl: string;
+    }>;
+};
+export type ScreenshotWindow = Window & typeof globalThis & {
+    __genomeSpyScreenshot: ScreenshotState;
+};
+//# sourceMappingURL=screenshotHarness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"screenshotHarness.d.ts","sourceRoot":"","sources":["../../src/screenshotHarness.js"],"names":[],"mappings":"8BAQa;IACR,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,OAAO,CAAC;QAAE,WAAW,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC5F;+BAIS,MAAM,GAAG,OAAO,UAAU,GAAG;IAAE,qBAAqB,EAAE,eAAe,CAAA;CAAE"}