@genome-spy/core 0.65.0 → 0.67.0

package/dist/src/scales/scaleInstanceManager.js

@@ -0,0 +1,317 @@
+import { isArray } from "vega-util";
+
+import createScale, { configureScale } from "../scale/scale.js";
+import { isExprRef } from "../view/paramMediator.js";
+import { isScaleLocus } from "../genome/scaleLocus.js";
+
+export default class ScaleInstanceManager {
+    /**
+     * @typedef {import("../types/encoder.js").VegaScale} VegaScale
+     * @typedef {VegaScale & { props: import("../spec/scale.js").Scale }} ScaleWithProps
+     */
+
+    /** @type {ScaleWithProps | undefined} */
+    #scale;
+
+    /** @type {Set<import("../view/paramMediator.js").ExprRefFunction>} */
+    #rangeExprRefListeners = new Set();
+
+    /** @type {() => import("../view/paramMediator.js").default} */
+    #getParamMediator;
+
+    /** @type {() => void} */
+    #onRangeChange;
+
+    /** @type {() => void} */
+    #onDomainChange;
+
+    /** @type {() => import("../genome/genomeStore.js").default | undefined} */
+    #getGenomeStore;
+
+    #domainNotificationsSuspended = 0;
+
+    /**
+     * @param {object} options
+     * @param {() => import("../view/paramMediator.js").default} options.getParamMediator
+     * @param {() => void} options.onRangeChange
+     * @param {() => void} [options.onDomainChange]
+     * @param {() => import("../genome/genomeStore.js").default | undefined} [options.getGenomeStore]
+     */
+    constructor({
+        getParamMediator,
+        onRangeChange,
+        onDomainChange,
+        getGenomeStore,
+    }) {
+        this.#getParamMediator = getParamMediator;
+        this.#onRangeChange = onRangeChange;
+        this.#onDomainChange = onDomainChange;
+        this.#getGenomeStore = getGenomeStore;
+    }
+
+    get scale() {
+        return this.#scale;
+    }
+
+    /**
+     * @returns {import("../genome/genome.js").default}
+     */
+    getLocusGenome() {
+        const genomeStore = this.#getGenomeStore?.();
+        const genome = genomeStore?.getGenome();
+        if (!genome) {
+            throw new Error("No genome has been defined!");
+        }
+        return genome;
+    }
+
+    /**
+     * @param {import("../spec/scale.js").Scale} props
+     * @returns {ScaleWithProps}
+     */
+    createScale(props) {
+        const scale = createScale({
+            ...this.#stripNonScaleProps(props),
+            range: undefined,
+        });
+        /** @type {ScaleWithProps} */ (scale).props = props;
+
+        if ("unknown" in scale) {
+            // Never allow implicit domain construction
+            scale.unknown(null);
+        }
+
+        this.#scale = /** @type {ScaleWithProps} */ (scale);
+        this.#bindGenomeIfNeeded(props);
+        this.#configureRange();
+        this.#wrapScaleInterceptors();
+
+        return this.#scale;
+    }
+
+    /**
+     * @param {import("../spec/scale.js").Scale} props
+     */
+    #bindGenomeIfNeeded(props) {
+        const scale = this.#scale;
+        if (!scale || !isScaleLocus(scale)) {
+            return;
+        }
+
+        const genomeStore = this.#getGenomeStore?.();
+        const genome = genomeStore?.getGenome(props.assembly);
+        if (!genome) {
+            throw new Error("No genome has been defined!");
+        }
+
+        scale.genome(genome);
+    }
+
+    /**
+     * @param {import("../spec/scale.js").Scale} props
+     */
+    reconfigureScale(props) {
+        const scale = this.#scale;
+        if (!scale || scale.type == "null") {
+            return;
+        }
+
+        configureScale(
+            { ...this.#stripNonScaleProps(props), range: undefined },
+            scale
+        );
+        scale.props = props;
+        this.#configureRange();
+    }
+
+    /**
+     * @param {() => void} callback
+     * @returns {void}
+     */
+    withDomainNotificationsSuppressed(callback) {
+        this.#domainNotificationsSuspended += 1;
+        try {
+            callback();
+        } finally {
+            this.#domainNotificationsSuspended -= 1;
+        }
+    }
+
+    /**
+     * @param {import("../spec/scale.js").Scale} props
+     * @returns {import("../spec/scale.js").Scale}
+     */
+    #stripNonScaleProps(props) {
+        // Avoid sending non-scale properties into vega-scale.
+        // Strip internal runtime-only props before passing into vega-scale.
+        const propsAny = /** @type {any} */ (props);
+        const {
+            assembly: _assembly,
+            domainIndexer: _domainIndexer,
+            ...rest
+        } = propsAny;
+        void _assembly;
+        void _domainIndexer;
+        return rest;
+    }
+
+    /**
+     * Configures range. If range is an array of expressions, they are evaluated
+     * and the scale is updated when the expressions change.
+     */
+    #configureRange() {
+        const scale = this.#scale;
+        if (!scale) {
+            return;
+        }
+
+        const props = scale.props;
+        this.#rangeExprRefListeners.forEach((fn) => fn.invalidate());
+
+        const resolved = resolveRange({
+            range: props.range,
+            reverse: props.reverse,
+            createExpression: (expr) =>
+                this.#getParamMediator().createExpression(expr),
+            registerExpr: (fn) => this.#rangeExprRefListeners.add(fn),
+        });
+
+        if (!resolved) {
+            // Named ranges?
+            return;
+        }
+
+        if ("values" in resolved) {
+            scale.range(/** @type {any[]} */ (resolved.values));
+            return;
+        }
+
+        const apply = () => scale.range(resolved.evaluate());
+        resolved.setup(apply);
+        apply();
+    }
+
+    #wrapScaleInterceptors() {
+        const scale = this.#scale;
+        if (!scale) {
+            return;
+        }
+
+        const range = scale.range;
+        const domain = scale.domain;
+        const notifyRange = () => this.#onRangeChange?.();
+        const notifyDomain = () => {
+            if (this.#domainNotificationsSuspended > 0) {
+                return;
+            }
+            this.#onDomainChange?.();
+        };
+
+        withScaleInterceptors(scale, {
+            onRangeChange: notifyRange,
+            onDomainChange: notifyDomain,
+            range,
+            domain,
+        });
+
+        notifyRange();
+    }
+}
+
+/**
+ * @param {import("../types/encoder.js").VegaScale} scale
+ * @param {object} options
+ * @param {(value: any) => void} [options.onRangeChange]
+ * @param {(value: any) => void} [options.onDomainChange]
+ * @param {(value?: any) => any} options.range
+ * @param {(value?: any) => any} options.domain
+ */
+function withScaleInterceptors(
+    scale,
+    { onRangeChange, onDomainChange, range, domain }
+) {
+    if (typeof range === "function") {
+        scale.range = /** @type {any} */ (
+            function (/** @type {any} */ _) {
+                if (arguments.length) {
+                    range(_);
+                    onRangeChange?.();
+                } else {
+                    return range();
+                }
+            }
+        );
+    }
+
+    if (typeof domain === "function") {
+        scale.domain = /** @type {any} */ (
+            function (/** @type {any} */ _) {
+                if (arguments.length) {
+                    domain(_);
+                    onDomainChange?.();
+                } else {
+                    return domain();
+                }
+            }
+        );
+    }
+}
+
+/**
+ * @param {object} options
+ * @param {import("../spec/scale.js").Scale["range"]} options.range
+ * @param {boolean | undefined} options.reverse
+ * @param {(expr: string) => import("../view/paramMediator.js").ExprRefFunction} options.createExpression
+ * @param {(fn: import("../view/paramMediator.js").ExprRefFunction) => void} options.registerExpr
+ * @returns {{
+ *   dynamic: true,
+ *   evaluate: () => any[],
+ *   setup: (listener: () => void) => void
+ * } | {
+ *   dynamic: false,
+ *   values: any[]
+ * } | null}
+ */
+function resolveRange({ range, reverse, createExpression, registerExpr }) {
+    if (!range || !isArray(range)) {
+        return null;
+    }
+
+    /**
+     * @param {T} array
+     * @param {boolean} reverseFlag
+     * @returns {T}
+     * @template T
+     */
+    const flip = (array, reverseFlag) =>
+        // @ts-ignore TODO: Fix the type (should be a generic union array type)
+        reverseFlag ? array.slice().reverse() : array;
+
+    if (range.some(isExprRef)) {
+        /** @type {(() => any)[]} */
+        let expressions;
+        const evaluate = () =>
+            flip(
+                expressions.map((expr) => expr()),
+                reverse
+            );
+        const setup = (/** @type {() => void} */ listener) => {
+            expressions = range.map((elem) => {
+                if (isExprRef(elem)) {
+                    const fn = createExpression(elem.expr);
+                    fn.addListener(listener);
+                    registerExpr(fn);
+                    return () => fn(null);
+                }
+                return () => elem;
+            });
+        };
+
+        return { dynamic: true, evaluate, setup };
+    }
+
+    return {
+        dynamic: false,
+        values: flip(range, reverse),
+    };
+}

package/dist/src/scales/scaleInstanceManager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scaleInstanceManager.test.d.ts.map

package/dist/src/scales/scaleInstanceManager.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaleInstanceManager.test.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.test.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,73 @@
+/**
+ * @typedef {import("../spec/scale.js").NumericDomain} NumericDomain
+ * @typedef {import("../spec/scale.js").ScalarDomain} ScalarDomain
+ * @typedef {import("../spec/scale.js").ComplexDomain} ComplexDomain
+ * @typedef {import("../spec/scale.js").ZoomParams} ZoomParams
+ * @typedef {import("../types/encoder.js").VegaScale} VegaScale
+ * @typedef {VegaScale & { props: import("../spec/scale.js").Scale }} ScaleWithProps
+ */
+export default class ScaleInteractionController {
+    /**
+     * @param {object} options
+     * @param {() => ScaleWithProps} options.getScale
+     * @param {() => import("../utils/animator.js").default} options.getAnimator
+     * @param {() => number[]} options.getInitialDomainSnapshot
+     * @param {() => number[]} options.getResetDomain
+     * @param {(domain: ScalarDomain | ComplexDomain) => number[]} options.fromComplexInterval
+     * @param {() => number[]} options.getGenomeExtent
+     */
+    constructor({ getScale, getAnimator, getInitialDomainSnapshot, getResetDomain, fromComplexInterval, getGenomeExtent, }: {
+        getScale: () => ScaleWithProps;
+        getAnimator: () => import("../utils/animator.js").default;
+        getInitialDomainSnapshot: () => number[];
+        getResetDomain: () => number[];
+        fromComplexInterval: (domain: ScalarDomain | ComplexDomain) => number[];
+        getGenomeExtent: () => number[];
+    });
+    getZoomExtent(): number[];
+    isZoomable(): boolean;
+    isZoomingSupported(): boolean;
+    /**
+     * Return true if the scale is zoomable and the current domain differs from the initial domain.
+     *
+     * @returns true if zoomed
+     */
+    isZoomed(): boolean;
+    /**
+     * Pans (translates) and zooms using a specified scale factor.
+     *
+     * @param {number} scaleFactor
+     * @param {number} scaleAnchor
+     * @param {number} pan
+     * @returns {boolean} true if the scale was zoomed
+     */
+    zoom(scaleFactor: number, scaleAnchor: number, pan: number): boolean;
+    /**
+     * Immediately zooms to the given interval.
+     *
+     * @param {NumericDomain | ComplexDomain} domain
+     * @param {boolean | number} [duration] an approximate duration for transition.
+     *      Zero duration zooms immediately. Boolean `true` indicates a default duration.
+     */
+    zoomTo(domain: NumericDomain | ComplexDomain, duration?: boolean | number): Promise<void>;
+    /**
+     * Resets the current domain to the initial one
+     *
+     * @returns true if the domain was changed
+     */
+    resetZoom(): boolean;
+    /**
+     * Returns the zoom level with respect to the reference domain span (the original domain).
+     */
+    getZoomLevel(): number;
+    #private;
+}
+export type NumericDomain = import("../spec/scale.js").NumericDomain;
+export type ScalarDomain = import("../spec/scale.js").ScalarDomain;
+export type ComplexDomain = import("../spec/scale.js").ComplexDomain;
+export type ZoomParams = import("../spec/scale.js").ZoomParams;
+export type VegaScale = import("../types/encoder.js").VegaScale;
+export type ScaleWithProps = VegaScale & {
+    props: import("../spec/scale.js").Scale;
+};
+//# sourceMappingURL=scaleInteractionController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scaleInteractionController.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInteractionController.js"],"names":[],"mappings":"AAmBA;;;;;;;GAOG;AAEH;IAmBI;;;;;;;;OAQG;IACH,wHAPG;QAAsC,QAAQ,EAAtC,MAAM,cAAc;QACkC,WAAW,EAAjE,MAAM,OAAO,sBAAsB,EAAE,OAAO;QACpB,wBAAwB,EAAhD,MAAM,MAAM,EAAE;QACU,cAAc,EAAtC,MAAM,MAAM,EAAE;QAC8C,mBAAmB,EAA/E,CAAC,MAAM,EAAE,YAAY,GAAG,aAAa,KAAK,MAAM,EAAE;QAC1B,eAAe,EAAvC,MAAM,MAAM,EAAE;KACxB,EAeA;IAED,0BAUC;IAED,sBAEC;IAED,8BAEC;IAED;;;;OAIG;IACH,oBAQC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CA2BnB;IAED;;;;;;OAMG;IACH,eAJW,aAAa,GAAG,aAAa,aAC7B,OAAO,GAAG,MAAM,iBAuD1B;IAED;;;;OAIG;IACH,qBAcC;IAED;;OAEG;IACH,uBAOC;;CACJ;4BAvNY,OAAO,kBAAkB,EAAE,aAAa;2BACxC,OAAO,kBAAkB,EAAE,YAAY;4BACvC,OAAO,kBAAkB,EAAE,aAAa;yBACxC,OAAO,kBAAkB,EAAE,UAAU;wBACrC,OAAO,qBAAqB,EAAE,SAAS;6BACvC,SAAS,GAAG;IAAE,KAAK,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAA;CAAE"}