@genome-spy/core 0.48.2 → 0.49.0

package/dist/src/data/transforms/identifier.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifier.test.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/identifier.test.js"],"names":[],"mappings":""}

package/dist/src/data/transforms/pileup.test.d.ts

@@ -0,0 +1,2 @@
+export type PileupParams = import("../../spec/transform.js").PileupParams;
+//# sourceMappingURL=pileup.test.d.ts.map

package/dist/src/data/transforms/pileup.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pileup.test.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/pileup.test.js"],"names":[],"mappings":"2BAOa,OAAO,yBAAyB,EAAE,YAAY"}

package/dist/src/data/transforms/project.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project.test.d.ts.map

package/dist/src/data/transforms/project.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.test.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/project.test.js"],"names":[],"mappings":""}

package/dist/src/data/transforms/project.test.js

@@ -11,7 +11,7 @@ test("Project", () => {
         },
     ];
 
-    /** @param {import("./project.js").ProjectParams} params */
+    /** @param {import("../../spec/transform.js").ProjectParams} params */
     const p = (params) => processData(new ProjectTransform(params), data);
 
     expect(p({ type: "project", fields: ["bar"] })).toEqual([{ bar: "BAR" }]);

package/dist/src/data/transforms/regexExtract.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=regexExtract.test.d.ts.map

package/dist/src/data/transforms/regexExtract.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexExtract.test.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/regexExtract.test.js"],"names":[],"mappings":""}

package/dist/src/data/transforms/regexExtract.test.js

@@ -4,7 +4,7 @@ import { processData } from "../flowTestUtils.js";
 import RegexExtractTransform from "./regexExtract.js";
 
 /**
- * @param {import("./regexExtract.js").RegexExtractParams} params
+ * @param {import("../../spec/transform.js").RegexExtractParams} params
  * @param {any[]} data
  */
 function transform(params, data) {
@@ -12,9 +12,12 @@ function transform(params, data) {
 }
 
 describe("RegexExtractTransform", () => {
+    /**
+     * @typedef {import("../../spec/transform.js").RegexExtractParams} RegexExtractParams
+     */
     const rows = [{ a: "12-34" }, { a: "23-45" }];
 
-    /** @type {import("./regexExtract.js").RegexExtractParams} */
+    /** @type {RegexExtractParams} */
     const params = {
         type: "regexExtract",
         regex: "^(\\d+)-(\\d+)$",
@@ -30,7 +33,7 @@ describe("RegexExtractTransform", () => {
     });
 
     test("Invalid config", () => {
-        /** @type {import("./regexExtract.js").RegexExtractParams} */
+        /** @type {RegexExtractParams} */
         const config2 = {
             type: "regexExtract",
             regex: "^(\\d+)-(\\d+)$",

package/dist/src/data/transforms/regexFold.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=regexFold.test.d.ts.map

package/dist/src/data/transforms/regexFold.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexFold.test.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/regexFold.test.js"],"names":[],"mappings":""}

package/dist/src/data/transforms/sample.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sample.test.d.ts.map

package/dist/src/data/transforms/sample.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample.test.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/sample.test.js"],"names":[],"mappings":""}

package/dist/src/data/transforms/stack.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stack.test.d.ts.map

package/dist/src/data/transforms/stack.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.test.d.ts","sourceRoot":"","sources":["../../../../src/data/transforms/stack.test.js"],"names":[],"mappings":""}

package/dist/src/data/transforms/stack.test.js

@@ -8,8 +8,8 @@ const sampleData = [
     { group: "b", choice: "y", value: 3 },
 ];
 
-/** @type {import("./stack.js").StackParams} */
-const baseConf = {
+/** @type {import("../../spec/transform.js").StackParams} */
+const baseParams = {
     type: "stack",
     field: "value",
     groupby: ["group"],
@@ -23,7 +23,7 @@ const baseConf = {
 
 /**
  *
- * @param {import("./stack.js").StackParams} params
+ * @param {import("../../spec/transform.js").StackParams} params
  * @param {any[]} data
  */
 function transform(params, data) {
@@ -32,7 +32,7 @@ function transform(params, data) {
 
 describe("Stack transform", () => {
     test("No field", () => {
-        const conf = Object.assign({}, baseConf, {
+        const conf = Object.assign({}, baseParams, {
             field: undefined,
         });
 
@@ -44,7 +44,7 @@ describe("Stack transform", () => {
     });
 
     test("Zero offset", () => {
-        expect(transform(baseConf, sampleData)).toEqual([
+        expect(transform(baseParams, sampleData)).toEqual([
             { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
             { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
             { group: "b", choice: "y", value: 3, z0: 1, z1: 4 },
@@ -52,7 +52,7 @@ describe("Stack transform", () => {
     });
 
     test("Normalize offset", () => {
-        const conf = Object.assign({}, baseConf, {
+        const conf = Object.assign({}, baseParams, {
             offset: "normalize",
         });
 
@@ -64,7 +64,7 @@ describe("Stack transform", () => {
     });
 
     test("Center offset", () => {
-        const conf = Object.assign({}, baseConf, {
+        const conf = Object.assign({}, baseParams, {
             offset: "center",
         });
 
@@ -76,7 +76,7 @@ describe("Stack transform", () => {
     });
 
     test("Descending sort", () => {
-        const conf = Object.assign({}, baseConf, {
+        const conf = Object.assign({}, baseParams, {
             sort: {
                 field: "value",
                 order: "descending",

package/dist/src/encoder/accessor.d.ts

@@ -1,15 +1,18 @@
-export default class AccessorFactory {
-    /** @type {(function(import("../spec/channel.js").ChannelDef):Accessor)[]} */
-    accessorCreators: ((arg0: import("../spec/channel.js").ChannelDef) => import("../types/encoder.js").Accessor)[];
-    /**
-     *
-     * @param {function(import("../spec/channel.js").ChannelDef):Accessor} creator
-     */
-    register(creator: (arg0: import("../spec/channel.js").ChannelDef) => import("../types/encoder.js").Accessor): void;
-    /**
-     *
-     * @param {import("../spec/channel.js").ChannelDef} encoding
-     */
-    createAccessor(encoding: import("../spec/channel.js").ChannelDef): import("../types/encoder.js").Accessor;
-}
+/**
+ * @param {import("../spec/channel.js").Channel} channel
+ * @param {import("../spec/channel.js").ChannelDef | import("../spec/channel.js").Conditional<import("../spec/channel.js").ChannelDef>} channelDef
+ * @param {import("../view/paramMediator.js").default} paramMediator
+ * @returns {import("../types/encoder.js").Accessor}
+ */
+export function createAccessor(channel: import("../spec/channel.js").Channel, channelDef: import("../spec/channel.js").ChannelDef | import("../spec/channel.js").Conditional<import("../spec/channel.js").ChannelDef>, paramMediator: import("../view/paramMediator.js").default): import("../types/encoder.js").Accessor;
+/**
+ * Returns an array of acessors and their predicates. A returned array with
+ * a single element indicates that no conditions are present.
+ * The default accessor is always the last element in the array.
+ *
+ * @param {import("../spec/channel.js").Channel} channel
+ * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @param {import("../view/paramMediator.js").default} paramMediator
+ */
+export function createConditionalAccessors(channel: import("../spec/channel.js").Channel, channelDef: import("../spec/channel.js").ChannelDef, paramMediator: import("../view/paramMediator.js").default): import("../types/encoder.js").Accessor<import("../spec/channel.js").Scalar>[];
 //# sourceMappingURL=accessor.d.ts.map

package/dist/src/encoder/accessor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accessor.d.ts","sourceRoot":"","sources":["../../../src/encoder/accessor.js"],"names":[],"mappings":"AAMA;IAKQ,6EAA6E;IAC7E,0BADqB,OAAO,oBAAoB,EAAE,UAAU,+CAClC;IAkC9B;;;OAGG;IACH,yBAFoB,OAAO,oBAAoB,EAAE,UAAU,mDAI1D;IAED;;;OAGG;IACH,yBAFW,OAAO,oBAAoB,EAAE,UAAU,0CASjD;CACJ"}
+{"version":3,"file":"accessor.d.ts","sourceRoot":"","sources":["../../../src/encoder/accessor.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,wCALW,OAAO,oBAAoB,EAAE,OAAO,cACpC,OAAO,oBAAoB,EAAE,UAAU,GAAG,OAAO,oBAAoB,EAAE,WAAW,CAAC,OAAO,oBAAoB,EAAE,UAAU,CAAC,iBAC3H,OAAO,0BAA0B,EAAE,OAAO,GACxC,OAAO,qBAAqB,EAAE,QAAQ,CAyFlD;AAED;;;;;;;;GAQG;AACH,oDAJW,OAAO,oBAAoB,EAAE,OAAO,cACpC,OAAO,oBAAoB,EAAE,UAAU,iBACvC,OAAO,0BAA0B,EAAE,OAAO,iFAgCpD"}

package/dist/src/encoder/accessor.js

@@ -1,78 +1,149 @@
-import createFunction from "../utils/expression.js";
-
-import { accessorFields, constant } from "vega-util";
-import { isDatumDef, isExprDef, isFieldDef } from "./encoder.js";
+import {
+    isChannelDefWithScale,
+    isChannelWithScale,
+    isDatumDef,
+    isExprDef,
+    isFieldDef,
+    isFieldOrDatumDefWithCondition,
+    isValueDef,
+    isValueDefWithCondition,
+} from "./encoder.js";
 import { field } from "../utils/field.js";
+import { isExprRef, makeConstantExprRef } from "../view/paramMediator.js";
+import { makeSelectionTestExpression } from "../selection/selection.js";
 
-export default class AccessorFactory {
+/**
+ * @param {import("../spec/channel.js").Channel} channel
+ * @param {import("../spec/channel.js").ChannelDef | import("../spec/channel.js").Conditional<import("../spec/channel.js").ChannelDef>} channelDef
+ * @param {import("../view/paramMediator.js").default} paramMediator
+ * @returns {import("../types/encoder.js").Accessor}
+ */
+export function createAccessor(channel, channelDef, paramMediator) {
     /**
-     * @typedef {import("../types/encoder.js").Accessor} Accessor
+     * @typedef {import("../data/flowNode.js").Datum} Datum
+     * @typedef {import("../spec/channel.js").Scalar} Scalar
      */
-    constructor() {
-        /** @type {(function(import("../spec/channel.js").ChannelDef):Accessor)[]} */
-        this.accessorCreators = [];
-
-        this.register((channelDef) => {
-            if (isFieldDef(channelDef)) {
-                try {
-                    const accessor = /** @type {Accessor} */ (
-                        field(channelDef.field)
-                    );
-                    accessor.constant = false;
-                    accessor.fields = accessorFields(accessor);
-                    return accessor;
-                } catch (e) {
-                    throw new Error(`Invalid field definition: ${e.message}`);
-                }
-            }
-        });
-
-        this.register((channelDef) =>
-            isExprDef(channelDef)
-                ? createExpressionAccessor(channelDef.expr)
-                : undefined
-        );
 
-        this.register((channelDef) => {
-            if (isDatumDef(channelDef)) {
-                const c = /** @type {any} */ (constant(channelDef.datum));
-                const accessor = /** @type {Accessor} */ (c);
-                accessor.constant = true; // Can be optimized downstream
-                accessor.fields = [];
-                return accessor;
-            }
-        });
+    if (!channel) {
+        // TODO: Don't call with an undefined channel
+        return;
     }
 
     /**
-     *
-     * @param {function(import("../spec/channel.js").ChannelDef):Accessor} creator
+     * @param {(datum?: Datum) => Scalar} fn
+     * @returns {import("../types/encoder.js").Accessor<Scalar>}
      */
-    register(creator) {
-        this.accessorCreators.push(creator);
+    function asAccessor(fn) {
+        const a = /** @type {import("../types/encoder.js").Accessor} */ (fn);
+        a.fields ??= [];
+        a.constant = a.fields.length === 0;
+        a.channelDef = channelDef;
+        a.channel = channel;
+
+        a.scaleChannel =
+            ((isChannelDefWithScale(channelDef) &&
+                channelDef.resolutionChannel) ??
+                (isChannelWithScale(channel) && channel)) ||
+            undefined;
+
+        if ("param" in channelDef) {
+            a.predicate = paramMediator.createExpression(
+                makeSelectionTestExpression(channelDef)
+            );
+            a.predicate.param = channelDef.param;
+            a.predicate.empty = channelDef.empty ?? true;
+        } else {
+            a.predicate = makeConstantExprRef(true); // Always true (default accessor)
+            a.predicate.empty = false;
+        }
+
+        a.asNumberAccessor = () =>
+            /** @type {import("../types/encoder.js").Accessor<number>} */ (a);
+
+        return a;
     }
 
     /**
      *
-     * @param {import("../spec/channel.js").ChannelDef} encoding
+     * @param {Scalar | import("../spec/parameter.js").ExprRef} potentialExprRef
      */
-    createAccessor(encoding) {
-        for (const creator of this.accessorCreators) {
-            const accessor = creator(encoding);
-            if (accessor) {
-                return accessor;
+    function potentialExprRefToAccessor(potentialExprRef) {
+        if (isExprRef(potentialExprRef)) {
+            const a = asAccessor(
+                paramMediator.createExpression(potentialExprRef.expr)
+            );
+            if (a.fields.length > 0) {
+                throw new Error(
+                    "Expression in DatumDef/ValueDef cannot access data fields: " +
+                        potentialExprRef.expr
+                );
             }
+            return a;
+        } else {
+            const v = potentialExprRef;
+            return asAccessor(() => v);
         }
     }
+
+    if (isFieldDef(channelDef)) {
+        try {
+            return asAccessor(field(channelDef.field));
+        } catch (e) {
+            throw new Error(`Invalid field definition: ${e.message}`);
+        }
+    } else if (isExprDef(channelDef)) {
+        // TODO: If parameters change, the data should be re-evaluated
+        return asAccessor(paramMediator.createExpression(channelDef.expr));
+    } else if (isDatumDef(channelDef)) {
+        return potentialExprRefToAccessor(channelDef.datum);
+    } else if (isValueDef(channelDef)) {
+        return potentialExprRefToAccessor(channelDef.value);
+    } else {
+        throw new Error(
+            `Invalid channel definition: ${JSON.stringify(
+                channelDef
+            )}. Cannot create an accessor for channel ${channel}!`
+        );
+    }
 }
 
 /**
- * @param {string} expr
+ * Returns an array of acessors and their predicates. A returned array with
+ * a single element indicates that no conditions are present.
+ * The default accessor is always the last element in the array.
+ *
+ * @param {import("../spec/channel.js").Channel} channel
+ * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @param {import("../view/paramMediator.js").default} paramMediator
  */
-function createExpressionAccessor(expr) {
-    const fn = createFunction(expr);
-    const accessor = /** @type {Accessor} */ (/** @type {any} */ (fn));
-    // Not bulletproof and probably erroneous with global params
-    accessor.constant = accessor.fields.length == 0;
-    return accessor;
+export function createConditionalAccessors(channel, channelDef, paramMediator) {
+    /** @type {import("../types/encoder.js").Accessor[]} */
+    const conditionalAccessors = [];
+
+    // TODO: Support an array of conditions
+    if (
+        isFieldOrDatumDefWithCondition(channelDef) ||
+        isValueDefWithCondition(channelDef)
+    ) {
+        const conditions = Array.isArray(channelDef.condition)
+            ? channelDef.condition
+            : [channelDef.condition];
+
+        for (const condition of conditions) {
+            conditionalAccessors.push(
+                createAccessor(channel, condition, paramMediator)
+            );
+        }
+    }
+
+    conditionalAccessors.push(
+        createAccessor(channel, channelDef, paramMediator)
+    );
+
+    if (conditionalAccessors.filter((a) => !a.constant).length > 1) {
+        throw new Error(
+            "Only one accessor can be non-constant. Channel: " + channel
+        );
+    }
+    return conditionalAccessors;
 }

package/dist/src/encoder/accessor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=accessor.test.d.ts.map

package/dist/src/encoder/accessor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessor.test.d.ts","sourceRoot":"","sources":["../../../src/encoder/accessor.test.js"],"names":[],"mappings":""}

package/dist/src/encoder/accessor.test.js

@@ -1,7 +1,8 @@
-import { expect, test } from "vitest";
-import AccessorFactory from "./accessor.js";
-
-const af = new AccessorFactory();
+import { describe, expect, test } from "vitest";
+import ParamMediator from "../view/paramMediator.js";
+import { createAccessor, createConditionalAccessors } from "./accessor.js";
+import { UNIQUE_ID_KEY } from "../data/transforms/identifier.js";
+import { createSinglePointSelection } from "../selection/selection.js";
 
 const datum = {
     a: 1,
@@ -9,39 +10,152 @@ const datum = {
     "x.c": 3,
 };
 
-test("Creates a field accessor", () => {
-    const a = af.createAccessor({ field: "a" });
-    expect(a(datum)).toEqual(1);
-    expect(a.constant).toBeFalsy();
-    expect(a.fields).toEqual(["a"]);
-});
+describe("Accessors for different encoding types", () => {
+    test("Creates a field accessor", () => {
+        const a = createAccessor("x", { field: "a" }, new ParamMediator());
+        expect(a(datum)).toEqual(1);
+        expect(a.constant).toBeFalsy();
+        expect(a.fields).toEqual(["a"]);
+    });
 
-test("Creates an expression accessor", () => {
-    const a = af.createAccessor({ expr: `datum.b + datum['x\.c']` });
-    expect(a(datum)).toEqual(5);
-    expect(a.constant).toBeFalsy();
-    expect(a.fields.sort()).toEqual(["b", "x.c"].sort());
-});
+    test("Creates an expression accessor", () => {
+        const a = createAccessor(
+            "x",
+            { expr: `datum.b + datum['x\.c']` },
+            new ParamMediator()
+        );
+        expect(a(datum)).toEqual(5);
+        expect(a.constant).toBeFalsy();
+        expect(a.fields.sort()).toEqual(["b", "x.c"].sort());
+    });
+
+    test("Creates a constant accessor", () => {
+        const a = createAccessor("x", { datum: 0 }, new ParamMediator());
+        expect(a(datum)).toEqual(0);
+        expect(a.constant).toBeTruthy();
+        expect(a.fields).toEqual([]);
+    });
 
-test("Creates a constant accessor", () => {
-    const a = af.createAccessor({ datum: 0 });
-    expect(a(datum)).toEqual(0);
-    expect(a.constant).toBeTruthy();
-    expect(a.fields).toEqual([]);
+    test("Creates a value accessor", () => {
+        const a = createAccessor("x", { value: 123 }, new ParamMediator());
+        expect(a(datum)).toEqual(123);
+        expect(a.constant).toBeTruthy();
+        expect(a.fields).toEqual([]);
+    });
 });
 
-test("Returns undefined on incomplete encoding spec", () => {
-    expect(af.createAccessor({})).toBeUndefined();
+test("Throws on incomplete encoding spec", () => {
+    expect(() => createAccessor("x", {}, new ParamMediator())).toThrow();
 });
 
-test("Registers and creates a custom accessor", () => {
-    const af = new AccessorFactory();
-    af.register((encoding) => {
-        if (encoding.iddqd && encoding.idkfa) {
-            return (datum) =>
-                `${datum[encoding.iddqd]}-${datum[encoding.idkfa]}`;
-        }
+describe("createConditionalAccessors", () => {
+    const data = [
+        { a: 1, b: 2, [UNIQUE_ID_KEY]: 0 },
+        { a: 3, b: 4, [UNIQUE_ID_KEY]: 1 },
+    ];
+
+    const paramMediator = new ParamMediator();
+    paramMediator.allocateSetter("p", createSinglePointSelection(data[0]));
+
+    const a = createConditionalAccessors(
+        "x",
+        {
+            field: "a",
+            type: "quantitative",
+            condition: { param: "p", value: 123 },
+        },
+        paramMediator
+    );
+
+    const b = createConditionalAccessors(
+        "x",
+        {
+            field: "a",
+            type: "quantitative",
+            condition: [
+                { param: "p", value: 123 },
+                { param: "p", value: 234 },
+            ],
+        },
+        paramMediator
+    );
+
+    const c = createConditionalAccessors(
+        "x",
+        {
+            value: 123,
+            condition: {
+                param: "p",
+                field: "a",
+                type: "quantitative",
+            },
+        },
+        paramMediator
+    );
+
+    // TODO: Add more combinations of datum, field, expr, etc
+
+    test("Creates a correct number of accessors", () => {
+        expect(a.length).toBe(2);
+        expect(b.length).toBe(3);
+        expect(c.length).toBe(2);
+    });
+
+    // Conditional accessor
+    test("Conditional accessor accesses the correct field", () => {
+        expect(a[0](data[0])).toEqual(123);
+        expect(a[0].predicate.param).toEqual("p");
+    });
+
+    test("Conditional predicate is true only for the selected datum", () => {
+        expect(a[0].predicate(data[0])).toBeTruthy();
+        expect(a[0].predicate(data[1])).toBeFalsy();
     });
 
-    expect(af.createAccessor({ iddqd: "a", idkfa: "b" })(datum)).toEqual("1-2");
+    // Default accessor
+    test("Default accessor accesses the correct field", () => {
+        expect(a[1](data[0])).toEqual(1);
+        expect(a[1].predicate.param).toBeFalsy();
+    });
+
+    test("Default predicate is true for all data", () => {
+        expect(a[1].predicate(data[0])).toBeTruthy();
+        expect(a[1].predicate(data[1])).toBeTruthy();
+    });
+
+    test("Throws if multiple non-constant accessors are used", () => {
+        expect(() =>
+            createConditionalAccessors(
+                "x",
+                {
+                    field: "a",
+                    type: "quantitative",
+                    condition: {
+                        param: "p",
+                        // @ts-expect-error
+                        field: "b",
+                        type: "quantitative",
+                    },
+                },
+                paramMediator
+            )
+        ).toThrow();
+
+        expect(() =>
+            createConditionalAccessors(
+                "x",
+                {
+                    field: "a",
+                    type: "quantitative",
+                    condition: {
+                        param: "p",
+                        // @ts-expect-error
+                        expr: "datum.b",
+                        type: "quantitative",
+                    },
+                },
+                paramMediator
+            )
+        ).toThrow();
+    });
 });