@genome-spy/core 0.36.1 → 0.37.0

package/dist/src/view/unitView.js

@@ -0,0 +1,345 @@
+import RectMark from "../marks/rectMark";
+import PointMark from "../marks/pointMark";
+import RuleMark from "../marks/rule";
+import LinkMark from "../marks/link";
+import TextMark from "../marks/text";
+
+import ContainerView from "./containerView";
+import ScaleResolution from "./scaleResolution";
+import {
+    isSecondaryChannel,
+    secondaryChannels,
+    isPositionalChannel,
+    isChannelDefWithScale,
+    primaryPositionalChannels,
+    getPrimaryChannel,
+    isChannelWithScale,
+    isPrimaryPositionalChannel,
+} from "../encoder/encoder";
+import createDomain from "../utils/domainArray";
+import AxisResolution from "./axisResolution";
+
+/**
+ *
+ * @type {Object.<string, typeof import("../marks/mark").default>}
+ * TODO: Find a proper place, make extendible
+ */
+export const markTypes = {
+    point: PointMark,
+    rect: RectMark,
+    rule: RuleMark,
+    link: LinkMark,
+    text: TextMark,
+};
+
+export default class UnitView extends ContainerView {
+    /**
+     * @typedef {import("../spec/channel").Channel} Channel
+     * @typedef {import("./view").default} View
+     * @typedef {import("./layerView").default} LayerView
+     * @typedef {import("../utils/domainArray").DomainArray} DomainArray
+     * @typedef {import("../spec/view").ResolutionTarget} ResolutionTarget
+     *
+     */
+    /**
+     *
+     * @param {import("../spec/view").UnitSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {import("./containerView").default} layoutParent
+     * @param {import("./view").default} dataParent
+     * @param {string} name
+     */
+    constructor(spec, context, layoutParent, dataParent, name) {
+        super(spec, context, layoutParent, dataParent, name);
+
+        this.spec = spec; // Set here again to keep types happy
+
+        const Mark = markTypes[this.getMarkType()];
+        if (Mark) {
+            /** @type {import("../marks/mark").default} */
+            this.mark = new Mark(this);
+        } else {
+            throw new Error(`No such mark: ${this.getMarkType()}`);
+        }
+
+        /**
+         * Not nice! Inconsistent when faceting!
+         * TODO: Something. Maybe store only width/height
+         * @type {import("../utils/layout/rectangle").default}
+         */
+        this.coords = undefined;
+
+        this.needsAxes = { x: true, y: true };
+    }
+
+    /**
+     * @param {import("./renderingContext/viewRenderingContext").default} context
+     * @param {import("../utils/layout/rectangle").default} coords
+     * @param {import("../types/rendering").RenderingOptions} [options]
+     */
+    render(context, coords, options = {}) {
+        if (!this.isConfiguredVisible()) {
+            return;
+        }
+
+        this.coords = coords;
+
+        context.pushView(this, coords);
+        context.renderMark(this.mark, options);
+        context.popView(this);
+    }
+
+    getMarkType() {
+        return typeof this.spec.mark == "object"
+            ? this.spec.mark.type
+            : this.spec.mark;
+    }
+
+    /**
+     * Pulls scales and axes up in the view hierarcy according to the resolution rules, using dataParents.
+     * TODO: legends
+     *
+     * @param {ResolutionTarget} type
+     */
+    resolve(type) {
+        // TODO: Complain about nonsensical configuration, e.g. shared parent has independent children.
+
+        const encoding = this.mark.encoding;
+
+        for (const [channel, channelDef] of Object.entries(encoding)) {
+            if (!isChannelDefWithScale(channelDef)) {
+                continue;
+            }
+
+            const targetChannel = getPrimaryChannel(
+                channelDef.resolutionChannel ?? channel
+            );
+
+            if (!isChannelWithScale(targetChannel)) {
+                continue;
+            }
+
+            if (type == "axis" && !isPositionalChannel(targetChannel)) {
+                continue;
+            }
+
+            // eslint-disable-next-line consistent-this
+            let view = this;
+            while (
+                (view.getConfiguredOrDefaultResolution(targetChannel, type) ==
+                    "forced" ||
+                    (view.dataParent instanceof ContainerView &&
+                        ["shared", "excluded", "forced"].includes(
+                            view.dataParent.getConfiguredOrDefaultResolution(
+                                targetChannel,
+                                type
+                            )
+                        ))) &&
+                view.getConfiguredOrDefaultResolution(targetChannel, type) !=
+                    "excluded"
+            ) {
+                // @ts-ignore
+                view = view.dataParent;
+            }
+
+            // Quite a bit of redundancy, but makes type checker happy.
+            if (
+                type == "axis" &&
+                isPositionalChannel(channel) &&
+                isPrimaryPositionalChannel(targetChannel)
+            ) {
+                if (!view.resolutions[type][targetChannel]) {
+                    view.resolutions[type][targetChannel] = new AxisResolution(
+                        targetChannel
+                    );
+                }
+                view.resolutions[type][targetChannel].pushUnitView(
+                    this,
+                    channel
+                );
+            } else if (type == "scale" && isChannelWithScale(channel)) {
+                if (!view.resolutions[type][targetChannel]) {
+                    view.resolutions[type][targetChannel] = new ScaleResolution(
+                        targetChannel
+                    );
+                }
+                view.resolutions[type][targetChannel].pushUnitView(
+                    this,
+                    channel
+                );
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {Channel} channel
+     */
+    getAccessor(channel) {
+        return this._cache("accessor/" + channel, () => {
+            const encoding = this.mark.encoding; // Mark provides encodings with defaults and possible modifications
+            if (encoding && encoding[channel]) {
+                return this.context.accessorFactory.createAccessor(
+                    encoding[channel]
+                );
+            }
+        });
+    }
+
+    /**
+     * Returns an accessor that returns a (composite) key for partitioning the data
+     *
+     * @param {View} [whoIsAsking]
+     * @returns {function(object):any}
+     */
+    getFacetAccessor(whoIsAsking) {
+        // TODO: Rewrite, call getFacetFields
+        const sampleAccessor = this.getAccessor("sample");
+        if (sampleAccessor) {
+            return sampleAccessor;
+        }
+
+        return super.getFacetAccessor(this);
+    }
+
+    /**
+     * Returns a collector that is associated with this view.
+     */
+    getCollector() {
+        return this.context.dataFlow.findCollectorByKey(this);
+    }
+
+    /**
+     * @param {Channel} channel A primary channel
+     */
+    _validateDomainQuery(channel) {
+        if (isSecondaryChannel(channel)) {
+            throw new Error(
+                `getDomain(${channel}), must only be called for primary channels!`
+            );
+        }
+
+        const channelDef = this.mark.encoding[channel];
+        // TODO: Broken. Fix.
+        if (!isChannelDefWithScale(channelDef)) {
+            throw new Error("The channel has no scale, cannot get domain!");
+        }
+
+        return channelDef;
+    }
+
+    /**
+     * Returns the domain of the specified channel of this domain/mark.
+     *
+     * @param {import("../spec/channel").ChannelWithScale} channel A primary channel
+     * @returns {DomainArray}
+     */
+    getConfiguredDomain(channel) {
+        const channelDef = this._validateDomainQuery(channel);
+
+        const specDomain =
+            channelDef && channelDef.scale && channelDef.scale.domain;
+        if (specDomain) {
+            const scaleResolution = this.getScaleResolution(
+                channelDef.resolutionChannel ?? channel
+            );
+            return createDomain(
+                channelDef.type ?? "nominal",
+                // Chrom/pos must be linearized first
+                scaleResolution.fromComplexInterval(specDomain)
+            );
+        }
+    }
+
+    /**
+     * Extracts the domain from the data.
+     *
+     * TODO: Optimize! Now this performs redundant work if multiple views share the same collector.
+     * Also, all relevant fields should be processed in one iteration: https://jsbench.me/y5kkqy52jo/1
+     * In fact, domain extraction could be a responsibility of the collector: As it handles data items,
+     * it extracts domains for all fields (and data types) that need extracted domains.
+     * Alternatively, extractor nodes could be added to the data flow, just like Vega does
+     * (with aggregate and extent).
+     *
+     * @param {Channel} channel
+     * @returns {DomainArray}
+     */
+    extractDataDomain(channel) {
+        const channelDef = this._validateDomainQuery(channel);
+        const type = channelDef.type ?? "nominal"; // TODO: Should check that this is a channel without scale
+
+        /** @param {Channel} channel */
+        const extract = (channel) => {
+            /** @type {DomainArray} */
+            let domain;
+
+            const encodingSpec = this.mark.encoding[channel];
+
+            if (encodingSpec) {
+                const accessor =
+                    this.context.accessorFactory.createAccessor(encodingSpec);
+                if (accessor) {
+                    domain = createDomain(type);
+
+                    if (accessor.constant) {
+                        domain.extend(accessor({}));
+                    } else {
+                        const collector = this.getCollector();
+                        if (collector?.completed) {
+                            collector.visitData((d) =>
+                                domain.extend(accessor(d))
+                            );
+                        }
+                    }
+                }
+            }
+            return domain;
+        };
+
+        let domain = extract(channel);
+
+        const secondaryChannel = secondaryChannels[channel];
+        if (secondaryChannel) {
+            const secondaryDomain = extract(secondaryChannel);
+            if (secondaryDomain) {
+                domain.extendAll(secondaryDomain);
+            }
+        }
+
+        return domain;
+    }
+
+    getZoomLevel() {
+        /** @param {import("../spec/channel").ChannelWithScale} channel */
+        const getZoomLevel = (channel) =>
+            this.getScaleResolution(channel)?.getZoomLevel() ?? 1.0;
+
+        return primaryPositionalChannels
+            .map(getZoomLevel)
+            .reduce((a, c) => a * c, 1);
+    }
+
+    /**
+     * @param {import("../utils/interactionEvent").default} event
+     */
+    propagateInteractionEvent(event) {
+        this.handleInteractionEvent(undefined, event, true);
+        event.target = this;
+
+        if (event.stopped) {
+            return;
+        }
+
+        this.handleInteractionEvent(undefined, event, false);
+    }
+
+    /**
+     * @param {string} channel
+     * @param {ResolutionTarget} resolutionType
+     * @returns {import("../spec/view").ResolutionBehavior}
+     */
+    getDefaultResolution(channel, resolutionType) {
+        // This affects the sample aggregate views.
+        return channel == "x" ? "shared" : "independent";
+    }
+}

package/dist/src/view/view.d.ts

@@ -0,0 +1,291 @@
+/** Skip children */
+export const VISIT_SKIP: "VISIT_SKIP";
+/** Stop further visits */
+export const VISIT_STOP: "VISIT_STOP";
+/**
+ * @typedef {VISIT_SKIP|VISIT_STOP|void} VisitResult
+ *
+ * @callback VisitorCallback
+ * @param {View} view
+ * @returns {VisitResult}
+ *
+ * @typedef {VisitorCallback & {
+ *      postOrder?: function(View):void,
+ *      beforeChildren?: function(View):void,
+ *      afterChildren?: function(View):void}
+ * } Visitor
+ *
+ * @typedef {object} BroadcastMessage
+ * @prop {import("../genomeSpy").BroadcastEventType} type Broadcast type
+ * @prop {any} [payload] Anything
+ *
+ * @callback InteractionEventListener
+ * @param {import("../utils/layout/rectangle").default} coords
+ *      Coordinates of the view
+ * @param {import("../utils/interactionEvent").default} event
+ */
+export default class View {
+    /**
+     *
+     * @param {import("../spec/view").ViewSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {import("./containerView").default} layoutParent Parent that handles rendering of this view
+     * @param {import("./view").default} dataParent Parent that provides data, encodings, and is used in scale resolution
+     * @param {string} name
+     */
+    constructor(spec: import("../spec/view").ViewSpec, context: import("../types/viewContext").default, layoutParent: import("./containerView").default, dataParent: import("./view").default, name: string);
+    /**
+     * @type {function(number):number}
+     */
+    opacityFunction: (arg0: number) => number;
+    context: import("../types/viewContext").default;
+    layoutParent: import("./containerView").default;
+    dataParent: View;
+    name: string;
+    spec: import("../spec/view").ViewSpec;
+    resolutions: {
+        /**
+         * Channel-specific scale resolutions
+         * @type {Partial<Record<import("../spec/channel").ChannelWithScale, import("./scaleResolution").default>>}
+         */
+        scale: Partial<Record<import("../spec/channel").ChannelWithScale, import("./scaleResolution").default>>;
+        /**
+         * Channel-specific axis resolutions
+         * @type {Partial<Record<import("../spec/channel").PrimaryPositionalChannel, import("./axisResolution").default>>}
+         */
+        axis: Partial<Record<import("../spec/channel").PrimaryPositionalChannel, import("./axisResolution").default>>;
+    };
+    /**
+     * Don't inherit encodings from parent.
+     * TODO: Make configurable through spec. Allow more fine-grained control.
+     */
+    blockEncodingInheritance: boolean;
+    /**
+     * Whether ScaleResolution should include this view or its children in the domain.
+     * This is mainly used to block axis views from contributing to the domain.
+     */
+    contributesToScaleDomain: boolean;
+    /**
+     * Whether GridView or equivalent should draw axis and grid lines for this view.
+     * @type {Record<import("../spec/channel").PrimaryPositionalChannel, boolean>}
+     */
+    needsAxes: Record<import("../spec/channel").PrimaryPositionalChannel, boolean>;
+    getPadding(): Padding;
+    /**
+     * Returns a padding that indicates how much axes and titles extend over the plot area.
+     *
+     * @returns {Padding}
+     */
+    getOverhang(): Padding;
+    /**
+     * Returns the configured size, if present. Otherwise a computed or default
+     * height is returned.
+     *
+     * @returns {FlexDimensions}
+     */
+    getSize(): FlexDimensions;
+    isConfiguredVisible(): boolean;
+    isVisibleInSpec(): boolean;
+    /**
+     * Returns the effective visibility of this view, e.g., whether this view
+     * and all its ancestors are visible.
+     *
+     * When doing a depth-first traversal on the view hierarchy, it's best to
+     * use `isConfiguredVisible()` instead of this method.
+     *
+     * @returns {boolean}
+     */
+    isVisible(): boolean;
+    /**
+     * Returns the effective opacity of this view, e.g., view's opacity multiplied
+     * by opacities of its ancestors.
+     *
+     * TODO: This methods makes sense only in Unit and Layer views.
+     *
+     * @returns {number}
+     */
+    getEffectiveOpacity(): number;
+    getPathString(): string;
+    /**
+     * Returns the ancestor views, starting with this view.
+     */
+    getLayoutAncestors(): View[];
+    /**
+     * Returns the ancestor views, starting with this view.
+     */
+    getDataAncestors(): View[];
+    /**
+     * Handles a broadcast message that is intended for the whole view hierarchy.
+     *
+     * @param {BroadcastMessage} message
+     */
+    handleBroadcast(message: BroadcastMessage): void;
+    /**
+     *
+     * @param {string} type
+     * @param {function(BroadcastMessage):void} handler
+     */
+    _addBroadcastHandler(type: string, handler: (arg0: BroadcastMessage) => void): void;
+    /**
+     * Handles an interactionEvent
+     *
+     * @param {import("../utils/layout/rectangle").default} coords
+     *      Coordinates of the view
+     * @param {import("../utils/interactionEvent").default} event
+     * @param {boolean} capturing
+     */
+    handleInteractionEvent(coords: import("../utils/layout/rectangle").default, event: import("../utils/interactionEvent").default, capturing: boolean): void;
+    /**
+     * Add an "interaction" event listener that mimics DOM's event model inside
+     * the view hierarchy.
+     *
+     * This is intended for GenomeSpy's internal use. It allows the views to handle
+     * low level interactions such as dragging, wheeling, etc.
+     *
+     * @param {string} type
+     * @param {InteractionEventListener} listener
+     * @param {boolean} [useCapture]
+     */
+    addInteractionEventListener(type: string, listener: InteractionEventListener, useCapture?: boolean): void;
+    /**
+     * Visits child views in depth-first order. Visitor's return value
+     * controls the traversal.
+     *
+     * @param {Visitor} visitor
+     * @returns {VisitResult}
+     *
+     */
+    visit(visitor: Visitor): VisitResult;
+    /**
+     * Get all descendants of this view in depth-first order.
+     */
+    getDescendants(): View[];
+    /**
+     * Called after all scales in the view hierarchy have been resolved.
+     */
+    onScalesResolved(): void;
+    /**
+     * ViewRenderingContext calls this method once for each view during each rendering
+     * pass. The order is depth first, pre order.
+     */
+    onBeforeRender(): void;
+    render(context: ViewRenderingContext, coords: import("../utils/layout/rectangle").default, options?: import("../types/rendering").RenderingOptions): void;
+    /**
+     * Returns the encodings specified in this view combined with the inherited
+     * encodings. However, this does not contain any defaults or inferred/adjusted/fixed
+     * encodings. Those are available in Mark's encoding property.
+     *
+     * @return {import("../spec/channel").Encoding}
+     */
+    getEncoding(): import("../spec/channel").Encoding;
+    /**
+     * @param {View} [whoIsAsking] Passed to the immediate parent. Allows for
+     *      selectively breaking the inheritance.
+     * @return {function(object):any}
+     */
+    getFacetAccessor(whoIsAsking?: View): (arg0: object) => any;
+    /**
+     * Returns the fields that should be used for partitioning the data for facets.
+     *
+     * @param {View} [whoIsAsking]
+     * @returns {string[]}
+     */
+    getFacetFields(whoIsAsking?: View): string[];
+    /**
+     * Returns a texture that has a mapping for the sample locations. This is implemented
+     * only in the SampleView of GenomeSpy App.
+     *
+     * Background:
+     * There are to ways to manage how sample facets are drawn in the App:
+     *
+     * 1) Use one draw call for each facet and pass the location data as a uniform.
+     * 2) Draw all facets with one call and pass the facet locations as a texture.
+     *
+     * The former is suitable for large datasets, which can be subsetted for better
+     * performance. The latter one is more performant for cases where each facet
+     * consists of few data items (sample attributes / metadata).
+     *
+     * @return {WebGLTexture}
+     */
+    getSampleFacetTexture(): WebGLTexture;
+    /**
+     * @param {import("../spec/channel").ChannelWithScale} channel
+     */
+    getScaleResolution(channel: import("../spec/channel").ChannelWithScale): import("./scaleResolution").default;
+    /**
+     * @param {import("../spec/channel").PositionalChannel} channel
+     */
+    getAxisResolution(channel: import("../spec/channel").PositionalChannel): import("./axisResolution").default;
+    /**
+     * @param {import("../spec/channel").Channel | "default"} channel
+     * @param {import("../spec/view").ResolutionTarget} resolutionType
+     * @returns {import("../spec/view").ResolutionBehavior}
+     */
+    getConfiguredResolution(channel: import("../spec/channel").Channel | "default", resolutionType: import("../spec/view").ResolutionTarget): import("../spec/view").ResolutionBehavior;
+    /**
+     * @param {import("../spec/channel").Channel} channel
+     * @param {import("../spec/view").ResolutionTarget} resolutionType
+     * @returns {import("../spec/view").ResolutionBehavior}
+     */
+    getConfiguredOrDefaultResolution(channel: import("../spec/channel").Channel, resolutionType: import("../spec/view").ResolutionTarget): import("../spec/view").ResolutionBehavior;
+    /**
+     * @param {import("../spec/channel").Channel} channel
+     * @param {import("../spec/view").ResolutionTarget} resolutionType
+     * @returns {import("../spec/view").ResolutionBehavior}
+     */
+    getDefaultResolution(channel: import("../spec/channel").Channel, resolutionType: import("../spec/view").ResolutionTarget): import("../spec/view").ResolutionBehavior;
+    /**
+     * @returns {string}
+     */
+    getBaseUrl(): string;
+    /**
+     * Returns `true` if this view and its children supports picking.
+     */
+    isPickingSupported(): boolean;
+    getTitleText(): string;
+    /**
+     * @param {any} key string
+     * @param {function(key?):T} callable A function that produces a value to be cached
+     * @returns {T}
+     * @template T
+     * @protected
+     */
+    protected _cache<T>(key: any, callable: (arg0: any | null) => T): T;
+    /**
+     *
+     * @param {string} key
+     * @param {"self" | "progeny" | "ancestors"} [direction]
+     */
+    _invalidateCacheByPrefix(key: string, direction?: "self" | "progeny" | "ancestors"): void;
+    invalidateSizeCache(): void;
+    /**
+     * Broadcasts a message to views that include the given (x, y) point.
+     * This is mainly intended for mouse events.
+     *
+     * @param {import("../utils/interactionEvent").default} event
+     */
+    propagateInteractionEvent(event: import("../utils/interactionEvent").default): void;
+    #private;
+}
+export function isStepSize(size: any): size is import("../spec/view").Step;
+export type VisitResult = "VISIT_SKIP" | "VISIT_STOP" | void;
+export type VisitorCallback = (view: View) => VisitResult;
+export type Visitor = VisitorCallback & {
+    postOrder?: (arg0: View) => void;
+    beforeChildren?: (arg0: View) => void;
+    afterChildren?: (arg0: View) => void;
+};
+export type BroadcastMessage = {
+    /**
+     * Broadcast type
+     */
+    type: import("../genomeSpy").BroadcastEventType;
+    /**
+     * Anything
+     */
+    payload?: any;
+};
+export type InteractionEventListener = (coords: import("../utils/layout/rectangle").default, event: import("../utils/interactionEvent").default) => any;
+import Padding from "../utils/layout/padding";
+import { FlexDimensions } from "../utils/layout/flexLayout";
+//# sourceMappingURL=view.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../../src/view/view.js"],"names":[],"mappings":"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"}