@genome-spy/core 0.77.0 → 0.79.0

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

@@ -0,0 +1,83 @@
+export default class LegendResolution {
+    /**
+     * @param {import("../spec/channel.js").ChannelWithScale} channel
+     */
+    constructor(channel: import("../spec/channel.js").ChannelWithScale);
+    channel: import("../spec/channel.js").ChannelWithScale;
+    /**
+     * @param {LegendResolutionMember} member
+     * @returns {() => boolean}
+     */
+    registerMember(member: LegendResolutionMember): () => boolean;
+    /**
+     * @param {LegendResolutionMember} member
+     * @returns {boolean}
+     */
+    removeMember(member: LegendResolutionMember): boolean;
+    /**
+     * @returns {LegendDefinition[]}
+     */
+    getLegendDefs(): LegendDefinition[];
+    /**
+     * @returns {boolean}
+     */
+    hasVisibleNonChromeMember(): boolean;
+    getDebugState(): {
+        kind: string;
+        channel: import("../spec/channel.js").ChannelWithScale;
+        hostView: any;
+        legendDefs: {
+            view: import("../view/unitView.js").default<import("../spec/view.js").UnitSpec>;
+            scaleResolution: import("./scaleResolution.js").default;
+            legend: import("../spec/legend.js").LegendConfig;
+            channel: import("../spec/channel.js").ChannelWithScale;
+            field?: string;
+            type: LegendType;
+            symbolChannels?: Partial<Record<import("../spec/channel.js").ChannelWithScale, string>>;
+            symbolGeometry?: "point" | "stroke";
+            format?: string;
+            dataType: import("../spec/channel.js").Type;
+        }[];
+        hasVisibleNonChromeMember: boolean;
+        members: {
+            view: import("../view/unitView.js").default<import("../spec/view.js").UnitSpec>;
+            channel: import("../spec/channel.js").ChannelWithScale;
+        }[];
+        viewLevelLegendConfig: {
+            view: import("../view/view.js").default<import("../spec/view.js").ViewSpec>;
+            config: import("../spec/legend.js").Legend;
+        };
+    };
+    /**
+     * @param {import("../view/view.js").default} view
+     * @param {import("../spec/legend.js").Legend} config
+     */
+    attachViewLevelLegendConfig(view: import("../view/view.js").default, config: import("../spec/legend.js").Legend): void;
+    /**
+     * @param {import("../view/view.js").default} view
+     */
+    clearViewLevelLegendConfig(view: import("../view/view.js").default): void;
+    getViewLevelLegendConfig(): {
+        view: import("../view/view.js").default;
+        config: import("../spec/legend.js").Legend;
+    };
+    #private;
+}
+export type LegendType = "symbol" | "gradient";
+export type LegendResolutionMember = {
+    view: import("../view/unitView.js").default;
+    channel: import("../spec/channel.js").ChannelWithScale;
+};
+export type LegendDefinition = {
+    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;
+};
+//# sourceMappingURL=legendResolution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"legendResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/legendResolution.js"],"names":[],"mappings":"AA2CA;IAOI;;OAEG;IACH,qBAFW,OAAO,oBAAoB,EAAE,gBAAgB,EAIvD;IADG,uDAAsB;IAG1B;;;OAGG;IACH,uBAHW,sBAAsB,GACpB,MAAM,OAAO,CAMzB;IAED;;;OAGG;IACH,qBAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;OAEG;IACH,iBAFa,gBAAgB,EAAE,CAoB9B;IAgGD;;OAEG;IACH,6BAFa,OAAO,CAanB;IAED;;;;;;;;qBA7LY,OAAO,oBAAoB,EAAE,gBAAgB;oBAC9C,MAAM;kBACR,UAAU;6BACC,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,CAAC,CAAC;6BACtE,OAAO,GAAG,QAAQ;qBAE1B,MAAM;sBACL,OAAO,oBAAoB,EAAE,IAAI;;;;;;;;;;;MAmN7C;IAED;;;OAGG;IACH,kCAHW,OAAO,iBAAiB,EAAE,OAAO,UACjC,OAAO,mBAAmB,EAAE,MAAM,QAqB5C;IAED;;OAEG;IACH,iCAFW,OAAO,iBAAiB,EAAE,OAAO,QAM3C;IAED;cAlOmB,OAAO,iBAAiB,EAAE,OAAO;gBAAU,OAAO,mBAAmB,EAAE,MAAM;MAoO/F;;CAYJ;yBAnRY,QAAQ,GAAG,UAAU;;UAExB,OAAO,qBAAqB,EAAE,OAAO;aACrC,OAAO,oBAAoB,EAAE,gBAAgB;;+BAE1C;IACN,IAAI,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;IAC5C,OAAO,EAAE,OAAO,oBAAoB,EAAE,gBAAgB,CAAC;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,UAAU,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,OAAO,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAAC;IACxF,cAAc,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IACpC,MAAM,EAAE,OAAO,mBAAmB,EAAE,YAAY,CAAC;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,oBAAoB,EAAE,IAAI,CAAC;IAC5C,eAAe,EAAE,OAAO,sBAAsB,EAAE,OAAO,CAAA;CAC1D"}

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/scaleInstanceManager.d.ts

@@ -17,6 +17,7 @@ export default class ScaleInstanceManager {
     get scale(): import("../types/encoder.js").VegaScale & {
         props: import("../spec/scale.js").Scale;
     };
+    resetScale(): void;
     /**
      * @param {import("../spec/scale.js").Scale["assembly"]} [assembly]
      * @returns {import("../genome/genome.js").default}

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

@@ -1 +1 @@
-{"version":3,"file":"scaleInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.js"],"names":[],"mappings":"AAMA;IA0BI;;;;;;OAMG;IACH,iFALG;QAAkH,eAAe,EAAzH,MAAM;YAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,0BAA0B,EAAE,eAAe,CAAA;SAAE;QAC5E,aAAa,EAAjC,MAAM,IAAI;QACW,cAAc,GAAnC,MAAM,IAAI;QAC6D,cAAc,GAArF,MAAM,OAAO,0BAA0B,EAAE,OAAO,GAAG,SAAS;KAA0B,EAYhG;IAED;eA1CkC,OAAO,kBAAkB,EAAE,KAAK;MA4CjE;IAED;;;OAGG;IACH,0BAHW,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAC1C,OAAO,qBAAqB,EAAE,OAAO,CAajD;IAED;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,KAAK;eAhET,OAAO,kBAAkB,EAAE,KAAK;MAqFjE;IAcD;;OAEG;IACH,wBAFW,OAAO,kBAAkB,EAAE,KAAK,QAc1C;IAED;;;OAGG;IACH,4CAHW,MAAM,IAAI,GACR,IAAI,CAShB;IAwFD,gBAGC;;CACJ"}
+{"version":3,"file":"scaleInstanceManager.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleInstanceManager.js"],"names":[],"mappings":"AAMA;IA0BI;;;;;;OAMG;IACH,iFALG;QAAkH,eAAe,EAAzH,MAAM;YAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,0BAA0B,EAAE,eAAe,CAAA;SAAE;QAC5E,aAAa,EAAjC,MAAM,IAAI;QACW,cAAc,GAAnC,MAAM,IAAI;QAC6D,cAAc,GAArF,MAAM,OAAO,0BAA0B,EAAE,OAAO,GAAG,SAAS;KAA0B,EAYhG;IAED;eA1CkC,OAAO,kBAAkB,EAAE,KAAK;MA4CjE;IAED,mBAGC;IAED;;;OAGG;IACH,0BAHW,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAC1C,OAAO,qBAAqB,EAAE,OAAO,CAajD;IAED;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,KAAK;eArET,OAAO,kBAAkB,EAAE,KAAK;MA0FjE;IAcD;;OAEG;IACH,wBAFW,OAAO,kBAAkB,EAAE,KAAK,QAc1C;IAED;;;OAGG;IACH,4CAHW,MAAM,IAAI,GACR,IAAI,CAShB;IAwFD,gBAGC;;CACJ"}

package/dist/src/scales/scaleInstanceManager.js

@@ -53,6 +53,11 @@ export default class ScaleInstanceManager {
         return this.#scale;
     }
 
+    resetScale() {
+        this.dispose();
+        this.#scale = undefined;
+    }
+
     /**
      * @param {import("../spec/scale.js").Scale["assembly"]} [assembly]
      * @returns {import("../genome/genome.js").default}

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

@@ -8,14 +8,19 @@
  * @param {Channel} options.channel
  * @param {import("../spec/channel.js").Type} options.dataType
  * @param {ScaleResolutionMember[]} options.orderedMembers
+ * @param {{ view: import("../view/view.js").default, config: Scale } | undefined} [options.viewLevelScaleConfig]
  * @param {boolean} options.isExplicitDomain
  * @param {import("../spec/config.js").GenomeSpyConfig[]} options.configScopes
  * @returns {Scale}
  */
-export function resolveScalePropsBase({ channel, dataType, orderedMembers, isExplicitDomain, configScopes, }: {
+export function resolveScalePropsBase({ channel, dataType, orderedMembers, viewLevelScaleConfig, isExplicitDomain, configScopes, }: {
     channel: Channel;
     dataType: import("../spec/channel.js").Type;
     orderedMembers: ScaleResolutionMember[];
+    viewLevelScaleConfig?: {
+        view: import("../view/view.js").default;
+        config: Scale;
+    } | undefined;
     isExplicitDomain: boolean;
     configScopes: import("../spec/config.js").GenomeSpyConfig[];
 }): Scale;

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

@@ -1 +1 @@
-{"version":3,"file":"scalePropsResolver.d.ts","sourceRoot":"","sources":["../../../src/scales/scalePropsResolver.js"],"names":[],"mappings":"AAcA;;;;GAIG;AAEH;;;;;;;;GAQG;AACH,8GAPG;IAAyB,OAAO,EAAxB,OAAO;IACoC,QAAQ,EAAnD,OAAO,oBAAoB,EAAE,IAAI;IACA,cAAc,EAA/C,qBAAqB,EAAE;IACN,gBAAgB,EAAjC,OAAO;IACgD,YAAY,EAAnE,OAAO,mBAAmB,EAAE,eAAe,EAAE;CACrD,GAAU,KAAK,CA6IjB;sBAzJY,OAAO,oBAAoB,EAAE,OAAO;oBACpC,OAAO,kBAAkB,EAAE,KAAK;oCAChC,OAAO,sBAAsB,EAAE,qBAAqB"}
+{"version":3,"file":"scalePropsResolver.d.ts","sourceRoot":"","sources":["../../../src/scales/scalePropsResolver.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,oIARG;IAAyB,OAAO,EAAxB,OAAO;IACoC,QAAQ,EAAnD,OAAO,oBAAoB,EAAE,IAAI;IACA,cAAc,EAA/C,qBAAqB,EAAE;IAC0D,oBAAoB,GAArG;QAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,SAAS;IACrD,gBAAgB,EAAjC,OAAO;IACgD,YAAY,EAAnE,OAAO,mBAAmB,EAAE,eAAe,EAAE;CACrD,GAAU,KAAK,CAgKjB;sBA7KY,OAAO,oBAAoB,EAAE,OAAO;oBACpC,OAAO,kBAAkB,EAAE,KAAK;oCAChC,OAAO,sBAAsB,EAAE,qBAAqB"}