@genome-spy/core 0.77.0 → 0.78.0

package/dist/src/scales/scalePropsResolver.js

@@ -9,7 +9,12 @@ import {
     getConfiguredNamedRange,
     isConfigRangeName,
 } from "../config/scaleConfig.js";
-import { applyLockedProperties, getDefaultScaleType } from "./scaleRules.js";
+import { collectConfiguredDomainExprRefs } from "./domainExpressions.js";
+import {
+    applyLockedProperties,
+    getDefaultScaleType,
+    validateScaleTypeCompatibility,
+} from "./scaleRules.js";
 import { INDEX, LOCUS } from "./scaleResolutionConstants.js";
 
 /**
@@ -23,6 +28,7 @@ import { INDEX, LOCUS } from "./scaleResolutionConstants.js";
  * @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}
@@ -31,6 +37,7 @@ export function resolveScalePropsBase({
     channel,
     dataType,
     orderedMembers,
+    viewLevelScaleConfig,
     isExplicitDomain,
     configScopes,
 }) {
@@ -44,9 +51,11 @@ export function resolveScalePropsBase({
         )
         .filter((markType) => !!markType);
 
-    const propArray = memberList
-        .map((member) => member.channelDef.scale)
-        .filter((props) => props !== undefined);
+    const propArray = viewLevelScaleConfig
+        ? [viewLevelScaleConfig.config]
+        : memberList
+              .map((member) => member.channelDef.scale)
+              .filter((props) => props !== undefined);
 
     // TODO: Disabled scale: https://vega.github.io/vega-lite/docs/scale.html#disable
     const mergedProps = mergeObjects(propArray, "scale", ["domain"]);
@@ -76,6 +85,13 @@ export function resolveScalePropsBase({
         props.type = getDefaultScaleType(channel, dataType);
     }
 
+    validateScaleTypeCompatibility(
+        channel,
+        dataType,
+        viewLevelScaleConfig ? props.type : undefined,
+        `View-level scales.${channel}.type`
+    );
+
     if (typeof props.range == "string") {
         if (!isConfigRangeName(props.range)) {
             throw new Error(
@@ -132,9 +148,15 @@ export function resolveScalePropsBase({
     }
 
     if (props.domainTransition === undefined) {
-        const hasExprDrivenDomain = memberList.some((member) =>
-            isExprRef(member.channelDef.scale?.domain)
-        );
+        const hasExprDrivenDomain =
+            memberList.some(
+                (member) =>
+                    collectConfiguredDomainExprRefs(
+                        member.channelDef.scale?.domain
+                    ).length > 0
+            ) ||
+            collectConfiguredDomainExprRefs(viewLevelScaleConfig?.config.domain)
+                .length > 0;
         props.domainTransition = !hasExprDrivenDomain;
     }
 
@@ -143,9 +165,12 @@ export function resolveScalePropsBase({
         props.range.some(isExprRef) &&
         memberList.length > 0
     ) {
-        const rangeOwner = memberList.find(
-            (member) => member.channelDef.scale?.range !== undefined
-        )?.view;
+        const rangeOwner =
+            viewLevelScaleConfig?.config.range !== undefined
+                ? viewLevelScaleConfig.view
+                : memberList.find(
+                      (member) => member.channelDef.scale?.range !== undefined
+                  )?.view;
         if (rangeOwner) {
             /** @type {any} */
             (props).__rangeExprScope = rangeOwner;

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

@@ -68,6 +68,22 @@ export default class ScaleResolution implements ScaleResolutionApi {
      * @returns {() => boolean}
      */
     registerMember(member: ScaleResolutionMember): () => boolean;
+    /**
+     * @param {import("../view/view.js").default} view
+     * @param {import("../spec/scale.js").Scale} config
+     */
+    attachViewLevelScaleConfig(view: import("../view/view.js").default, config: import("../spec/scale.js").Scale): void;
+    /**
+     * @param {import("../view/view.js").default} view
+     */
+    clearViewLevelScaleConfig(view: import("../view/view.js").default): void;
+    /**
+     * @returns {{ view: import("../view/view.js").default, config: import("../spec/scale.js").Scale } | undefined}
+     */
+    getViewLevelScaleConfig(): {
+        view: import("../view/view.js").default;
+        config: import("../spec/scale.js").Scale;
+    } | undefined;
     dispose(): void;
     /**
      * @param {import("../data/collector.js").default} collector

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

@@ -1 +1 @@
-{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAoDA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA8cI;;;;;;;;OAQG;IACH,uBALa,CAAC,eACH,QAAQ,CAAC,eAAe,CAAC,YACzB,MAAM,CAAC,GACL,CAAC,CAqBb;IAnaD;;;OAGG;IACH,sEAFW,OAAO,iBAAiB,EAAE,OAAO,EAuC3C;IApCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IA2EzB,2BASC;IAwBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IAiCD,sCA6CC;IA+MD;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAazB;IAED,gBAMC;IAoFD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IAED;;OAEG;IACH,qCAEC;IAED,+BAiBC;IAuED;;;;;;;;;;;OAWG;IACH,0BALa;QACR,QAAQ,EAAE,OAAO,kBAAkB,EAAE,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAAC;QACnE,oBAAoB,EAAE,OAAO,CAAA;KAC9B,CAeH;IAED;;;;;;;OAOG;IACH,wBAFa,OAAO,kBAAkB,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,SAAS,CAShE;IAgGD;;;;;OAKG;IACH,oBAYC;IAED;;;;;OAKG;IACH,0BA0BC;IAoID;;OAEG;IACH;eAnhCkC,OAAO,kBAAkB,EAAE,KAAK;MA0hCjE;IAED;;;;;;OAMG;IACH;eAniCkC,OAAO,kBAAkB,EAAE,KAAK;MA0iCjE;IAED;;;;OAIG;IACH;eAjjCkC,OAAO,kBAAkB,EAAE,KAAK;MA0jCjE;IAED,mBASC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CASzC;IAED;;OAEG;IACH;;;;MAqBC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,YAC7B,OAAO,gCAAgC,EAAE,aAAa,GAAG,OAAO,GAAG,MAAM,iBAKnF;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,uBAFW,MAAM,yDAUhB;IAED;;OAEG;IACH,iBAFW,MAAM,yDAIhB;IAED;;;OAGG;IACH,qBAHW,MAAM,+CAAmB,GACvB,MAAM,CAIlB;IAED;;;OAGG;IACH,8BAHW,kFAA4B,GAC1B,MAAM,EAAE,CAOpB;;CACJ;kCAxyC+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBApCV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}
+{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"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"}

package/dist/src/scales/scaleResolution.js

@@ -15,6 +15,7 @@ import ScaleInstanceManager from "./scaleInstanceManager.js";
 import { resolveScalePropsBase } from "./scalePropsResolver.js";
 import DomainPlanner from "./domainPlanner.js";
 import ScaleInteractionController from "./scaleInteractionController.js";
+import { validateScaleTypeCompatibility } from "./scaleRules.js";
 import {
     INDEX,
     LOCUS,
@@ -24,11 +25,8 @@ import {
 } from "./scaleResolutionConstants.js";
 
 import { getAccessorDomainKey } from "../encoder/accessor.js";
-import {
-    isPrimaryPositionalChannel,
-    isSecondaryChannel,
-} from "../encoder/encoder.js";
-import { isExprRef } from "../paramRuntime/paramUtils.js";
+import { isSecondaryChannel } from "../encoder/encoder.js";
+import { collectConfiguredDomainExprRefs } from "./domainExpressions.js";
 import { NominalDomain } from "../utils/domainArray.js";
 import { shallowArrayEquals } from "../utils/arrayUtils.js";
 import createIndexer from "../utils/indexer.js";
@@ -143,6 +141,11 @@ export default class ScaleResolution {
     /** @type {import("../view/view.js").default | undefined} */
     #hostView;
 
+    /**
+     * @type {{ view: import("../view/view.js").default, config: import("../spec/scale.js").Scale } | undefined}
+     */
+    #viewLevelScaleConfig;
+
     #resolvingScaleProps = 0;
 
     #memberRegistrationBatchDepth = 0;
@@ -168,6 +171,8 @@ export default class ScaleResolution {
             getAllMembers: () => this.#members,
             getDataMembers: () =>
                 this.#getActiveMembers(this.#dataDomainMembers),
+            getViewLevelConfiguredDomain: () =>
+                this.#getViewLevelConfiguredDomain(),
             getType: () => this.type,
             getLocusExtent: (assembly) => this.#getLocusExtent(assembly),
             fromComplexInterval: this.fromComplexInterval.bind(this),
@@ -400,6 +405,10 @@ export default class ScaleResolution {
      * @returns {boolean}
      */
     #hasConfiguredDomain() {
+        if (this.#viewLevelScaleConfig?.config.domain !== undefined) {
+            return true;
+        }
+
         for (const member of this.#members) {
             if (
                 member.contributesToDomain &&
@@ -452,6 +461,8 @@ export default class ScaleResolution {
         const member = normalizeMember(newMember);
         const { channel, channelDef } = member;
 
+        this.#assertCanRegisterMember(member);
+
         // A convenience hack for cases where the new member should adapt
         // the scale type to the existing one. For example: SelectionRect
         // TODO: Add test
@@ -481,15 +492,12 @@ export default class ScaleResolution {
             explicitScaleType ??
             (type === INDEX || type === LOCUS ? type : undefined);
 
-        if (
-            effectiveScaleType &&
-            [INDEX, LOCUS].includes(effectiveScaleType) &&
-            !isPrimaryPositionalChannel(this.channel)
-        ) {
-            throw new Error(
-                `Index and locus scales are only supported on positional channels (x/y). Channel "${this.channel}" resolves to scale type "${effectiveScaleType}".`
-            );
-        }
+        validateScaleTypeCompatibility(
+            this.channel,
+            type,
+            effectiveScaleType,
+            `encoding.${channel}.scale.type`
+        );
 
         if (name) {
             if (this.name !== undefined && name != this.name) {
@@ -587,6 +595,100 @@ export default class ScaleResolution {
         };
     }
 
+    /**
+     * @param {import("../view/view.js").default} view
+     * @param {import("../spec/scale.js").Scale} config
+     */
+    attachViewLevelScaleConfig(view, config) {
+        if (
+            this.#viewLevelScaleConfig &&
+            this.#viewLevelScaleConfig.view !== view
+        ) {
+            throw new Error(
+                `Multiple view-level scale configs target the same ${this.channel} scale resolution.`
+            );
+        }
+
+        for (const member of this.#members) {
+            this.#assertMemberHasNoScaleConfig(member);
+        }
+
+        this.#viewLevelScaleConfig = { view, config };
+        this.#invalidateMergedScaleProps();
+        this.#invalidateConfiguredDomain();
+        this.#refreshSelectionDomainParamSubscriptions();
+        this.#refreshConfiguredDomainExprSubscriptions();
+        if (this.#scaleManager.scale) {
+            this.#scaleManager.resetScale();
+            this.initializeScale();
+        }
+    }
+
+    /**
+     * @param {import("../view/view.js").default} view
+     */
+    clearViewLevelScaleConfig(view) {
+        if (this.#viewLevelScaleConfig?.view === view) {
+            this.#viewLevelScaleConfig = undefined;
+            this.#invalidateMergedScaleProps();
+            this.#invalidateConfiguredDomain();
+            this.#refreshSelectionDomainParamSubscriptions();
+            this.#refreshConfiguredDomainExprSubscriptions();
+            if (this.#scaleManager.scale) {
+                this.#scaleManager.resetScale();
+                this.initializeScale();
+            }
+        }
+    }
+
+    /**
+     * @returns {{ view: import("../view/view.js").default, config: import("../spec/scale.js").Scale } | undefined}
+     */
+    getViewLevelScaleConfig() {
+        return this.#viewLevelScaleConfig;
+    }
+
+    #getViewLevelConfiguredDomain() {
+        const viewLevelScaleConfig = this.#viewLevelScaleConfig;
+        if (!viewLevelScaleConfig) {
+            return undefined;
+        }
+
+        return {
+            view: viewLevelScaleConfig.view,
+            channel:
+                /** @type {import("../spec/channel.js").ChannelWithScale} */ (
+                    this.channel
+                ),
+            type: this.type,
+            domain: viewLevelScaleConfig.config.domain,
+        };
+    }
+
+    /**
+     * @param {ScaleResolutionMember} member
+     */
+    #assertCanRegisterMember(member) {
+        if (!this.#viewLevelScaleConfig) {
+            return;
+        }
+
+        this.#assertMemberHasNoScaleConfig(member);
+    }
+
+    /**
+     * @param {ScaleResolutionMember} member
+     */
+    #assertMemberHasNoScaleConfig(member) {
+        if (member.channelDef.scale === undefined) {
+            return;
+        }
+
+        throw new Error(
+            `Cannot mix view-level scales.${this.channel} with encoding.${member.channel}.scale in the same scale resolution.`
+        );
+    }
+
     dispose() {
         this.#clearSelectionDomainParamSubscriptions();
         this.#clearConfiguredDomainExprSubscriptions();
@@ -658,11 +760,28 @@ export default class ScaleResolution {
                 continue;
             }
             const domain = member.channelDef.scale?.domain;
-            if (!isExprRef(domain)) {
+            const exprRefs = collectConfiguredDomainExprRefs(domain);
+            if (exprRefs.length === 0) {
                 continue;
             }
 
-            const expr = member.view.paramRuntime.createExpression(domain.expr);
+            for (const exprRef of exprRefs) {
+                const expr = member.view.paramRuntime.createExpression(
+                    exprRef.expr
+                );
+                const unsubscribe = expr.subscribe(listener);
+                this.#configuredDomainExprUnsubscribers.push(unsubscribe);
+            }
+        }
+
+        const viewLevelDomain = this.#viewLevelScaleConfig?.config.domain;
+        const viewLevelExprRefs =
+            collectConfiguredDomainExprRefs(viewLevelDomain);
+        for (const exprRef of viewLevelExprRefs) {
+            const expr =
+                this.#viewLevelScaleConfig.view.paramRuntime.createExpression(
+                    exprRef.expr
+                );
             const unsubscribe = expr.subscribe(listener);
             this.#configuredDomainExprUnsubscribers.push(unsubscribe);
         }
@@ -754,6 +873,7 @@ export default class ScaleResolution {
                 channel: this.channel,
                 dataType: this.type,
                 orderedMembers: this.#getOrderedMembers(),
+                viewLevelScaleConfig: this.#viewLevelScaleConfig,
                 isExplicitDomain: this.isDomainDefinedExplicitly(),
                 configScopes: this.#resolutionView.getConfigScopes(),
             });

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

@@ -7,6 +7,16 @@
  * @returns {import("../spec/scale.js").ScaleType}
  */
 export function getDefaultScaleType(channel: Channel, dataType: import("../spec/channel.js").Type): import("../spec/scale.js").ScaleType;
+/**
+ * Validates explicit scale type choices against the resolved data type and
+ * channel constraints.
+ *
+ * @param {Channel} channel
+ * @param {import("../spec/channel.js").Type} dataType
+ * @param {import("../spec/scale.js").ScaleType | undefined} scaleType
+ * @param {string} source
+ */
+export function validateScaleTypeCompatibility(channel: Channel, dataType: import("../spec/channel.js").Type, scaleType: import("../spec/scale.js").ScaleType | undefined, source: string): void;
 /**
  * @param {import("../spec/scale.js").Scale} props
  * @param {Channel} channel

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,CA2EhD;AAED;;;GAGG;AACH,6CAHW,OAAO,kBAAkB,EAAE,KAAK,WAChC,OAAO,QAgBjB;sBArGY,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,CA0EhD;AAED;;;;;;;;GAQG;AACH,wDALW,OAAO,YACP,OAAO,oBAAoB,EAAE,IAAI,aACjC,OAAO,kBAAkB,EAAE,SAAS,GAAG,SAAS,UAChD,MAAM,QA6BhB;AAED;;;GAGG;AACH,6CAHW,OAAO,kBAAkB,EAAE,KAAK,WAChC,OAAO,QAgBjB;sBA1IY,OAAO,oBAAoB,EAAE,OAAO"}

package/dist/src/scales/scaleRules.js

@@ -37,7 +37,6 @@ export function getDefaultScaleType(channel, dataType) {
         if (isPrimaryPositionalChannel(channel)) {
             return dataType;
         } else {
-            // TODO: Also explicitly set scales should be validated
             throw new Error(
                 channel +
                     " does not support " +
@@ -96,6 +95,44 @@ export function getDefaultScaleType(channel, dataType) {
     return type;
 }
 
+/**
+ * Validates explicit scale type choices against the resolved data type and
+ * channel constraints.
+ *
+ * @param {Channel} channel
+ * @param {import("../spec/channel.js").Type} dataType
+ * @param {import("../spec/scale.js").ScaleType | undefined} scaleType
+ * @param {string} source
+ */
+export function validateScaleTypeCompatibility(
+    channel,
+    dataType,
+    scaleType,
+    source
+) {
+    if (!scaleType) {
+        return;
+    }
+
+    if (
+        [INDEX, LOCUS].includes(scaleType) &&
+        !isPrimaryPositionalChannel(channel)
+    ) {
+        throw new Error(
+            `Index and locus scales are only supported on positional channels (x/y). Channel "${channel}" resolves to scale type "${scaleType}".`
+        );
+    }
+
+    if (
+        ([INDEX, LOCUS].includes(dataType) && scaleType !== dataType) ||
+        (scaleType === LOCUS && scaleType !== dataType)
+    ) {
+        throw new Error(
+            `${source} "${scaleType}" is incompatible with "${dataType}" data.`
+        );
+    }
+}
+
 /**
  * @param {import("../spec/scale.js").Scale} props
  * @param {Channel} channel

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

@@ -0,0 +1,45 @@
+/**
+ * @typedef {import("../spec/channel.js").ChannelWithScale} ChannelWithScale
+ * @typedef {import("../spec/scale.js").Scale} Scale
+ * @typedef {import("../view/view.js").default} View
+ * @typedef {import("./scaleResolution.js").default} ScaleResolution
+ *
+ * @typedef {object} ViewLevelScaleConfigMapping
+ * @prop {View} view
+ * @prop {ChannelWithScale} channel
+ * @prop {Scale} config
+ * @prop {ScaleResolution | undefined} resolution
+ */
+/**
+ * Maps view-level scale configs to the unique scale resolution visible from
+ * each configured subtree. Configs with no matching resolution stay pending.
+ *
+ * @param {View} root
+ * @returns {ViewLevelScaleConfigMapping[]}
+ */
+export function mapViewLevelScaleConfigs(root: View): ViewLevelScaleConfigMapping[];
+/**
+ * Maps view-level scale configs and attaches non-pending configs to their
+ * target resolutions.
+ *
+ * @param {View} root
+ * @returns {ViewLevelScaleConfigMapping[]}
+ */
+export function attachViewLevelScaleConfigs(root: View): ViewLevelScaleConfigMapping[];
+/**
+ * Clears view-level scale configs owned by views in the subtree.
+ *
+ * @param {View} root
+ */
+export function clearViewLevelScaleConfigs(root: View): void;
+export type ChannelWithScale = import("../spec/channel.js").ChannelWithScale;
+export type Scale = import("../spec/scale.js").Scale;
+export type View = import("../view/view.js").default;
+export type ScaleResolution = import("./scaleResolution.js").default;
+export type ViewLevelScaleConfigMapping = {
+    view: View;
+    channel: ChannelWithScale;
+    config: Scale;
+    resolution: ScaleResolution | undefined;
+};
+//# sourceMappingURL=viewLevelScaleConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viewLevelScaleConfig.d.ts","sourceRoot":"","sources":["../../../src/scales/viewLevelScaleConfig.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,+CAHW,IAAI,GACF,2BAA2B,EAAE,CAwBzC;AAED;;;;;;GAMG;AACH,kDAHW,IAAI,GACF,2BAA2B,EAAE,CAczC;AAED;;;;GAIG;AACH,iDAFW,IAAI,QAYd;+BA/EY,OAAO,oBAAoB,EAAE,gBAAgB;oBAC7C,OAAO,kBAAkB,EAAE,KAAK;mBAChC,OAAO,iBAAiB,EAAE,OAAO;8BACjC,OAAO,sBAAsB,EAAE,OAAO;;UAGzC,IAAI;aACJ,gBAAgB;YAChB,KAAK;gBACL,eAAe,GAAG,SAAS"}

package/dist/src/scales/viewLevelScaleConfig.js

@@ -0,0 +1,138 @@
+/**
+ * @typedef {import("../spec/channel.js").ChannelWithScale} ChannelWithScale
+ * @typedef {import("../spec/scale.js").Scale} Scale
+ * @typedef {import("../view/view.js").default} View
+ * @typedef {import("./scaleResolution.js").default} ScaleResolution
+ *
+ * @typedef {object} ViewLevelScaleConfigMapping
+ * @prop {View} view
+ * @prop {ChannelWithScale} channel
+ * @prop {Scale} config
+ * @prop {ScaleResolution | undefined} resolution
+ */
+
+/**
+ * Maps view-level scale configs to the unique scale resolution visible from
+ * each configured subtree. Configs with no matching resolution stay pending.
+ *
+ * @param {View} root
+ * @returns {ViewLevelScaleConfigMapping[]}
+ */
+export function mapViewLevelScaleConfigs(root) {
+    /** @type {ViewLevelScaleConfigMapping[]} */
+    const mappings = [];
+
+    for (const view of root.getDescendants()) {
+        const scales = view.spec.scales;
+        if (!scales) {
+            continue;
+        }
+
+        for (const [channel, config] of Object.entries(scales)) {
+            mappings.push(
+                mapViewLevelScaleConfig(
+                    view,
+                    /** @type {ChannelWithScale} */ (channel),
+                    config
+                )
+            );
+        }
+    }
+
+    return mappings;
+}
+
+/**
+ * Maps view-level scale configs and attaches non-pending configs to their
+ * target resolutions.
+ *
+ * @param {View} root
+ * @returns {ViewLevelScaleConfigMapping[]}
+ */
+export function attachViewLevelScaleConfigs(root) {
+    clearViewLevelScaleConfigs(root);
+    const mappings = mapViewLevelScaleConfigs(root);
+    for (const mapping of mappings) {
+        if (mapping.resolution) {
+            mapping.resolution.attachViewLevelScaleConfig(
+                mapping.view,
+                mapping.config
+            );
+        }
+    }
+    return mappings;
+}
+
+/**
+ * Clears view-level scale configs owned by views in the subtree.
+ *
+ * @param {View} root
+ */
+export function clearViewLevelScaleConfigs(root) {
+    const views = new Set(root.getDescendants());
+    const resolutions = collectAllScaleResolutions(root);
+
+    for (const resolution of resolutions) {
+        const config = resolution.getViewLevelScaleConfig();
+        if (config && views.has(config.view)) {
+            resolution.clearViewLevelScaleConfig(config.view);
+        }
+    }
+}
+
+/**
+ * @param {View} view
+ * @param {ChannelWithScale} channel
+ * @param {Scale} config
+ * @returns {ViewLevelScaleConfigMapping}
+ */
+function mapViewLevelScaleConfig(view, channel, config) {
+    const resolutions = collectVisibleScaleResolutions(view, channel);
+
+    if (resolutions.size > 1) {
+        throw new Error(
+            `View-level scales.${channel} maps to multiple scale resolutions. ` +
+                `Move scales.${channel} closer to the intended subtree or configure scale resolution explicitly.`
+        );
+    }
+
+    const resolution = resolutions.values().next().value;
+    return {
+        view,
+        channel,
+        config,
+        resolution,
+    };
+}
+
+/**
+ * @param {View} view
+ * @param {ChannelWithScale} channel
+ * @returns {Set<ScaleResolution>}
+ */
+function collectVisibleScaleResolutions(view, channel) {
+    /** @type {Set<ScaleResolution>} */
+    const resolutions = new Set();
+    for (const descendant of view.getDescendants()) {
+        const resolution = descendant.getScaleResolution(channel);
+        if (resolution) {
+            resolutions.add(resolution);
+        }
+    }
+    return resolutions;
+}
+
+/**
+ * @param {View} view
+ * @returns {Set<ScaleResolution>}
+ */
+function collectAllScaleResolutions(view) {
+    /** @type {Set<ScaleResolution>} */
+    const resolutions = new Set();
+    for (const descendant of view.getDescendants()) {
+        for (const resolution of Object.values(descendant.resolutions.scale)) {
+            resolutions.add(resolution);
+        }
+    }
+    return resolutions;
+}

package/dist/src/spec/scale.d.ts

@@ -67,8 +67,17 @@ export interface Scale {
      * For _temporal_ fields, `domain` can be a two-element array minimum and maximum values, in the form of either timestamps or the [DateTime definition objects](https://vega.github.io/vega-lite/docs/types.html#datetime).
      *
      * For _ordinal_ and _nominal_ fields, `domain` can be an array that lists valid input values.
+
+     * The domain can also be defined by an expression reference that evaluates to the domain array.
+     * Array elements may also be expression references.
+     *
      */
-    domain?: ScalarDomain | ComplexDomain | SelectionDomainRef | ExprRef;
+    domain?:
+        | ScalarDomain
+        | ComplexDomain
+        | SelectionDomainRef
+        | ExprRef
+        | DomainValueArray;
 
     /**
      * Inserts a single mid-point value into a two-element domain. The mid-point value must lie between the domain minimum and maximum values. This property can be useful for setting a midpoint for [diverging color scales](https://vega.github.io/vega-lite/docs/scale.html#piecewise). The domainMid property is only intended for use with scales supporting continuous, piecewise domains.
@@ -97,10 +106,10 @@ export interface Scale {
      * transition.
      *
      * Set this to `false` to apply domain updates immediately. The default is
-     * `true`, except for domains defined by an `ExprRef`, which default to
+     * `true`, except for domains that include `ExprRef`s, which default to
      * `false` unless overridden.
      *
-     * __Default value:__ `true`, except `false` for ExprRef-driven domains.
+     * __Default value:__ `true`, except `false` for `ExprRef`-driven domains.
      */
     domainTransition?: boolean | Record<string, unknown>;
 
@@ -109,9 +118,9 @@ export interface Scale {
      *
      * - A string indicating a [pre-defined named scale range](https://vega.github.io/vega-lite/docs/scale.html#range-config) (e.g., example, `"symbol"`, or `"diverging"`).
      *
-     * - For [continuous scales](https://vega.github.io/vega-lite/docs/scale.html#continuous), two-element array indicating  minimum and maximum values, or an array with more than two entries for specifying a [piecewise scale](https://vega.github.io/vega-lite/docs/scale.html#piecewise).
+     * - For [continuous scales](https://vega.github.io/vega-lite/docs/scale.html#continuous), two-element array indicating minimum and maximum values, or an array with more than two entries for specifying a [piecewise scale](https://vega.github.io/vega-lite/docs/scale.html#piecewise). Array elements may also be expression references.
      *
-     * - For [discrete](https://vega.github.io/vega-lite/docs/scale.html#discrete) and [discretizing](https://vega.github.io/vega-lite/docs/scale.html#discretizing) scales, an array of desired output values.
+     * - For [discrete](https://vega.github.io/vega-lite/docs/scale.html#discrete) and [discretizing](https://vega.github.io/vega-lite/docs/scale.html#discretizing) scales, an array of desired output values. Array elements may also be expression references.
      *
      * __Notes:__
      *
@@ -119,7 +128,7 @@ export interface Scale {
      *
      * 2) Any directly specified `range` for `x` and `y` channels will be ignored. Range can be customized via the view's corresponding [size](https://vega.github.io/vega-lite/docs/size.html) (`width` and `height`).
      */
-    range?: number[] | string[] | string | ExprRef[];
+    range?: (number | string | ExprRef)[] | string;
 
     // ordinal
 
@@ -257,6 +266,10 @@ export interface Scale {
 
 export type InlineLocusAssembly = GenomeDefinition;
 
+export type DomainValue = number | string | boolean | ExprRef;
+
+export type DomainValueArray = DomainValue[];
+
 export interface SelectionDomainRef {
     /**
      * Name of an interval selection parameter that provides the domain.