@genome-spy/core 0.68.0 → 0.69.1

package/dist/src/paramRuntime/viewParamRuntime.js

@@ -0,0 +1,443 @@
+import { isString } from "vega-util";
+import ParamRuntime from "./paramRuntime.js";
+import {
+    getDefaultParamValue,
+    isSelectionParameter,
+    validateParameterName,
+} from "./paramUtils.js";
+
+export {
+    activateExprRefProps,
+    getDefaultParamValue,
+    isExprRef,
+    isSelectionParameter,
+    isVariableParameter,
+    makeConstantExprRef,
+    validateParameterName,
+    withoutExprRef,
+} from "./paramUtils.js";
+
+/**
+ * A class that manages parameters and expressions.
+ * Supports nesting and scoped parameters through a shared runtime graph.
+ * The architecture follows signal-graph ideas (explicit dependencies, batched
+ * propagation, deterministic scheduling) while keeping GenomeSpy-specific
+ * parameter and expression semantics.
+ *
+ * @typedef {import("../utils/expression.js").ExpressionFunction & { subscribe: (listener: () => void) => () => void, invalidate: () => void, identifier: () => string}} ExprRefFunction
+ */
+export default class ViewParamRuntime {
+    /**
+     * @typedef {import("../spec/parameter.js").Parameter} Parameter
+     * @typedef {(value: any) => void} ParameterSetter
+     *
+     * @typedef {object} WatchExpressionOptions
+     * @prop {boolean} [scopeOwned=true]
+     *      Whether the subscription lifecycle is owned by this runtime scope.
+     *      When true, the listener is unsubscribed automatically during
+     *      `dispose()` via scope disposal. Set to false when another owner
+     *      (for example a `View` disposer registry) controls teardown.
+     * @prop {(disposer: () => void) => void} [registerDisposer]
+     *      Optional external disposer registration hook. When provided, the
+     *      unsubscribe callback is passed to this hook in addition to any
+     *      scope-owned registration.
+     */
+
+    /** @type {ParamRuntime} */
+    #runtime;
+
+    /** @type {string} */
+    #scopeId;
+
+    /** @type {Map<string, (value: any) => void>} */
+    #allocatedSetters = new Map();
+
+    /** @type {Map<string, import("./types.js").ParamRef<any>>} */
+    #localRefs = new Map();
+
+    /** @type {Map<string, Parameter>} */
+    #paramConfigs = new Map();
+
+    /** @type {() => ViewParamRuntime} */
+    #parentFinder;
+
+    #disposed = false;
+
+    /**
+     * @param {() => ViewParamRuntime} [parentFinder]
+     *      An optional function that returns the parent runtime.
+     *      N.B. The function must always return the same runtime for the same parent,
+     *      i.e., the changing the structure of the hierarchy is NOT supported.
+     */
+    constructor(parentFinder) {
+        this.#parentFinder = parentFinder ?? (() => undefined);
+
+        const parent = this.#parentFinder();
+        if (parent) {
+            this.#runtime = parent.#runtime;
+            this.#scopeId = this.#runtime.createScope(parent.#scopeId);
+        } else {
+            this.#runtime = new ParamRuntime();
+            this.#scopeId = this.#runtime.createScope();
+        }
+    }
+
+    /**
+     * Registers a parameter definition into this runtime scope.
+     *
+     * Returns a writable setter for writable parameters (`value`, `select`,
+     * `push: "outer"`). For derived (`expr`) parameters, the returned setter
+     * throws.
+     *
+     * A parameter name can be registered only once per runtime scope.
+     *
+     * @param {Parameter} param
+     * @returns {ParameterSetter}
+     */
+    registerParam(param) {
+        const name = param.name;
+        validateParameterName(name);
+
+        if (this.#paramConfigs.has(name)) {
+            throw new Error(
+                'Parameter "' + name + '" already registered in this scope.'
+            );
+        }
+
+        if ("value" in param && "expr" in param) {
+            throw new Error(
+                `The parameter "${name}" must not have both value and expr properties!`
+            );
+        }
+
+        /** @type {ParameterSetter} */
+        let setter;
+        let defaultValue;
+
+        if (param.push == "outer") {
+            const outerRuntime = this.findRuntimeForParam(name);
+            if (!outerRuntime) {
+                throw new Error(
+                    `Parameter "${name}" not found in outer scope!`
+                );
+            }
+
+            const outerProps = outerRuntime.paramConfigs.get(name);
+            if (!outerProps) {
+                throw new Error(
+                    `Outer parameter "${name}" exists as a value but has no registered config.`
+                );
+            }
+            if ("expr" in outerProps || "select" in outerProps) {
+                throw new Error(
+                    `The outer parameter "${name}" must not have expr or select properties!`
+                );
+            }
+            setter = (
+                /** @type {any} */
+                value
+            ) => {
+                outerRuntime.setValue(name, value);
+            };
+            // The following will become a bit fragile if the view hierarchy is going to
+            // support mutation (i.e. adding/removing children) in future.
+            this.#allocatedSetters.set(name, setter);
+        } else if ("value" in param) {
+            defaultValue = getDefaultParamValue(param, this);
+            setter = this.#registerBaseSetter(name, defaultValue);
+        } else if ("expr" in param) {
+            const ref = this.#runtime.registerDerived(
+                this.#scopeId,
+                name,
+                param.expr
+            );
+            this.#localRefs.set(name, ref);
+            setter = () => {
+                throw new Error('Cannot set derived parameter "' + name + '".');
+            };
+        } else {
+            defaultValue = getDefaultParamValue(param, this);
+            setter = this.#registerBaseSetter(name, defaultValue);
+        }
+
+        if ("select" in param) {
+            defaultValue ??= getDefaultParamValue(param, this);
+            if (!this.#allocatedSetters.has(name)) {
+                const ref = this.#runtime.registerSelection(
+                    this.#scopeId,
+                    name,
+                    defaultValue
+                );
+                this.#localRefs.set(name, ref);
+                this.#allocatedSetters.set(name, (value) => {
+                    ref.set(value);
+                    this.#runtime.flushNow();
+                });
+                setter = this.#allocatedSetters.get(name);
+            }
+            // Set initial value so that production rules in shaders can be generated, etc.
+            setter(defaultValue);
+        }
+
+        this.#paramConfigs.set(name, param);
+
+        return setter;
+    }
+
+    /**
+     *
+     * @param {string} paramName
+     * @param {T} initialValue
+     * @param {boolean} [passive] If true, the setter will not notify listeners when the value changes.
+     * @returns {(value: T) => void}
+     * @template T
+     */
+    allocateSetter(paramName, initialValue, passive = false) {
+        validateParameterName(paramName);
+
+        if (this.#allocatedSetters.has(paramName)) {
+            throw new Error(
+                "Setter already allocated for parameter: " + paramName
+            );
+        }
+
+        const ref = this.#runtime.registerBase(
+            this.#scopeId,
+            paramName,
+            initialValue,
+            {
+                notify: !passive,
+            }
+        );
+        this.#localRefs.set(paramName, ref);
+        const setter = (
+            /** @type {T} */
+            value
+        ) => {
+            ref.set(value);
+            this.#runtime.flushNow();
+        };
+
+        this.#allocatedSetters.set(paramName, setter);
+
+        return setter;
+    }
+
+    /**
+     * Sets a writable parameter value in this runtime scope.
+     *
+     * Only parameters with locally registered writable setters are supported.
+     * This method does not resolve through ancestors.
+     *
+     * @param {string} paramName
+     * @param {any} value
+     */
+    setValue(paramName, value) {
+        validateParameterName(paramName);
+        const setter = this.#allocatedSetters.get(paramName);
+        if (!setter) {
+            throw new Error(
+                "Writable parameter not found in this scope: " + paramName
+            );
+        }
+        setter(value);
+    }
+
+    /**
+     * Get the value of a parameter from this runtime.
+     * @param {string} paramName
+     */
+    getValue(paramName) {
+        return this.#localRefs.get(paramName)?.get();
+    }
+
+    /**
+     * Subscribe to changes of a parameter's value. The listener is called only
+     * when the stored value changes. For expression parameters, the listener is
+     * called when upstream changes re-evaluate to a different value.
+     *
+     * @param {string} paramName
+     * @param {() => void} listener
+     * @returns {() => void}
+     */
+    subscribe(paramName, listener) {
+        validateParameterName(paramName);
+        const runtime = this.findRuntimeForParam(paramName);
+        if (!runtime) {
+            throw new Error("Parameter not found: " + paramName);
+        }
+
+        const ref = runtime.#localRefs.get(paramName);
+        if (!ref) {
+            throw new Error(
+                "Parameter found without local reference: " + paramName
+            );
+        }
+
+        return ref.subscribe(listener);
+    }
+
+    /**
+     * Get the value of a parameter from this runtime or its ancestors.
+     * @param {string} paramName
+     */
+    findValue(paramName) {
+        const runtime = this.findRuntimeForParam(paramName);
+        return runtime?.getValue(paramName);
+    }
+
+    /**
+     * Returns configs for all parameters that have been registered using `registerParam`.
+     */
+    get paramConfigs() {
+        return /** @type {ReadonlyMap<string, Parameter>} */ (
+            this.#paramConfigs
+        );
+    }
+
+    /**
+     *
+     * @param {string} paramName
+     * @returns {ViewParamRuntime}
+     */
+    findRuntimeForParam(paramName) {
+        if (this.#localRefs.has(paramName)) {
+            return this;
+        } else {
+            return this.#parentFinder()?.findRuntimeForParam(paramName);
+        }
+    }
+
+    // Setter lifecycle is scope-owned: setters are dropped when the runtime scope
+    // is disposed. A standalone deallocation API is intentionally not exposed.
+
+    /**
+     * Parse expr and return a function that returns the value of the parameter.
+     *
+     * @param {string} expr
+     */
+    createExpression(expr) {
+        return this.#runtime.createExpression(this.#scopeId, expr);
+    }
+
+    /**
+     * Creates an expression and subscribes a listener that is automatically
+     * removed according to `options` lifecycle ownership.
+     *
+     * Lifecycle semantics:
+     * 1. `scopeOwned: true` (default): unsubscribe is bound to runtime scope
+     *    disposal (`ViewParamRuntime.dispose()`).
+     * 2. `scopeOwned: false`: caller must own teardown, typically via
+     *    `registerDisposer` or by storing and calling the returned unsubscribe.
+     * 3. `registerDisposer` can be used regardless of `scopeOwned` to bind the
+     *    same unsubscribe to another lifecycle owner.
+     *
+     * @param {string} expr
+     * @param {() => void} listener
+     * @param {WatchExpressionOptions} [options]
+     * @returns {ExprRefFunction}
+     */
+    watchExpression(expr, listener, options = {}) {
+        const fn = this.createExpression(expr);
+        const dispose = fn.subscribe(listener);
+
+        if (options.scopeOwned ?? true) {
+            this.#runtime.addScopeDisposer(this.#scopeId, dispose);
+        }
+        options.registerDisposer?.(dispose);
+
+        return fn;
+    }
+
+    /**
+     * @template T
+     * @param {string} name
+     * @param {T} defaultValue
+     * @returns {(value: T) => void}
+     */
+    #registerBaseSetter(name, defaultValue) {
+        const ref = this.#runtime.registerBase(
+            this.#scopeId,
+            name,
+            defaultValue
+        );
+        this.#localRefs.set(name, ref);
+        const setter = (
+            /** @type {T} */
+            value
+        ) => {
+            ref.set(value);
+            this.#runtime.flushNow();
+        };
+        this.#allocatedSetters.set(name, setter);
+        return setter;
+    }
+
+    /**
+     * A convenience method for evaluating an expression.
+     *
+     * @param {string} expr
+     */
+    evaluateAndGet(expr) {
+        const fn = this.createExpression(expr);
+        return fn();
+    }
+
+    /**
+     * @template T
+     * @param {() => T} fn
+     * @returns {T}
+     */
+    runInTransaction(fn) {
+        return this.#runtime.runInTransaction(fn);
+    }
+
+    flushNow() {
+        this.#runtime.flushNow();
+    }
+
+    /**
+     * Sync barrier only: resolves when DAG propagation/effects have flushed.
+     * Must not be broadened to temporal/animation convergence semantics.
+     *
+     * @param {{ signal?: AbortSignal, timeoutMs?: number }} [options]
+     */
+    whenPropagated(options) {
+        return this.#runtime.whenPropagated(options);
+    }
+
+    dispose() {
+        if (this.#disposed) {
+            return;
+        }
+
+        this.#disposed = true;
+        this.#runtime.disposeScope(this.#scopeId);
+        this.#allocatedSetters.clear();
+        this.#localRefs.clear();
+        this.#paramConfigs.clear();
+    }
+
+    /**
+     * Returns true if this runtime has any parameters that are point selections.
+     * Point selections necessitate the use of uniqueIds in the data.
+     *
+     * @returns {boolean}
+     */
+    hasPointSelections() {
+        for (const param of this.#paramConfigs.values()) {
+            if (isSelectionParameter(param)) {
+                const select = param.select;
+                if (isString(select)) {
+                    if (select == "point") {
+                        return true;
+                    }
+                } else if (select.type == "point") {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+}

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

@@ -1,13 +1,15 @@
 export default class ScaleInstanceManager {
     /**
      * @param {object} options
-     * @param {() => import("../view/paramMediator.js").default} options.getParamMediator
+     * @param {() => { createExpression: (expr: string) => import("../paramRuntime/types.js").ExprRefFunction }} options.getParamRuntime
      * @param {() => void} options.onRangeChange
      * @param {() => void} [options.onDomainChange]
      * @param {() => import("../genome/genomeStore.js").default | undefined} [options.getGenomeStore]
      */
-    constructor({ getParamMediator, onRangeChange, onDomainChange, getGenomeStore, }: {
-        getParamMediator: () => import("../view/paramMediator.js").default;
+    constructor({ getParamRuntime, onRangeChange, onDomainChange, getGenomeStore, }: {
+        getParamRuntime: () => {
+            createExpression: (expr: string) => import("../paramRuntime/types.js").ExprRefFunction;
+        };
         onRangeChange: () => void;
         onDomainChange?: () => void;
         getGenomeStore?: () => import("../genome/genomeStore.js").default | undefined;
@@ -35,6 +37,7 @@ export default class ScaleInstanceManager {
      * @returns {void}
      */
     withDomainNotificationsSuppressed(callback: () => void): void;
+    dispose(): void;
     #private;
 }
 //# sourceMappingURL=scaleInstanceManager.d.ts.map

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,kFALG;QAAkE,gBAAgB,EAA1E,MAAM,OAAO,0BAA0B,EAAE,OAAO;QAC5B,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;;OAEG;IACH,kBAFa,OAAO,qBAAqB,EAAE,OAAO,CASjD;IAED;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,KAAK;eA3DT,OAAO,kBAAkB,EAAE,KAAK;MAgFjE;IAoBD;;OAEG;IACH,wBAFW,OAAO,kBAAkB,EAAE,KAAK,QAc1C;IAED;;;OAGG;IACH,4CAHW,MAAM,IAAI,GACR,IAAI,CAShB;;CAiFJ"}
+{"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;;OAEG;IACH,kBAFa,OAAO,qBAAqB,EAAE,OAAO,CASjD;IAED;;;OAGG;IACH,mBAHW,OAAO,kBAAkB,EAAE,KAAK;eA3DT,OAAO,kBAAkB,EAAE,KAAK;MAgFjE;IAoBD;;OAEG;IACH,wBAFW,OAAO,kBAAkB,EAAE,KAAK,QAc1C;IAED;;;OAGG;IACH,4CAHW,MAAM,IAAI,GACR,IAAI,CAShB;IAmFD,gBAGC;;CACJ"}

package/dist/src/scales/scaleInstanceManager.js

@@ -1,7 +1,7 @@
 import { isArray } from "vega-util";
 
 import createScale, { configureScale } from "../scale/scale.js";
-import { isExprRef } from "../view/paramMediator.js";
+import { isExprRef } from "../paramRuntime/paramUtils.js";
 import { isScaleLocus } from "../genome/scaleLocus.js";
 
 export default class ScaleInstanceManager {
@@ -13,11 +13,11 @@ export default class ScaleInstanceManager {
     /** @type {ScaleWithProps | undefined} */
     #scale;
 
-    /** @type {Set<import("../view/paramMediator.js").ExprRefFunction>} */
+    /** @type {Set<import("../paramRuntime/types.js").ExprRefFunction>} */
     #rangeExprRefListeners = new Set();
 
-    /** @type {() => import("../view/paramMediator.js").default} */
-    #getParamMediator;
+    /** @type {() => { createExpression: (expr: string) => import("../paramRuntime/types.js").ExprRefFunction }} */
+    #getParamRuntime;
 
     /** @type {() => void} */
     #onRangeChange;
@@ -32,18 +32,18 @@ export default class ScaleInstanceManager {
 
     /**
      * @param {object} options
-     * @param {() => import("../view/paramMediator.js").default} options.getParamMediator
+     * @param {() => { createExpression: (expr: string) => import("../paramRuntime/types.js").ExprRefFunction }} options.getParamRuntime
      * @param {() => void} options.onRangeChange
      * @param {() => void} [options.onDomainChange]
      * @param {() => import("../genome/genomeStore.js").default | undefined} [options.getGenomeStore]
      */
     constructor({
-        getParamMediator,
+        getParamRuntime,
         onRangeChange,
         onDomainChange,
         getGenomeStore,
     }) {
-        this.#getParamMediator = getParamMediator;
+        this.#getParamRuntime = getParamRuntime;
         this.#onRangeChange = onRangeChange;
         this.#onDomainChange = onDomainChange;
         this.#getGenomeStore = getGenomeStore;
@@ -167,12 +167,13 @@ export default class ScaleInstanceManager {
 
         const props = scale.props;
         this.#rangeExprRefListeners.forEach((fn) => fn.invalidate());
+        this.#rangeExprRefListeners.clear();
 
         const resolved = resolveRange({
             range: props.range,
             reverse: props.reverse,
             createExpression: (expr) =>
-                this.#getParamMediator().createExpression(expr),
+                this.#getParamRuntime().createExpression(expr),
             registerExpr: (fn) => this.#rangeExprRefListeners.add(fn),
         });
 
@@ -216,6 +217,11 @@ export default class ScaleInstanceManager {
 
         notifyRange();
     }
+
+    dispose() {
+        this.#rangeExprRefListeners.forEach((fn) => fn.invalidate());
+        this.#rangeExprRefListeners.clear();
+    }
 }
 
 /**
@@ -261,8 +267,8 @@ function withScaleInterceptors(
  * @param {object} options
  * @param {import("../spec/scale.js").Scale["range"]} options.range
  * @param {boolean | undefined} options.reverse
- * @param {(expr: string) => import("../view/paramMediator.js").ExprRefFunction} options.createExpression
- * @param {(fn: import("../view/paramMediator.js").ExprRefFunction) => void} options.registerExpr
+ * @param {(expr: string) => import("../paramRuntime/types.js").ExprRefFunction} options.createExpression
+ * @param {(fn: import("../paramRuntime/types.js").ExprRefFunction) => void} options.registerExpr
  * @returns {{
  *   dynamic: true,
  *   evaluate: () => any[],
@@ -299,7 +305,7 @@ function resolveRange({ range, reverse, createExpression, registerExpr }) {
             expressions = range.map((elem) => {
                 if (isExprRef(elem)) {
                     const fn = createExpression(elem.expr);
-                    fn.addListener(listener);
+                    fn.subscribe(listener);
                     registerExpr(fn);
                     return () => fn(null);
                 }

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

@@ -56,6 +56,7 @@ export default class ScaleResolution implements ScaleResolutionApi {
      * @returns {() => boolean}
      */
     registerMember(member: ScaleResolutionMember): () => boolean;
+    dispose(): void;
     /**
      * @param {import("../data/collector.js").default} collector
      * @param {Iterable<import("../types/encoder.js").ScaleAccessor>} accessors

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

@@ -1 +1 @@
-{"version":3,"file":"scaleResolution.d.ts","sourceRoot":"","sources":["../../../src/scales/scaleResolution.js"],"names":[],"mappings":"AAuCA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA8CI;;OAEG;IACH,2DAkCC;IAjCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IAoEzB,2BASC;IAqBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IA6ED;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAYzB;IAWD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IA4HD;;;;;OAKG;IACH,oBAUC;IAED;;;;;OAKG;IACH,0BAuBC;IAuGD;;OAEG;IACH;eA5jBkC,OAAO,kBAAkB,EAAE,KAAK;MAmkBjE;IAED;;;;;;OAMG;IACH;eA5kBkC,OAAO,kBAAkB,EAAE,KAAK;MA8kBjE;IAED;;;;OAIG;IACH;eArlBkC,OAAO,kBAAkB,EAAE,KAAK;MA8lBjE;IAED,mBAEC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CAMzC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBAGC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAK1B;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;kCAlyB+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBAvBV,+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":"AAuCA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA8CI;;OAEG;IACH,2DAkCC;IAjCG,8CAAsB;IACtB,0FAA0F;IAC1F,MADW,OAAO,oBAAoB,EAAE,IAAI,CAC5B;IAEhB,iEAAiE;IACjE,MADW,MAAM,CACI;IAoEzB,2BASC;IAqBD;;;;;;;OAOG;IACH,4KAEC;IAED;;;OAGG;IACH,+KAEC;IA6ED;;;OAGG;IACH,uBAHW,qBAAqB,GACnB,MAAM,OAAO,CAYzB;IAED,gBAIC;IAWD;;;;OAIG;IACH,0CAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,QAAQ,CAAC,OAAO,qBAAqB,EAAE,aAAa,CAAC,GACnD,MAAM,IAAI,CAkCtB;IA4HD;;;;;OAKG;IACH,oBAUC;IAED;;;;;OAKG;IACH,0BAuBC;IAuGD;;OAEG;IACH;eAlkBkC,OAAO,kBAAkB,EAAE,KAAK;MAykBjE;IAED;;;;;;OAMG;IACH;eAllBkC,OAAO,kBAAkB,EAAE,KAAK;MAolBjE;IAED;;;;OAIG;IACH;eA3lBkC,OAAO,kBAAkB,EAAE,KAAK;MAomBjE;IAED,mBAEC;IAED;;;;OAIG;IACH,+DAEC;IAED;;OAEG;IACH,oBAFa,mFAA6B,CAMzC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,sBAGC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,eACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,eAJW,mFAA6B,aAC7B,OAAO,GAAG,MAAM,iBAK1B;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;kCAxyB+B,CAAC,SAApB,6CAAkB;;;;UAGrB,OAAO,qBAAqB,EAAE,OAAO;aACrC,CAAC;gBACD,OAAO,oBAAoB,EAAE,mBAAmB;yBAChD,OAAO;;sBAvBV,+BAA+B;sBAA/B,+BAA+B;wBAA/B,+BAA+B;wBAA/B,+BAA+B;6BAA/B,+BAA+B"}

package/dist/src/scales/scaleResolution.js

@@ -132,7 +132,7 @@ export default class ScaleResolution {
         });
 
         this.#scaleManager = new ScaleInstanceManager({
-            getParamMediator: () => this.#firstMemberView.paramMediator,
+            getParamRuntime: () => this.#firstMemberView.paramRuntime,
             onRangeChange: () => this.#notifyListeners("range"),
             onDomainChange: () => this.#notifyListeners("domain"),
             getGenomeStore: () => this.#viewContext.genomeStore,
@@ -329,6 +329,12 @@ export default class ScaleResolution {
         };
     }
 
+    dispose() {
+        this.#listeners.domain.clear();
+        this.#listeners.range.clear();
+        this.#scaleManager.dispose();
+    }
+
     #hasRenderedMember() {
         for (const member of this.#members) {
             if (member.view.hasRendered()) {

package/dist/src/selection/selection.js

@@ -3,7 +3,7 @@ import {
     getSecondaryChannel,
     isPrimaryPositionalChannel,
 } from "../encoder/encoder.js";
-import { validateParameterName } from "../view/paramMediator.js";
+import { validateParameterName } from "../paramRuntime/paramUtils.js";
 import { field } from "../utils/field.js";
 
 /**

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

@@ -0,0 +1,53 @@
+import { RootConfig } from "./root.js";
+import {
+    ConcatSpec as CoreConcatSpec,
+    HConcatSpec as CoreHConcatSpec,
+    ImportSpec,
+    LayerSpec as CoreLayerSpec,
+    MultiscaleSpec as CoreMultiscaleSpec,
+    UnitSpec as CoreUnitSpec,
+    VConcatSpec as CoreVConcatSpec,
+} from "./view.js";
+
+interface SchemaViewConfig {
+    templates?: Record<string, ViewSpec>;
+}
+
+interface UnitSpec extends Omit<CoreUnitSpec, "templates">, SchemaViewConfig {}
+
+interface LayerSpec
+    extends Omit<CoreLayerSpec, "templates" | "layer">, SchemaViewConfig {
+    layer: (LayerSpec | UnitSpec | MultiscaleSpec | ImportSpec)[];
+}
+
+interface MultiscaleSpec
+    extends
+        Omit<CoreMultiscaleSpec, "templates" | "multiscale">,
+        SchemaViewConfig {
+    multiscale: (LayerSpec | UnitSpec | MultiscaleSpec | ImportSpec)[];
+}
+
+interface VConcatSpec
+    extends Omit<CoreVConcatSpec, "templates" | "vconcat">, SchemaViewConfig {
+    vconcat: (ViewSpec | ImportSpec)[];
+}
+
+interface HConcatSpec
+    extends Omit<CoreHConcatSpec, "templates" | "hconcat">, SchemaViewConfig {
+    hconcat: (ViewSpec | ImportSpec)[];
+}
+
+interface ConcatSpec
+    extends Omit<CoreConcatSpec, "templates" | "concat">, SchemaViewConfig {
+    concat: (ViewSpec | ImportSpec)[];
+}
+
+type ViewSpec =
+    | UnitSpec
+    | LayerSpec
+    | MultiscaleSpec
+    | VConcatSpec
+    | HConcatSpec
+    | ConcatSpec;
+
+export type CoreRootSpec = ViewSpec & RootConfig;

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

@@ -1,7 +1,7 @@
 import { GenomeConfig } from "./genome.js";
 import { ViewSpec } from "./view.js";
 
-interface RootConfig {
+export interface RootConfig {
     $schema?: string;
 
     genome?: GenomeConfig;