@genome-spy/core 0.68.0 → 0.69.1

package/dist/src/paramRuntime/paramUtils.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @typedef {import("../utils/expression.js").ExpressionFunction & {
+ *   subscribe: (listener: () => void) => () => void,
+ *   invalidate: () => void,
+ *   identifier: () => string
+ * }} ExprRefFunction
+ */
+/**
+ * @param {any} x
+ * @returns {x is import("../spec/parameter.js").ExprRef}
+ */
+export function isExprRef(x: any): x is import("../spec/parameter.js").ExprRef;
+/**
+ * Removes ExprRef from the type and checks that the value is not an ExprRef.
+ * This is designed to be used with `activateExprRefProps`.
+ *
+ * @param {T | import("../spec/parameter.js").ExprRef} x
+ * @template T
+ * @returns {T}
+ */
+export function withoutExprRef<T>(x: T | import("../spec/parameter.js").ExprRef): T;
+/**
+ * @param {import("../spec/parameter.js").Parameter} param
+ * @returns {param is import("../spec/parameter.js").VariableParameter}
+ */
+export function isVariableParameter(param: import("../spec/parameter.js").Parameter): param is import("../spec/parameter.js").VariableParameter;
+/**
+ * @param {import("../spec/parameter.js").Parameter} param
+ * @returns {param is import("../spec/parameter.js").SelectionParameter}
+ */
+export function isSelectionParameter(param: import("../spec/parameter.js").Parameter): param is import("../spec/parameter.js").SelectionParameter;
+/**
+ * Validates a parameter name. If the name is invalid, throws an error.
+ * Otherwise, returns the name.
+ *
+ * @param {string} name
+ * @returns {string} the name
+ */
+export function validateParameterName(name: string): string;
+/**
+ * Computes the default value for a parameter specification.
+ *
+ * @param {import("../spec/parameter.js").Parameter} param
+ * @param {{ createExpression: (expr: string) => ExprRefFunction }} [paramRuntime]
+ * @param {ExprRefFunction} [exprFn]
+ * @returns {any}
+ */
+export function getDefaultParamValue(param: import("../spec/parameter.js").Parameter, paramRuntime?: {
+    createExpression: (expr: string) => ExprRefFunction;
+}, exprFn?: ExprRefFunction): any;
+/**
+ * Takes a record of properties that may have ExprRefs as values. Converts the
+ * ExprRefs to getters and setups a listener that is called when any of the
+ * expressions (upstream parameters) change.
+ *
+ * @param {{ createExpression: (expr: string) => ExprRefFunction, watchExpression?: (expr: string, listener: () => void, options?: { scopeOwned?: boolean, registerDisposer?: (disposer: () => void) => void }) => ExprRefFunction, whenPropagated?: () => Promise<void> }} paramRuntime
+ * @param {T} props The properties object
+ * @param {(props: ReadonlySet<keyof T>) => void} [listener] Listener to be called when any of the expressions change
+ * @param {(disposer: () => void) => void} [registerDisposer]
+ * @param {{ batchMode?: "microtask" | "whenPropagated" }} [options]
+ * @returns T
+ * @template {Record<string, any | import("../spec/parameter.js").ExprRef>} T
+ */
+export function activateExprRefProps<T extends Record<string, any | import("../spec/parameter.js").ExprRef>>(paramRuntime: {
+    createExpression: (expr: string) => ExprRefFunction;
+    watchExpression?: (expr: string, listener: () => void, options?: {
+        scopeOwned?: boolean;
+        registerDisposer?: (disposer: () => void) => void;
+    }) => ExprRefFunction;
+    whenPropagated?: () => Promise<void>;
+}, props: T, listener?: (props: ReadonlySet<keyof T>) => void, registerDisposer?: (disposer: () => void) => void, options?: {
+    batchMode?: "microtask" | "whenPropagated";
+}): T;
+/**
+ * Creates a function that always returns the same value.
+ *
+ * @param {any} value
+ * @returns {ExprRefFunction}
+ */
+export function makeConstantExprRef(value: any): ExprRefFunction;
+export type ExprRefFunction = import("../utils/expression.js").ExpressionFunction & {
+    subscribe: (listener: () => void) => () => void;
+    invalidate: () => void;
+    identifier: () => string;
+};
+//# sourceMappingURL=paramUtils.d.ts.map

package/dist/src/paramRuntime/paramUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paramUtils.d.ts","sourceRoot":"","sources":["../../../src/paramRuntime/paramUtils.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AAEH;;;GAGG;AACH,6BAHW,GAAG,GACD,CAAC,IAAI,OAAO,sBAAsB,EAAE,OAAO,CAIvD;AAED;;;;;;;GAOG;AACH,+BAHa,CAAC,KADH,CAAC,GAAG,OAAO,sBAAsB,EAAE,OAAO,GAExC,CAAC,CAWb;AAED;;;GAGG;AACH,2CAHW,OAAO,sBAAsB,EAAE,SAAS,GACtC,KAAK,IAAI,OAAO,sBAAsB,EAAE,iBAAiB,CAIrE;AAED;;;GAGG;AACH,4CAHW,OAAO,sBAAsB,EAAE,SAAS,GACtC,KAAK,IAAI,OAAO,sBAAsB,EAAE,kBAAkB,CAItE;AAED;;;;;;GAMG;AACH,4CAHW,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;GAOG;AACH,4CALW,OAAO,sBAAsB,EAAE,SAAS,iBACxC;IAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAA;CAAE,WACvD,eAAe,GACb,GAAG,CA0Cf;AAED;;;;;;;;;;;;GAYG;AACH,qCAF4E,CAAC,SAA/D,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,sBAAsB,EAAE,OAAO,CAAE,gBANhE;IAAE,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,eAAe,CAAC;IAAC,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;KAAE,KAAK,eAAe,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,SAC/P,CAAC,aACD,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,qBACrC,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,YAC9B;IAAE,SAAS,CAAC,EAAE,WAAW,GAAG,gBAAgB,CAAA;CAAE,GAkHnC,CAAC,CACtB;AAED;;;;;GAKG;AACH,2CAHW,GAAG,GACD,eAAe,CAW3B;8BApQY,OAAO,wBAAwB,EAAE,kBAAkB,GAAG;IAC9D,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAChD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,MAAM,CAAA;CACzB"}

package/dist/src/paramRuntime/paramUtils.js

@@ -0,0 +1,272 @@
+import { isString } from "vega-util";
+import {
+    asSelectionConfig,
+    createIntervalSelection,
+    createMultiPointSelection,
+    createSinglePointSelection,
+    isIntervalSelectionConfig,
+    isPointSelectionConfig,
+} from "../selection/selection.js";
+
+/**
+ * @typedef {import("../utils/expression.js").ExpressionFunction & {
+ *   subscribe: (listener: () => void) => () => void,
+ *   invalidate: () => void,
+ *   identifier: () => string
+ * }} ExprRefFunction
+ */
+
+/**
+ * @param {any} x
+ * @returns {x is import("../spec/parameter.js").ExprRef}
+ */
+export function isExprRef(x) {
+    return typeof x == "object" && x != null && "expr" in x && isString(x.expr);
+}
+
+/**
+ * Removes ExprRef from the type and checks that the value is not an ExprRef.
+ * This is designed to be used with `activateExprRefProps`.
+ *
+ * @param {T | import("../spec/parameter.js").ExprRef} x
+ * @template T
+ * @returns {T}
+ */
+export function withoutExprRef(x) {
+    if (isExprRef(x)) {
+        throw new Error(
+            "ExprRef " +
+                JSON.stringify(x) +
+                " not allowed here. Expected a scalar value."
+        );
+    }
+    return /** @type {T} */ (x);
+}
+
+/**
+ * @param {import("../spec/parameter.js").Parameter} param
+ * @returns {param is import("../spec/parameter.js").VariableParameter}
+ */
+export function isVariableParameter(param) {
+    return ("expr" in param || "bind" in param) && !("select" in param);
+}
+
+/**
+ * @param {import("../spec/parameter.js").Parameter} param
+ * @returns {param is import("../spec/parameter.js").SelectionParameter}
+ */
+export function isSelectionParameter(param) {
+    return !("expr" in param || "bind" in param) && "select" in param;
+}
+
+/**
+ * Validates a parameter name. If the name is invalid, throws an error.
+ * Otherwise, returns the name.
+ *
+ * @param {string} name
+ * @returns {string} the name
+ */
+export function validateParameterName(name) {
+    if (!/^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name)) {
+        throw new Error(
+            "Invalid parameter name: " +
+                name +
+                ". Must be a valid JavaScript identifier."
+        );
+    }
+
+    return name;
+}
+
+/**
+ * Computes the default value for a parameter specification.
+ *
+ * @param {import("../spec/parameter.js").Parameter} param
+ * @param {{ createExpression: (expr: string) => ExprRefFunction }} [paramRuntime]
+ * @param {ExprRefFunction} [exprFn]
+ * @returns {any}
+ */
+export function getDefaultParamValue(param, paramRuntime, exprFn) {
+    if ("select" in param) {
+        const select = asSelectionConfig(param.select);
+        if (isPointSelectionConfig(select)) {
+            return select.toggle
+                ? createMultiPointSelection()
+                : createSinglePointSelection(null);
+        }
+        if (isIntervalSelectionConfig(select)) {
+            if (!select.encodings) {
+                throw new Error(
+                    'Interval selection "' +
+                        param.name +
+                        '" must have encodings defined!'
+                );
+            }
+            return createIntervalSelection(select.encodings);
+        }
+        throw new Error(
+            'Unknown selection config for parameter "' + param.name + '".'
+        );
+    }
+
+    if ("expr" in param) {
+        const expr =
+            exprFn ??
+            paramRuntime?.createExpression(/** @type {string} */ (param.expr));
+        if (!expr) {
+            throw new Error(
+                'Cannot evaluate expression for parameter "' + param.name + '".'
+            );
+        }
+        return expr(null);
+    }
+
+    if ("value" in param) {
+        return param.value;
+    }
+
+    return null;
+}
+
+/**
+ * Takes a record of properties that may have ExprRefs as values. Converts the
+ * ExprRefs to getters and setups a listener that is called when any of the
+ * expressions (upstream parameters) change.
+ *
+ * @param {{ createExpression: (expr: string) => ExprRefFunction, watchExpression?: (expr: string, listener: () => void, options?: { scopeOwned?: boolean, registerDisposer?: (disposer: () => void) => void }) => ExprRefFunction, whenPropagated?: () => Promise<void> }} paramRuntime
+ * @param {T} props The properties object
+ * @param {(props: ReadonlySet<keyof T>) => void} [listener] Listener to be called when any of the expressions change
+ * @param {(disposer: () => void) => void} [registerDisposer]
+ * @param {{ batchMode?: "microtask" | "whenPropagated" }} [options]
+ * @returns T
+ * @template {Record<string, any | import("../spec/parameter.js").ExprRef>} T
+ */
+export function activateExprRefProps(
+    paramRuntime,
+    props,
+    listener,
+    registerDisposer,
+    options = {}
+) {
+    /** @type {Record<string, any | import("../spec/parameter.js").ExprRef>} */
+    const activatedProps = { ...props };
+
+    /** @type {Set<keyof T>} */
+    const alteredProps = new Set();
+
+    let scheduled = false;
+    let cancelled = false;
+    const batchMode = options.batchMode ?? "microtask";
+
+    const cancel = () => {
+        cancelled = true;
+        alteredProps.clear();
+        scheduled = false;
+    };
+
+    registerDisposer?.(cancel);
+
+    const flushChanges = () => {
+        if (cancelled) {
+            return;
+        }
+
+        if (!listener || alteredProps.size === 0) {
+            scheduled = false;
+            return;
+        }
+
+        const changedProps = new Set(alteredProps);
+        alteredProps.clear();
+        scheduled = false;
+        listener(changedProps);
+    };
+
+    const batchPropertyChange = (/** @type {keyof T} */ prop) => {
+        if (cancelled) {
+            return;
+        }
+
+        alteredProps.add(prop);
+        if (!scheduled) {
+            scheduled = true;
+            queueMicrotask(() => {
+                if (cancelled) {
+                    return;
+                }
+
+                if (
+                    batchMode == "whenPropagated" &&
+                    paramRuntime.whenPropagated
+                ) {
+                    paramRuntime
+                        .whenPropagated()
+                        .then(flushChanges)
+                        .catch(() => {
+                            flushChanges();
+                        });
+                } else {
+                    flushChanges();
+                }
+            });
+        }
+    };
+
+    for (const [key, value] of Object.entries(props)) {
+        if (isExprRef(value)) {
+            if (listener) {
+                const expressionListener = () => batchPropertyChange(key);
+                const fn = paramRuntime.watchExpression
+                    ? paramRuntime.watchExpression(
+                          value.expr,
+                          expressionListener,
+                          {
+                              scopeOwned: !registerDisposer,
+                              registerDisposer,
+                          }
+                      )
+                    : paramRuntime.createExpression(value.expr);
+                if (!paramRuntime.watchExpression) {
+                    const unsubscribe = fn.subscribe(expressionListener);
+                    registerDisposer?.(unsubscribe);
+                }
+
+                Object.defineProperty(activatedProps, key, {
+                    enumerable: true,
+                    get() {
+                        return fn();
+                    },
+                });
+            } else {
+                const fn = paramRuntime.createExpression(value.expr);
+                Object.defineProperty(activatedProps, key, {
+                    enumerable: true,
+                    get() {
+                        return fn();
+                    },
+                });
+            }
+        } else {
+            activatedProps[key] = value;
+        }
+    }
+
+    return /** @type {T} */ (activatedProps);
+}
+
+/**
+ * Creates a function that always returns the same value.
+ *
+ * @param {any} value
+ * @returns {ExprRefFunction}
+ */
+export function makeConstantExprRef(value) {
+    return Object.assign(() => value, {
+        subscribe: () => () => /** @type {void} */ (undefined),
+        invalidate: () => /** @type {void} */ (undefined),
+        identifier: () => "constant",
+        fields: [],
+        globals: [],
+        code: JSON.stringify(value),
+    });
+}

package/dist/src/paramRuntime/selectionStore.d.ts

@@ -0,0 +1,6 @@
+import { createSinglePointSelection } from "../selection/selection.js";
+import { createMultiPointSelection } from "../selection/selection.js";
+import { createIntervalSelection } from "../selection/selection.js";
+import { updateMultiPointSelection } from "../selection/selection.js";
+export { createSinglePointSelection, createMultiPointSelection, createIntervalSelection, updateMultiPointSelection };
+//# sourceMappingURL=selectionStore.d.ts.map

package/dist/src/paramRuntime/selectionStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectionStore.d.ts","sourceRoot":"","sources":["../../../src/paramRuntime/selectionStore.js"],"names":[],"mappings":"2CAKO,2BAA2B;0CAA3B,2BAA2B;wCAA3B,2BAA2B;0CAA3B,2BAA2B"}

package/dist/src/paramRuntime/selectionStore.js

@@ -0,0 +1,13 @@
+import {
+    createIntervalSelection,
+    createMultiPointSelection,
+    createSinglePointSelection,
+    updateMultiPointSelection,
+} from "../selection/selection.js";
+
+export {
+    createSinglePointSelection,
+    createMultiPointSelection,
+    createIntervalSelection,
+    updateMultiPointSelection,
+};

package/dist/src/paramRuntime/types.d.ts

@@ -0,0 +1,16 @@
+export type ParamRef<T> = {
+    id: string;
+    name: string;
+    kind: "base" | "derived" | "selection";
+    get: () => T;
+    subscribe: (listener: () => void) => () => void;
+};
+export type WritableParamRef<T> = ParamRef<T> & {
+    set: (value: T) => void;
+};
+export type ExprRefFunction = import("../utils/expression.js").ExpressionFunction & {
+    subscribe: (listener: () => void) => () => void;
+    invalidate: () => void;
+    identifier: () => string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/paramRuntime/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/paramRuntime/types.js"],"names":[],"mappings":"qBACa,CAAC,IACD;IACR,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CAAC;IACvC,GAAG,EAAE,MAAM,CAAC,CAAC;IACb,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;CAChD;6BAIS,CAAC,IACD,QAAQ,CAAC,CAAC,CAAC,GAAG;IAAE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAA;CAAE;8BAIzC,OAAO,wBAAwB,EAAE,kBAAkB,GAAG;IAC9D,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAChD,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,MAAM,CAAA;CACzB"}

package/dist/src/paramRuntime/types.js

@@ -0,0 +1,25 @@
+/**
+ * @template T
+ * @typedef {{
+ *   id: string,
+ *   name: string,
+ *   kind: "base" | "derived" | "selection",
+ *   get: () => T,
+ *   subscribe: (listener: () => void) => () => void
+ * }} ParamRef
+ */
+
+/**
+ * @template T
+ * @typedef {ParamRef<T> & { set: (value: T) => void }} WritableParamRef
+ */
+
+/**
+ * @typedef {import("../utils/expression.js").ExpressionFunction & {
+ *   subscribe: (listener: () => void) => () => void,
+ *   invalidate: () => void,
+ *   identifier: () => string
+ * }} ExprRefFunction
+ */
+
+export {};

package/dist/src/paramRuntime/viewParamRuntime.d.ts

@@ -0,0 +1,164 @@
+/**
+ * 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 {
+    /**
+     * @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?: () => ViewParamRuntime);
+    /**
+     * 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: import("../spec/parameter.js").Parameter): (value: any) => void;
+    /**
+     *
+     * @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<T>(paramName: string, initialValue: T, passive?: boolean): (value: T) => void;
+    /**
+     * 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: string, value: any): void;
+    /**
+     * Get the value of a parameter from this runtime.
+     * @param {string} paramName
+     */
+    getValue(paramName: string): any;
+    /**
+     * 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: string, listener: () => void): () => void;
+    /**
+     * Get the value of a parameter from this runtime or its ancestors.
+     * @param {string} paramName
+     */
+    findValue(paramName: string): any;
+    /**
+     * Returns configs for all parameters that have been registered using `registerParam`.
+     */
+    get paramConfigs(): ReadonlyMap<string, import("../spec/parameter.js").Parameter>;
+    /**
+     *
+     * @param {string} paramName
+     * @returns {ViewParamRuntime}
+     */
+    findRuntimeForParam(paramName: string): ViewParamRuntime;
+    /**
+     * Parse expr and return a function that returns the value of the parameter.
+     *
+     * @param {string} expr
+     */
+    createExpression(expr: string): import("./types.js").ExprRefFunction;
+    /**
+     * 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: string, listener: () => void, options?: {
+        /**
+         * 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.
+         */
+        scopeOwned?: boolean;
+        /**
+         * Optional external disposer registration hook. When provided, the
+         * unsubscribe callback is passed to this hook in addition to any
+         * scope-owned registration.
+         */
+        registerDisposer?: (disposer: () => void) => void;
+    }): ExprRefFunction;
+    /**
+     * A convenience method for evaluating an expression.
+     *
+     * @param {string} expr
+     */
+    evaluateAndGet(expr: string): any;
+    /**
+     * @template T
+     * @param {() => T} fn
+     * @returns {T}
+     */
+    runInTransaction<T>(fn: () => T): T;
+    flushNow(): void;
+    /**
+     * 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?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<void>;
+    dispose(): void;
+    /**
+     * 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(): boolean;
+    #private;
+}
+/**
+ * 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.
+ */
+export type ExprRefFunction = import("../utils/expression.js").ExpressionFunction & {
+    subscribe: (listener: () => void) => () => void;
+    invalidate: () => void;
+    identifier: () => string;
+};
+export { activateExprRefProps, getDefaultParamValue, isExprRef, isSelectionParameter, isVariableParameter, makeConstantExprRef, validateParameterName, withoutExprRef } from "./paramUtils.js";
+//# sourceMappingURL=viewParamRuntime.d.ts.map

package/dist/src/paramRuntime/viewParamRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewParamRuntime.d.ts","sourceRoot":"","sources":["../../../src/paramRuntime/viewParamRuntime.js"],"names":[],"mappings":"AAmBA;;;;;;;;GAQG;AACH;IAqCI;;;;;OAKG;IACH,2BALW,MAAM,gBAAgB,EAgBhC;IAED;;;;;;;;;;;OAWG;IACH,wEAjEqB,GAAG,KAAK,IAAI,CAyJhC;IAED;;;;;;;OAOG;IACH,eAFa,CAAC,aAJH,MAAM,gBACN,CAAC,YACD,OAAO,GACL,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAgC9B;IAED;;;;;;;;OAQG;IACH,oBAHW,MAAM,SACN,GAAG,QAWb;IAED;;;OAGG;IACH,oBAFW,MAAM,OAIhB;IAED;;;;;;;;OAQG;IACH,qBAJW,MAAM,YACN,MAAM,IAAI,GACR,MAAM,IAAI,CAiBtB;IAED;;;OAGG;IACH,qBAFW,MAAM,OAKhB;IAED;;OAEG;IACH,oBACsB,WAAW,CAAC,MAAM,2CAAY,CAGnD;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,gBAAgB,CAQ5B;IAKD;;;;OAIG;IACH,uBAFW,MAAM,wCAIhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBALW,MAAM,YACN,MAAM,IAAI;;;;;;;qBA7SX,OAAO;;;;;;2BAKP,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI;QA0S3B,eAAe,CAY3B;IA0BD;;;;OAIG;IACH,qBAFW,MAAM,OAKhB;IAED;;;;OAIG;IACH,iBAJa,CAAC,MACH,MAAM,CAAC,GACL,CAAC,CAIb;IAED,iBAEC;IAED;;;;;OAKG;IACH,yBAFW;QAAE,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,iBAItD;IAED,gBAUC;IAED;;;;;OAKG;IACH,sBAFa,OAAO,CAiBnB;;CACJ;;;;;;;;8BAhaY,OAAO,wBAAwB,EAAE,kBAAkB,GAAG;IAAE,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,MAAM,CAAA;CAAC"}