@genome-spy/core 0.78.0 → 0.79.0

package/dist/src/scales/legendResolution.js

@@ -0,0 +1,461 @@
+import {
+    findChannelDefWithScale,
+    isColorChannel,
+    isFieldDef,
+    isValueDef,
+} from "../encoder/encoder.js";
+import { getConfiguredLegendDefaults } from "../config/legendConfig.js";
+import { shallowArrayEquals } from "../utils/arrayUtils.js";
+import { orderResolutionMembers } from "./resolutionMemberOrder.js";
+import { isChromeView } from "../view/viewSelectors.js";
+
+/**
+ * @typedef {"symbol" | "gradient"} LegendType
+ * @typedef {object} LegendResolutionMember
+ * @prop {import("../view/unitView.js").default} view
+ * @prop {import("../spec/channel.js").ChannelWithScale} channel
+ *
+ * @typedef {{
+ *     view: import("../view/unitView.js").default,
+ *     channel: import("../spec/channel.js").ChannelWithScale,
+ *     field?: string,
+ *     type: LegendType,
+ *     symbolChannels?: Partial<Record<import("../spec/channel.js").ChannelWithScale, string>>,
+ *     symbolGeometry?: "point" | "stroke",
+ *     legend: import("../spec/legend.js").LegendConfig,
+ *     format?: string,
+ *     dataType: import("../spec/channel.js").Type,
+ *     scaleResolution: import("./scaleResolution.js").default
+ * }} LegendDefinition
+ */
+
+const SYMBOL_LEGEND_CHANNELS = new Set([
+    "color",
+    "fill",
+    "stroke",
+    "opacity",
+    "fillOpacity",
+    "strokeOpacity",
+    "shape",
+    "size",
+]);
+const GRADIENT_LEGEND_CHANNELS = new Set(["color", "fill", "stroke"]);
+
+export default class LegendResolution {
+    /** @type {Set<LegendResolutionMember>} */
+    #members = new Set();
+
+    /** @type {{ view: import("../view/view.js").default, config: import("../spec/legend.js").Legend } | undefined} */
+    #viewLevelLegendConfig;
+
+    /**
+     * @param {import("../spec/channel.js").ChannelWithScale} channel
+     */
+    constructor(channel) {
+        this.channel = channel;
+    }
+
+    /**
+     * @param {LegendResolutionMember} member
+     * @returns {() => boolean}
+     */
+    registerMember(member) {
+        this.#assertNoMixing(member);
+        this.#members.add(member);
+        return () => this.removeMember(member) && this.#members.size === 0;
+    }
+
+    /**
+     * @param {LegendResolutionMember} member
+     * @returns {boolean}
+     */
+    removeMember(member) {
+        return this.#members.delete(member);
+    }
+
+    /**
+     * @returns {LegendDefinition[]}
+     */
+    getLegendDefs() {
+        /** @type {Set<import("./scaleResolution.js").default>} */
+        const seenScaleResolutions = new Set();
+        /** @type {LegendDefinition[]} */
+        const definitions = [];
+
+        for (const member of orderResolutionMembers(this.#members)) {
+            const definition = this.#createLegendDefinition(member);
+            if (
+                definition &&
+                !seenScaleResolutions.has(definition.scaleResolution)
+            ) {
+                seenScaleResolutions.add(definition.scaleResolution);
+                definitions.push(definition);
+            }
+        }
+
+        return definitions;
+    }
+
+    /**
+     * @param {LegendResolutionMember} member
+     * @returns {LegendDefinition | undefined}
+     */
+    #createLegendDefinition(member) {
+        const { channel, view: legendParent } = member;
+        if (hasRedundantPrimaryLegend(channel, legendParent)) {
+            return undefined;
+        }
+
+        const channelDef = getLegendChannelDef(channel, legendParent);
+        if (!channelDef || isValueDef(channelDef)) {
+            return undefined;
+        }
+
+        const memberLegend =
+            "legend" in channelDef ? channelDef.legend : undefined;
+        if (!this.#viewLevelLegendConfig && memberLegend === null) {
+            return undefined;
+        }
+
+        if ("scale" in channelDef && channelDef.scale === null) {
+            return undefined;
+        }
+
+        const explicitLegend =
+            this.#viewLevelLegendConfig?.config ?? memberLegend;
+        const legendOverrides =
+            explicitLegend === undefined
+                ? undefined
+                : /** @type {import("../spec/legend.js").LegendConfig} */ ({
+                      disable: false,
+                      .../** @type {import("../spec/legend.js").Legend} */ (
+                          explicitLegend
+                      ),
+                  });
+        const scaleResolution = legendParent.getScaleResolution(channel);
+        if (!scaleResolution) {
+            return undefined;
+        }
+
+        const legendDefaults = getConfiguredLegendDefaults(
+            legendParent.getConfigScopes(),
+            legendOverrides,
+            { track: isTrackLegendParent(legendParent) }
+        );
+        if (legendDefaults.disable === true) {
+            return undefined;
+        }
+
+        const legendType = getLegendType(channel, channelDef);
+        if (!legendType) {
+            return undefined;
+        }
+
+        const channelTitle =
+            /** @type {import("../spec/legend.js").Legend["title"] | undefined} */ (
+                "title" in channelDef ? channelDef.title : undefined
+            );
+        const title =
+            legendDefaults.title !== undefined
+                ? legendDefaults.title
+                : channelTitle !== undefined
+                  ? channelTitle
+                  : isFieldDef(channelDef)
+                    ? channelDef.field
+                    : undefined;
+        const format = "format" in channelDef ? channelDef.format : undefined;
+        const symbolChannels =
+            legendType == "symbol"
+                ? getRedundantSymbolChannels(channel, legendParent)
+                : undefined;
+        const symbolGeometry =
+            legendType == "symbol"
+                ? getSymbolGeometry(channel, legendParent)
+                : undefined;
+
+        return {
+            view: legendParent,
+            channel,
+            field: isFieldDef(channelDef) ? channelDef.field : undefined,
+            type: legendType,
+            symbolChannels,
+            symbolGeometry,
+            legend: {
+                ...legendDefaults,
+                title,
+            },
+            format,
+            dataType: channelDef.type,
+            scaleResolution,
+        };
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    hasVisibleNonChromeMember() {
+        for (const member of this.#members) {
+            if (
+                member.view.isVisible() &&
+                !member.view.getLayoutAncestors().some(isChromeView)
+            ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    getDebugState() {
+        const legendDefs = this.getLegendDefs();
+        return {
+            kind: "legend",
+            channel: this.channel,
+            hostView:
+                legendDefs[0]?.scaleResolution.getDebugState().hostView ??
+                this.#viewLevelLegendConfig?.view ??
+                this.#members.values().next().value?.view,
+            legendDefs: legendDefs.map((definition) => ({
+                ...definition,
+                view: definition.view,
+                scaleResolution: definition.scaleResolution,
+                legend: structuredClone(definition.legend),
+            })),
+            hasVisibleNonChromeMember: this.hasVisibleNonChromeMember(),
+            members: orderResolutionMembers(this.#members).map((member) => ({
+                view: member.view,
+                channel: member.channel,
+            })),
+            viewLevelLegendConfig: this.#viewLevelLegendConfig
+                ? {
+                      view: this.#viewLevelLegendConfig.view,
+                      config: structuredClone(
+                          this.#viewLevelLegendConfig.config
+                      ),
+                  }
+                : undefined,
+        };
+    }
+
+    /**
+     * @param {import("../view/view.js").default} view
+     * @param {import("../spec/legend.js").Legend} config
+     */
+    attachViewLevelLegendConfig(view, config) {
+        if (
+            this.#viewLevelLegendConfig &&
+            this.#viewLevelLegendConfig.view !== view
+        ) {
+            throw new Error(
+                `Multiple view-level legend configs target the same ${this.channel} legend resolution.`
+            );
+        }
+
+        const configuredMember = Array.from(this.#members).find((member) =>
+            hasExplicitLegendConfig(member)
+        );
+        if (configuredMember) {
+            throw new Error(
+                `Cannot mix view-level legends.${this.channel} with encoding.${configuredMember.channel}.legend in the same legend resolution.`
+            );
+        }
+        this.#viewLevelLegendConfig = { view, config };
+    }
+
+    /**
+     * @param {import("../view/view.js").default} view
+     */
+    clearViewLevelLegendConfig(view) {
+        if (this.#viewLevelLegendConfig?.view === view) {
+            this.#viewLevelLegendConfig = undefined;
+        }
+    }
+
+    getViewLevelLegendConfig() {
+        return this.#viewLevelLegendConfig;
+    }
+
+    /**
+     * @param {LegendResolutionMember} member
+     */
+    #assertNoMixing(member) {
+        if (this.#viewLevelLegendConfig && hasExplicitLegendConfig(member)) {
+            throw new Error(
+                `Cannot mix view-level legends.${this.channel} with encoding.${member.channel}.legend in the same legend resolution.`
+            );
+        }
+    }
+}
+
+/**
+ * @param {LegendResolutionMember} member
+ * @returns {boolean}
+ */
+function hasExplicitLegendConfig(member) {
+    const channelDef = getLegendChannelDef(member.channel, member.view);
+    return Boolean(
+        channelDef && "legend" in channelDef && channelDef.legend !== undefined
+    );
+}
+
+/**
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @param {import("../view/unitView.js").default} legendParent
+ * @returns {"point" | "stroke"}
+ */
+function getSymbolGeometry(channel, legendParent) {
+    const markType = legendParent.getMarkType();
+    return channel == "size" && (markType == "rule" || markType == "link")
+        ? "stroke"
+        : "point";
+}
+
+/**
+ * @param {import("../view/unitView.js").default} legendParent
+ * @returns {boolean}
+ */
+function isTrackLegendParent(legendParent) {
+    const xDef = getLegendChannelDef("x", legendParent);
+    const xScaleType = legendParent
+        .getScaleResolution("x")
+        ?.getResolvedScaleType();
+
+    return (
+        xDef?.type == "index" ||
+        xDef?.type == "locus" ||
+        xScaleType == "index" ||
+        xScaleType == "locus"
+    );
+}
+
+/**
+ * Classifies currently implemented legend support. Deferred and unsupported
+ * channels intentionally return undefined so accidental legends are not
+ * generated before their visual representation is designed.
+ *
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @param {import("../spec/channel.js").ChannelDefWithScale} channelDef
+ * @returns {LegendType | undefined}
+ */
+function getLegendType(channel, channelDef) {
+    if (
+        ["opacity", "fillOpacity", "strokeOpacity", "size"].includes(channel) &&
+        channelDef.type == "quantitative"
+    ) {
+        return "symbol";
+    } else if (
+        (channelDef.type === "nominal" || channelDef.type === "ordinal") &&
+        SYMBOL_LEGEND_CHANNELS.has(channel)
+    ) {
+        return "symbol";
+    } else if (
+        channelDef.type === "quantitative" &&
+        GRADIENT_LEGEND_CHANNELS.has(channel)
+    ) {
+        return "gradient";
+    } else {
+        return undefined;
+    }
+}
+
+/**
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @param {import("../view/unitView.js").default} legendParent
+ * @returns {import("../spec/channel.js").ChannelDefWithScale | undefined}
+ */
+function getLegendChannelDef(channel, legendParent) {
+    return findChannelDefWithScale(legendParent.spec.encoding?.[channel]);
+}
+
+/**
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @param {import("../view/unitView.js").default} legendParent
+ * @returns {boolean}
+ */
+function isExplicitLegendNull(channel, legendParent) {
+    const channelDef = getLegendChannelDef(channel, legendParent);
+    return Boolean(
+        channelDef && "legend" in channelDef && channelDef.legend === null
+    );
+}
+
+/**
+ * @param {import("../spec/channel.js").ChannelWithScale} primary
+ * @param {import("../spec/channel.js").ChannelWithScale} secondary
+ * @param {import("../view/unitView.js").default} legendParent
+ * @returns {boolean}
+ */
+function canMergeSymbolChannels(primary, secondary, legendParent) {
+    const primaryDef = getLegendChannelDef(primary, legendParent);
+    const secondaryDef = getLegendChannelDef(secondary, legendParent);
+    const primaryResolution = legendParent.getScaleResolution(primary);
+    const secondaryResolution = legendParent.getScaleResolution(secondary);
+
+    return (
+        isFieldDef(primaryDef) &&
+        isFieldDef(secondaryDef) &&
+        primaryDef.field === secondaryDef.field &&
+        primaryResolution &&
+        secondaryResolution &&
+        shallowArrayEquals(
+            primaryResolution.getDomain(),
+            secondaryResolution.getDomain()
+        )
+    );
+}
+
+/**
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @param {import("../view/unitView.js").default} legendParent
+ * @returns {boolean}
+ */
+function hasRedundantPrimaryLegend(channel, legendParent) {
+    if (channel !== "shape") {
+        return false;
+    }
+
+    const channelDef = getLegendChannelDef(channel, legendParent);
+    if (!isFieldDef(channelDef)) {
+        return false;
+    }
+
+    for (const primary of /** @type {const} */ (["color", "fill", "stroke"])) {
+        if (
+            canMergeSymbolChannels(primary, channel, legendParent) &&
+            !isExplicitLegendNull(primary, legendParent)
+        ) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * @param {import("../spec/channel.js").ChannelWithScale} channel
+ * @param {import("../view/unitView.js").default} legendParent
+ * @returns {Partial<Record<import("../spec/channel.js").ChannelWithScale, string>>}
+ */
+function getRedundantSymbolChannels(channel, legendParent) {
+    if (!isColorChannel(channel)) {
+        return {};
+    }
+
+    const channelDef = getLegendChannelDef(channel, legendParent);
+    const shapeDef = getLegendChannelDef("shape", legendParent);
+    const shapeResolution = legendParent.getScaleResolution("shape");
+
+    if (
+        isFieldDef(channelDef) &&
+        isFieldDef(shapeDef) &&
+        shapeResolution &&
+        canMergeSymbolChannels(channel, "shape", legendParent) &&
+        !isExplicitLegendNull("shape", legendParent)
+    ) {
+        return {
+            shape: shapeResolution.name ?? "shape",
+        };
+    }
+
+    return {};
+}

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

@@ -96,6 +96,39 @@ export default class ScaleResolution implements ScaleResolutionApi {
      */
     isDomainDefinedExplicitly(): boolean;
     isDomainInitialized(): boolean;
+    /**
+     * Returns the participating members in the same deterministic order used
+     * for scale property merging.
+     *
+     * @returns {ScaleResolutionMember[]}
+     */
+    getOrderedMembers(): ScaleResolutionMember[];
+    getDebugState(): {
+        kind: string;
+        channel: import("../spec/channel.js").Channel;
+        hostView: import("../view/view.js").default<import("../spec/view.js").ViewSpec>;
+        name: string;
+        type: import("../spec/channel.js").Type;
+        resolvedScaleType: import("../spec/scale.js").ScaleType;
+        domain: any[];
+        complexDomain: import("../spec/scale.js").NumericDomain | import("../spec/scale.js").ComplexDomain;
+        range: any[];
+        zoomable: boolean;
+        zoomed: boolean;
+        members: {
+            view: import("../view/unitView.js").default<import("../spec/view.js").UnitSpec>;
+            channel: import("../spec/channel.js").ChannelWithScale;
+            channelDef: import("../spec/channel.js").ChannelDefWithScale;
+            contributesToDomain: boolean;
+            active: boolean;
+        }[];
+        activeMemberCount: number;
+        dataDomainMemberCount: number;
+        viewLevelScaleConfig: {
+            view: import("../view/view.js").default<import("../spec/view.js").ViewSpec>;
+            config: import("../spec/scale.js").Scale;
+        };
+    };
     /**
      * Returns locus assembly requirements without initializing the scale.
      *
@@ -145,6 +178,9 @@ export default class ScaleResolution implements ScaleResolutionApi {
      * Returns the scale instance, creating it if needed.
      *
      * Use this from call sites that may run before explicit initialization.
+     * Creating the scale resolves default domains and may require loaded
+     * assemblies for locus scales. For side-effect-free type checks, use
+     * `getResolvedScaleType()`.
      *
      * @returns {ScaleWithProps}
      */

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

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

package/dist/src/scales/scaleResolution.js

@@ -906,6 +906,62 @@ export default class ScaleResolution {
         return this.#orderedMembers;
     }
 
+    /**
+     * Returns the participating members in the same deterministic order used
+     * for scale property merging.
+     *
+     * @returns {ScaleResolutionMember[]}
+     */
+    getOrderedMembers() {
+        return this.#getOrderedMembers().slice();
+    }
+
+    getDebugState() {
+        const scale = this.#scaleManager.scale;
+        const canReadDomain = scale && typeof scale.domain === "function";
+        const canReadRange = scale && typeof scale.range === "function";
+
+        return {
+            kind: "scale",
+            channel: this.channel,
+            hostView: this.#resolutionView,
+            name: this.name,
+            type: this.type,
+            resolvedScaleType: this.getResolvedScaleType(),
+            domain: canReadDomain ? this.getDomain() : undefined,
+            complexDomain: canReadDomain ? this.getComplexDomain() : undefined,
+            range: canReadRange ? scale.range() : undefined,
+            zoomable: this.isZoomable(),
+            zoomed: this.isZoomable() ? this.isZoomed() : false,
+            members: this.#getOrderedMembers().map((member) =>
+                this.#createDebugMember(member)
+            ),
+            activeMemberCount: this.#getActiveMembers().size,
+            dataDomainMemberCount: this.#dataDomainMembers.size,
+            viewLevelScaleConfig: this.#viewLevelScaleConfig
+                ? {
+                      view: this.#viewLevelScaleConfig.view,
+                      config: structuredClone(
+                          this.#viewLevelScaleConfig.config
+                      ),
+                  }
+                : undefined,
+        };
+    }
+
+    /**
+     * @param {ScaleResolutionMember} member
+     */
+    #createDebugMember(member) {
+        return {
+            view: member.view,
+            channel: member.channel,
+            channelDef: structuredClone(member.channelDef),
+            contributesToDomain: member.contributesToDomain,
+            active: this.#getActiveMembers().has(member),
+        };
+    }
+
     #invalidateConfiguredDomain() {
         this.#domainAggregator.invalidateConfiguredDomain();
         this.#invalidateMergedScaleProps();
@@ -1269,6 +1325,9 @@ export default class ScaleResolution {
      * Returns the scale instance, creating it if needed.
      *
      * Use this from call sites that may run before explicit initialization.
+     * Creating the scale resolves default domains and may require loaded
+     * assemblies for locus scales. For side-effect-free type checks, use
+     * `getResolvedScaleType()`.
      *
      * @returns {ScaleWithProps}
      */

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

@@ -0,0 +1,53 @@
+/**
+ * Maps view-level axis configs and attaches non-pending configs to their
+ * target resolutions.
+ *
+ * @param {View} root
+ * @returns {ViewLevelAxisConfigMapping[]}
+ */
+export function attachViewLevelAxisConfigs(root: View): ViewLevelAxisConfigMapping[];
+/**
+ * Maps view-level legend configs and attaches non-pending configs to their
+ * target resolutions.
+ *
+ * @param {View} root
+ * @returns {ViewLevelLegendConfigMapping[]}
+ */
+export function attachViewLevelLegendConfigs(root: View): ViewLevelLegendConfigMapping[];
+/**
+ * Clears view-level guide configs owned by views in the subtree.
+ *
+ * @param {View} root
+ */
+export function clearViewLevelGuideConfigs(root: View): void;
+export type ChannelWithScale = import("../spec/channel.js").ChannelWithScale;
+export type PrimaryPositionalChannel = import("../spec/channel.js").PrimaryPositionalChannel;
+export type AxisConfig = import("../spec/axis.js").Axis & import("../spec/axis.js").GenomeAxis;
+export type LegendConfig = import("../spec/legend.js").Legend;
+export type View = import("../view/view.js").default;
+export type AxisResolution = import("./axisResolution.js").default;
+export type LegendResolution = import("./legendResolution.js").default;
+export type ViewLevelAxisConfigMapping = {
+    view: View;
+    channel: PrimaryPositionalChannel;
+    config: Partial<AxisConfig>;
+    resolution: AxisResolution | undefined;
+};
+export type ViewLevelLegendConfigMapping = {
+    view: View;
+    channel: ChannelWithScale;
+    config: LegendConfig;
+    resolution: LegendResolution | undefined;
+};
+export type GuideConfigSpec = {
+    configKey: "axes" | "legends";
+    resolutionType: "axis" | "legend";
+    getResolution: (view: View, channel: any) => AxisResolution | LegendResolution | undefined;
+    getAllResolutions: (view: View) => Iterable<AxisResolution | LegendResolution>;
+    attach: (resolution: any, view: View, config: any) => void;
+    getAttachedConfig: (resolution: any) => {
+        view: View;
+    } | undefined;
+    clear: (resolution: any, view: View) => void;
+};
+//# sourceMappingURL=viewLevelGuideConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viewLevelGuideConfig.d.ts","sourceRoot":"","sources":["../../../src/scales/viewLevelGuideConfig.js"],"names":[],"mappings":"AA0DA;;;;;;GAMG;AACH,iDAHW,IAAI,GACF,0BAA0B,EAAE,CAMxC;AAED;;;;;;GAMG;AACH,mDAHW,IAAI,GACF,4BAA4B,EAAE,CAM1C;AAED;;;;GAIG;AACH,iDAFW,IAAI,QAKd;+BAxFY,OAAO,oBAAoB,EAAE,gBAAgB;uCAC7C,OAAO,oBAAoB,EAAE,wBAAwB;yBACrD,OAAO,iBAAiB,EAAE,IAAI,GAAG,OAAO,iBAAiB,EAAE,UAAU;2BACrE,OAAO,mBAAmB,EAAE,MAAM;mBAClC,OAAO,iBAAiB,EAAE,OAAO;6BACjC,OAAO,qBAAqB,EAAE,OAAO;+BACrC,OAAO,uBAAuB,EAAE,OAAO;;UAG1C,IAAI;aACJ,wBAAwB;YACxB,OAAO,CAAC,UAAU,CAAC;gBACnB,cAAc,GAAG,SAAS;;;UAG1B,IAAI;aACJ,gBAAgB;YAChB,YAAY;gBACZ,gBAAgB,GAAG,SAAS;;;eAG5B,MAAM,GAAG,SAAS;oBAClB,MAAM,GAAG,QAAQ;mBACjB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,KAAK,cAAc,GAAG,gBAAgB,GAAG,SAAS;uBAC3E,CAAC,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,cAAc,GAAG,gBAAgB,CAAC;YAC3D,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,KAAK,IAAI;uBAClD,CAAC,UAAU,EAAE,GAAG,KAAK;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,SAAS;WAC/C,CAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI"}