@genome-spy/core 0.48.2 → 0.49.0

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

@@ -3,20 +3,23 @@
  *
  * TODO: This method should have a test. But how to mock Mark...
  *
- * @param {import("../marks/mark.js").default} mark
- * @param {import("../spec/channel.js").Encoding} [encoding] Taken from the mark if not provided
+ * @param {import("../view/unitView.js").default} unitView
+ * @param {import("../spec/channel.js").Encoding} encoding
  * @returns {Partial<Record<Channel, Encoder>>}
  */
-export default function createEncoders(mark: import("../marks/mark.js").default, encoding?: import("../spec/channel.js").Encoding): Partial<Record<import("../spec/channel.js").Channel, import("../types/encoder.js").Encoder>>;
+export default function createEncoders(unitView: import("../view/unitView.js").default, encoding: import("../spec/channel.js").Encoding): Partial<Record<import("../spec/channel.js").Channel, import("../types/encoder.js").Encoder>>;
+/**
+ * @param {import("../types/encoder.js").Accessor[]} accessors
+ * @param {(channel: import("../spec/channel.js").ChannelWithScale) => import("../types/encoder.js").VegaScale} scaleSource
+ * @returns {Encoder}
+ */
+export function createSimpleOrConditionalEncoder(accessors: import("../types/encoder.js").Accessor[], scaleSource: (channel: import("../spec/channel.js").ChannelWithScale) => import("../types/encoder.js").VegaScale): import("../types/encoder.js").Encoder;
 /**
- * @param {import("../marks/mark.js").default} mark
- * @param {import("../spec/channel.js").ChannelDef} channelDef
- * @param {any} scale
  * @param {Accessor} accessor
- * @param {Channel} channel
+ * @param {(channel: import("../spec/channel.js").ChannelWithScale) => import("../types/encoder.js").VegaScale} scaleSource
  * @returns {Encoder}
  */
-export function createEncoder(mark: import("../marks/mark.js").default, channelDef: import("../spec/channel.js").ChannelDef, scale: any, accessor: import("../types/encoder.js").Accessor, channel: import("../spec/channel.js").Channel): import("../types/encoder.js").Encoder;
+export function createEncoder(accessor: import("../types/encoder.js").Accessor<import("../spec/channel.js").Scalar>, scaleSource: (channel: import("../spec/channel.js").ChannelWithScale) => import("../types/encoder.js").VegaScale): import("../types/encoder.js").Encoder;
 /**
  * TODO: Move to a more generic place
  *
@@ -26,14 +29,14 @@ export function createEncoder(mark: import("../marks/mark.js").default, channelD
 export function isValueDef(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").ValueDef<import("../spec/channel.js").Scalar>;
 /**
  * @param {import("../spec/channel.js").ChannelDef} channelDef
- * @returns {channelDef is import("../spec/channel.js").FieldDefBase<string>}
+ * @returns {channelDef is import("../spec/channel.js").FieldDefBase}
  */
-export function isFieldDef(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").FieldDefBase<string>;
+export function isFieldDef(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").FieldDefBase;
 /**
  * @param {import("../spec/channel.js").ChannelDef} channelDef
  * @returns {channelDef is import("../spec/channel.js").DatumDef}
  */
-export function isDatumDef(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").DatumDef;
+export function isDatumDef(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").DatumDef<import("../spec/parameter.js").ExprRef | import("../spec/channel.js").Scalar>;
 /**
  * @param {import("../spec/channel.js").ChannelDef} channelDef
  * @returns {channelDef is import("../spec/channel.js").ChannelDefWithScale}
@@ -43,7 +46,7 @@ export function isChannelDefWithScale(channelDef: import("../spec/channel.js").C
  * @param {import("../view/unitView.js").default} view
  * @param {import("../spec/channel.js").Channel} channel
  */
-export function getChannelDefWithScale(view: import("../view/unitView.js").default, channel: import("../spec/channel.js").Channel): import("../spec/channel.js").MarkPropExprDef<import("../spec/channel.js").Type> | import("../spec/channel.js").MarkPropDatumDef<import("../spec/channel.js").Type> | import("../spec/channel.js").ChromPosDef | import("../spec/channel.js").PositionDatumDef | (import("../spec/channel.js").ChromPosDefBase & import("../spec/channel.js").TitleMixins & import("../spec/channel.js").PositionMixins & import("../spec/channel.js").TypeMixins<"locus"> & import("../spec/channel.js").ScaleMixins & import("../spec/channel.js").XIndexDef) | (import("../spec/channel.js").ScaleMixins & import("../spec/channel.js").DatumDefBase & import("../spec/channel.js").TitleMixins & import("../spec/channel.js").TypeMixins<import("../spec/channel.js").Type> & import("../spec/channel.js").PositionMixins & import("../spec/channel.js").XIndexDef) | import("../spec/channel.js").MarkPropDatumDef<import("../spec/channel.js").TypeForShape> | import("../spec/channel.js").MarkPropFieldDef<string, import("../spec/channel.js").Type> | import("../spec/channel.js").PositionFieldDef<string> | (import("../spec/channel.js").FieldDefBase<string> & import("../spec/channel.js").TitleMixins & import("../spec/channel.js").TypeMixins<import("../spec/channel.js").Type> & import("../spec/channel.js").ScaleMixins & import("../spec/channel.js").PositionMixins & import("../spec/channel.js").XIndexDef) | import("../spec/channel.js").MarkPropFieldDef<string, import("../spec/channel.js").TypeForShape>;
+export function getChannelDefWithScale(view: import("../view/unitView.js").default, channel: import("../spec/channel.js").Channel): import("../spec/channel.js").FieldOrDatumDefWithCondition<import("../spec/channel.js").MarkPropFieldDef<import("../spec/channel.js").Type>, string> | import("../spec/channel.js").PositionFieldDef | import("../spec/channel.js").PositionDatumDef | import("../spec/channel.js").ChromPosDef | import("../spec/channel.js").FieldOrDatumDefWithCondition<import("../spec/channel.js").MarkPropFieldDef<import("../spec/channel.js").Type>, number> | import("../spec/channel.js").FieldOrDatumDefWithCondition<import("../spec/channel.js").MarkPropFieldDef<import("../spec/channel.js").TypeForShape>, string> | (import("../spec/channel.js").FieldDefBase & import("../spec/channel.js").TitleMixins & import("../spec/channel.js").TypeMixins<import("../spec/channel.js").Type> & import("../spec/channel.js").ScaleMixins & import("../spec/channel.js").PositionMixins & import("../spec/channel.js").XIndexDef) | (import("../spec/channel.js").ScaleMixins & import("../spec/channel.js").DatumDef<import("../spec/parameter.js").ExprRef | import("../spec/channel.js").Scalar> & import("../spec/channel.js").TypeMixins<import("../spec/channel.js").Type> & import("../spec/channel.js").PositionMixins & import("../spec/channel.js").XIndexDef) | (import("../spec/channel.js").ChromPosDefBase & import("../spec/channel.js").TitleMixins & import("../spec/channel.js").PositionMixins & import("../spec/channel.js").TypeMixins<"locus"> & import("../spec/channel.js").ScaleMixins & import("../spec/channel.js").XIndexDef);
 /**
  * @param {import("../spec/channel.js").ChannelDef} channelDef
  * @returns {channelDef is import("../spec/channel.js").TypeMixins<import("../spec/channel.js").Type>}
@@ -59,6 +62,16 @@ export function isChromPosDef(channelDef: import("../spec/channel.js").ChannelDe
  * @returns {channelDef is import("../spec/channel.js").ExprDef}
  */
 export function isExprDef(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").ExprDef;
+/**
+ * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel.js").FieldOrDatumDefWithCondition}
+ */
+export function isFieldOrDatumDefWithCondition(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").FieldOrDatumDefWithCondition<import("../spec/channel.js").FieldDef<any> | import("../spec/channel.js").DatumDef<any>, import("../spec/channel.js").Value>;
+/**
+ * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel.js").ValueDefWithCondition}
+ */
+export function isValueDefWithCondition(channelDef: import("../spec/channel.js").ChannelDef): channelDef is import("../spec/channel.js").ValueDefWithCondition<import("../spec/channel.js").Value>;
 /**
  * @param {import("../spec/channel.js").Channel} channel
  * @returns {channel is import("../spec/channel.js").PrimaryPositionalChannel}
@@ -92,7 +105,7 @@ export function getPrimaryChannel(channel: import("../spec/channel.js").Channel)
  *
  * @param {import("../spec/channel.js").Channel} channel
  */
-export function getChannelWithSecondarys(channel: import("../spec/channel.js").Channel): import("../spec/channel.js").Channel[];
+export function getChannelWithSecondarys(channel: import("../spec/channel.js").Channel): ("search" | "fill" | "stroke" | "angle" | "sample" | "color" | "fillOpacity" | "opacity" | "strokeOpacity" | "strokeWidth" | "text" | "size" | "x" | "y" | "x2" | "y2" | "shape" | "dx" | "dy" | "uniqueId" | "facetIndex" | "semanticScore")[];
 /**
  * @param {import("../spec/channel.js").Channel} channel
  */

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

@@ -1 +1 @@
-{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../../src/encoder/encoder.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,6CAJW,OAAO,kBAAkB,EAAE,OAAO,aAClC,OAAO,oBAAoB,EAAE,QAAQ,gGAuC/C;AAED;;;;;;;GAOG;AACH,oCAPW,OAAO,kBAAkB,EAAE,OAAO,cAClC,OAAO,oBAAoB,EAAE,UAAU,SACvC,GAAG,0IAqGb;AAED;;;;;GAKG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,4FAKjD;AAED;;;GAGG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,mEAKjD;AAED;;;GAGG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,uDAKjD;AAED;;;GAGG;AACH,kDAHW,OAAO,oBAAoB,EAAE,UAAU,kEAWjD;AAED;;;GAGG;AACH,6CAHW,OAAO,qBAAqB,EAAE,OAAO,WACrC,OAAO,oBAAoB,EAAE,OAAO,27CAS9C;AAED;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,UAAU,4FAKjD;AAED;;;GAGG;AACH,0CAHW,OAAO,oBAAoB,EAAE,UAAU,0DAKjD;AAED;;;GAGG;AACH,sCAHW,OAAO,oBAAoB,EAAE,UAAU,sDAKjD;AAoBD;;;GAGG;AACH,oDAHW,OAAO,oBAAoB,EAAE,OAAO,oEAM9C;AAED;;;GAGG;AACH,6CAHW,OAAO,oBAAoB,EAAE,OAAO,6DAM9C;AAqBD;;;GAGG;AACH,4CAFW,MAAM,WAIhB;AAED;;;;GAIG;AACH,oDAFW,OAAO,oBAAoB,EAAE,OAAO,2DAS9C;AAED;;;;;GAKG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,wCAI9C;AAED;;;;GAIG;AACH,kDAFW,OAAO,oBAAoB,EAAE,OAAO,0CAM9C;AAED;;GAEG;AACH,wCAFW,OAAO,oBAAoB,EAAE,OAAO,WAI9C;AAED;;;;GAIG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,WAI9C;AAED;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,OAAO,4DAuB9C;AAED;;;;;GAKG;AACH,0CAHW,OAAO,oBAAoB,EAAE,OAAO,GAClC,GAAG,EAAE,CAsBjB;AAED;;;GAGG;AACH,gDAHW,OAAO,oBAAoB,EAAE,OAAO,UACzB,GAAG,KAAE,MAAM,CAmBhC;AA7LD;;GAEG;AACH,wCAFU,OAAO,oBAAoB,EAAE,wBAAwB,EAAE,CAEb;AAEpD;;GAEG;AACH,0CAFU,OAAO,oBAAoB,EAAE,0BAA0B,EAAE,CAEX;AAExD;;GAEG;AACH,iCAFU,OAAO,oBAAoB,EAAE,iBAAiB,EAAE,CAKxD;AAoBF;;;;GAIG;AACH,gCAFU,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,0BAA0B,CAAC,CAAC,CAKtH;AAEF;;;;GAIG;AACH,8BAFU,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAInG"}
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../../src/encoder/encoder.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,iDAJW,OAAO,qBAAqB,EAAE,OAAO,YACrC,OAAO,oBAAoB,EAAE,QAAQ,gGAgC/C;AAED;;;;GAIG;AACH,4DAJW,OAAO,qBAAqB,EAAE,QAAQ,EAAE,yBAC9B,OAAO,oBAAoB,EAAE,gBAAgB,KAAK,OAAO,qBAAqB,EAAE,SAAS,yCAqC7G;AAED;;;;GAIG;AACH,4IAHqB,OAAO,oBAAoB,EAAE,gBAAgB,KAAK,OAAO,qBAAqB,EAAE,SAAS,yCAqC7G;AAED;;;;;GAKG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,4FAKjD;AAED;;;GAGG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,2DAKjD;AAED;;;GAGG;AACH,uCAHW,OAAO,oBAAoB,EAAE,UAAU,qIAKjD;AAED;;;GAGG;AACH,kDAHW,OAAO,oBAAoB,EAAE,UAAU,kEAWjD;AAED;;;GAGG;AACH,6CAHW,OAAO,qBAAqB,EAAE,OAAO,WACrC,OAAO,oBAAoB,EAAE,OAAO,s9CAS9C;AAED;;;GAGG;AACH,iDAHW,OAAO,oBAAoB,EAAE,UAAU,4FAKjD;AAED;;;GAGG;AACH,0CAHW,OAAO,oBAAoB,EAAE,UAAU,0DAKjD;AAED;;;GAGG;AACH,sCAHW,OAAO,oBAAoB,EAAE,UAAU,sDAKjD;AAED;;;GAGG;AACH,2DAHW,OAAO,oBAAoB,EAAE,UAAU,wMAQjD;AAED;;;GAGG;AACH,oDAHW,OAAO,oBAAoB,EAAE,UAAU,wGAKjD;AAoBD;;;GAGG;AACH,oDAHW,OAAO,oBAAoB,EAAE,OAAO,oEAM9C;AAED;;;GAGG;AACH,6CAHW,OAAO,oBAAoB,EAAE,OAAO,6DAM9C;AAqBD;;;GAGG;AACH,4CAFW,MAAM,WAIhB;AAED;;;;GAIG;AACH,oDAFW,OAAO,oBAAoB,EAAE,OAAO,2DAS9C;AAED;;;;;GAKG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,wCAI9C;AAED;;;;GAIG;AACH,kDAFW,OAAO,oBAAoB,EAAE,OAAO,mPAM9C;AAED;;GAEG;AACH,wCAFW,OAAO,oBAAoB,EAAE,OAAO,WAI9C;AAED;;;;GAIG;AACH,2CAFW,OAAO,oBAAoB,EAAE,OAAO,WAI9C;AAED;;;GAGG;AACH,4CAHW,OAAO,oBAAoB,EAAE,OAAO,4DAsB9C;AAED;;;;;GAKG;AACH,0CAHW,OAAO,oBAAoB,EAAE,OAAO,GAClC,GAAG,EAAE,CAsBjB;AAED;;;GAGG;AACH,gDAHW,OAAO,oBAAoB,EAAE,OAAO,UACzB,GAAG,KAAE,MAAM,CAmBhC;AA5LD;;GAEG;AACH,wCAFU,OAAO,oBAAoB,EAAE,wBAAwB,EAAE,CAEb;AAEpD;;GAEG;AACH,0CAFU,OAAO,oBAAoB,EAAE,0BAA0B,EAAE,CAEX;AAExD;;GAEG;AACH,iCAFU,OAAO,oBAAoB,EAAE,iBAAiB,EAAE,CAKxD;AAoBF;;;;GAIG;AACH,gCAFU,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,0BAA0B,CAAC,CAAC,CAKtH;AAEF;;;;GAIG;AACH,8BAFU,QAAQ,OAAO,OAAO,oBAAoB,EAAE,OAAO,EAAE,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAInG"}

package/dist/src/encoder/encoder.js

@@ -1,18 +1,15 @@
-import { isDiscrete } from "vega-scale";
-import createIndexer from "../utils/indexer.js";
-import scaleNull from "../utils/scaleNull.js";
-import { isExprRef } from "../view/paramMediator.js";
+import { createConditionalAccessors } from "./accessor.js";
 
 /**
  * Creates an object that contains encoders for every channel of a mark
  *
  * TODO: This method should have a test. But how to mock Mark...
  *
- * @param {import("../marks/mark.js").default} mark
- * @param {import("../spec/channel.js").Encoding} [encoding] Taken from the mark if not provided
+ * @param {import("../view/unitView.js").default} unitView
+ * @param {import("../spec/channel.js").Encoding} encoding
  * @returns {Partial<Record<Channel, Encoder>>}
  */
-export default function createEncoders(mark, encoding) {
+export default function createEncoders(unitView, encoding) {
     /**
      * @typedef {import("../spec/channel.js").Channel} Channel
      * @typedef {import("../types/encoder.js").Encoder} Encoder
@@ -21,29 +18,22 @@ export default function createEncoders(mark, encoding) {
     /** @type {Partial<Record<Channel, Encoder>>} */
     const encoders = {};
 
-    if (!encoding) {
-        encoding = mark.encoding;
-    }
+    const scaleSource = (
+        /** @type {import("../spec/channel.js").ChannelWithScale}*/ channel
+    ) => unitView.getScaleResolution(channel)?.scale;
 
     for (const [channel, channelDef] of Object.entries(encoding)) {
         if (!channelDef) {
             continue;
         }
 
-        const channelWithScale =
-            ((isChannelDefWithScale(channelDef) &&
-                channelDef.resolutionChannel) ??
-                (isChannelWithScale(channel) && channel)) ||
-            undefined;
-
-        const resolution = mark.unitView.getScaleResolution(channelWithScale);
-
-        encoders[channel] = createEncoder(
-            mark,
-            encoding[channel],
-            resolution?.scale,
-            mark.unitView.getAccessor(channel),
-            channel
+        encoders[channel] = createSimpleOrConditionalEncoder(
+            createConditionalAccessors(
+                channel,
+                channelDef,
+                unitView.paramMediator
+            ),
+            scaleSource
         );
     }
 
@@ -51,109 +41,85 @@ export default function createEncoders(mark, encoding) {
 }
 
 /**
- * @param {import("../marks/mark.js").default} mark
- * @param {import("../spec/channel.js").ChannelDef} channelDef
- * @param {any} scale
- * @param {Accessor} accessor
- * @param {Channel} channel
+ * @param {import("../types/encoder.js").Accessor[]} accessors
+ * @param {(channel: import("../spec/channel.js").ChannelWithScale) => import("../types/encoder.js").VegaScale} scaleSource
  * @returns {Encoder}
  */
-export function createEncoder(mark, channelDef, scale, accessor, channel) {
+export function createSimpleOrConditionalEncoder(accessors, scaleSource) {
     /**
-     * @typedef {import("../spec/channel.js").Channel} Channel
      * @typedef {import("../types/encoder.js").Encoder} Encoder
      * @typedef {import("../types/encoder.js").Accessor} Accessor
+     * @typedef {import("../data/flowNode.js").Datum} Datum
      */
+    if (accessors.length === 1) {
+        return createEncoder(accessors[0], scaleSource);
+    }
 
-    /** @type {Encoder} */
-    let encoder;
-
-    if (isValueDef(channelDef)) {
-        if (isExprRef(channelDef.value)) {
-            const fn = mark.unitView.paramMediator.createExpression(
-                channelDef.value.expr
-            );
-            encoder = /** @type {Encoder} */ ((datum) => fn(null));
-            encoder.constant = true;
-            encoder.constantValue = false;
-            encoder.accessor = accessor;
-        } else {
-            const value = channelDef.value;
-            encoder = /** @type {Encoder} */ ((datum) => value);
-            encoder.constant = true;
-            encoder.constantValue = true;
-            encoder.accessor = undefined;
-        }
-    } else if (accessor) {
-        if (channel == "text") {
-            // TODO: Define somewhere channels that don't use a scale
-            encoder = /** @type {Encoder} */ ((datum) => undefined);
-            encoder.accessor = accessor;
-            encoder.constant = accessor.constant;
-        } else {
-            if (!scale) {
-                if (!isChannelWithScale(channel)) {
-                    // Channels like uniqueId are passed as is.
-                    scale = scaleNull();
-                } else {
-                    throw new Error(
-                        `Missing scale! "${channel}": ${JSON.stringify(
-                            channelDef
-                        )}`
-                    );
+    const predicates = accessors.map((a) => a.predicate);
+
+    const encoders = accessors.map((a) => createEncoder(a, scaleSource));
+
+    const encoder = Object.assign(
+        (/** @type {Datum} */ datum) => {
+            for (let i = 0; i < encoders.length; i++) {
+                if (predicates[i](datum)) {
+                    return encoders[i](datum);
                 }
             }
+        },
+        {
+            constant: false,
+            accessors: /** @type {Accessor[]} */ (
+                encoders.map((e) => e.accessors[0])
+            ),
+            dataAccessor: encoders.map((e) => e.dataAccessor).find((a) => a),
+            scale: encoders.map((e) => e.scale).find((s) => s),
+            channelDef: accessors.at(-1).channelDef,
+        }
+    );
 
-            encoder = /** @type {Encoder} */ (
-                (datum) => scale(accessor(datum))
-            );
-
-            if (isDiscrete(scale.type)) {
-                // TODO: pass the found values back to the scale/resolution
-                const indexer = createIndexer();
-                // Warning: There's a chance that the domain and indexer get out of sync.
-                // TODO: Make this more robust
-                indexer.addAll(scale.domain());
-                encoder.indexer = indexer;
-            }
+    return encoder;
+}
 
-            encoder.constant = accessor.constant;
-            encoder.accessor = accessor;
-            encoder.scale = scale;
-        }
-    } else {
+/**
+ * @param {Accessor} accessor
+ * @param {(channel: import("../spec/channel.js").ChannelWithScale) => import("../types/encoder.js").VegaScale} scaleSource
+ * @returns {Encoder}
+ */
+export function createEncoder(accessor, scaleSource) {
+    /**
+     * @typedef {import("../types/encoder.js").Encoder} Encoder
+     * @typedef {import("../types/encoder.js").Accessor} Accessor
+     * @typedef {import("../data/flowNode.js").Datum} Datum
+     */
+
+    const { channel, scaleChannel, channelDef } = accessor;
+
+    const scale = accessor.scaleChannel ? scaleSource(scaleChannel) : undefined;
+
+    if (scaleChannel && !scale) {
         throw new Error(
-            `Missing value or accessor (field, expr, datum) on channel "${channel}": ${JSON.stringify(
-                channelDef
-            )}`
+            `Missing scale! "${channel}": ${JSON.stringify(channelDef)}`
         );
     }
 
-    // TODO: Modifier should be inverted too
-    encoder.invert = scale
-        ? (value) => scale.invert(value)
-        : (value) => {
-              throw new Error(
-                  "No scale available, cannot invert: " +
-                      JSON.stringify(channelDef)
-              );
-          };
-
-    // Just to provide a convenient access to the config
-    encoder.channelDef = channelDef;
-
-    /** @param {Encoder} target */
-    encoder.applyMetadata = (target) => {
-        for (const prop in encoder) {
-            if (prop in encoder) {
-                // @ts-ignore
-                target[prop] = encoder[prop];
-            }
+    return Object.assign(
+        scale
+            ? (/** @type {Datum} */ datum) =>
+                  scale(
+                      // @ts-ignore Bad d3 types
+                      accessor(datum)
+                  )
+            : (/** @type {Datum} */ datum) => accessor(datum),
+        {
+            scale,
+            constant: accessor.constant,
+            accessors: [accessor],
+            dataAccessor: accessor.constant ? undefined : accessor,
+            // TODO: Accessor already has the channelDef
+            channelDef,
         }
-        return target;
-    };
-
-    return encoder;
+    );
 }
 
 /**
@@ -168,7 +134,7 @@ export function isValueDef(channelDef) {
 
 /**
  * @param {import("../spec/channel.js").ChannelDef} channelDef
- * @returns {channelDef is import("../spec/channel.js").FieldDefBase<string>}
+ * @returns {channelDef is import("../spec/channel.js").FieldDefBase}
  */
 export function isFieldDef(channelDef) {
     return channelDef && "field" in channelDef;
@@ -233,6 +199,25 @@ export function isExprDef(channelDef) {
     return channelDef && "expr" in channelDef;
 }
 
+/**
+ * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel.js").FieldOrDatumDefWithCondition}
+ */
+export function isFieldOrDatumDefWithCondition(channelDef) {
+    return (
+        (isFieldDef(channelDef) || isDatumDef(channelDef)) &&
+        "condition" in channelDef
+    );
+}
+
+/**
+ * @param {import("../spec/channel.js").ChannelDef} channelDef
+ * @returns {channelDef is import("../spec/channel.js").ValueDefWithCondition}
+ */
+export function isValueDefWithCondition(channelDef) {
+    return isValueDef(channelDef) && "condition" in channelDef;
+}
+
 /**
  * @type {import("../spec/channel.js").PrimaryPositionalChannel[]}
  */
@@ -344,7 +329,7 @@ export function isColorChannel(channel) {
  * @param {import("../spec/channel.js").Channel} channel
  */
 export function isDiscreteChannel(channel) {
-    return ["shape", "squeeze"].includes(channel);
+    return ["shape"].includes(channel);
 }
 
 /**
@@ -369,7 +354,6 @@ export function isChannelWithScale(channel) {
         "angle",
         "dx",
         "dy",
-        "sample",
     ].includes(channel);
 }
 

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

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

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

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

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

@@ -1,101 +1,104 @@
 import { describe, expect, test } from "vitest";
-import AccessorFactory from "./accessor.js";
-import { scale as vegaScale } from "vega-scale";
 
-import { createEncoder } from "./encoder.js";
-
-describe("Encoder", () => {
-    /** @type {Record<string, import("../view/viewUtils.js").ChannelDef>} */
-    const encodingSpecs = {
-        x: { value: 0 },
-        y: { field: "a" },
-        z: { datum: 2 },
-        size: { value: 5 },
-    };
-
-    const scaleLinear = vegaScale("linear");
-
-    /** @type {Record<string, import("./encoder.js").VegaScale>} */
-    const scales = {
-        y: scaleLinear().domain([0, 10]),
-        z: scaleLinear().domain([0, 20]),
-    };
-
-    const accessorFactory = new AccessorFactory();
-
-    /** @param {Record<string, import("../view/viewUtils.js").ChannelDef>} encoding */
-    function createEncoders(encoding) {
-        /** @type {Record<string, import("./encoder.js").Encoder>} */
-        const encoders = {};
-        for (const [channel, channelDef] of Object.entries(encoding)) {
-            encoders[channel] = createEncoder(
-                null, // TODO: stub the mark
-                channelDef,
-                scales[channel],
-                accessorFactory.createAccessor(encodingSpecs[channel]),
-                channel
-            );
+import { createAccessor, createConditionalAccessors } from "./accessor.js";
+import ParamMediator from "../view/paramMediator.js";
+import { createEncoder, createSimpleOrConditionalEncoder } from "./encoder.js";
+import { UNIQUE_ID_KEY } from "../data/transforms/identifier.js";
+import { createSinglePointSelection } from "../selection/selection.js";
+import { isArray } from "vega-util";
+import { scaleLinear } from "d3-scale";
+
+/** @type {import("../spec/channel.js").Encoding} */
+const encoding = {
+    x: { value: 42 },
+    y: {
+        field: "a",
+        type: "quantitative",
+        scale: { domain: [0, 100], range: [0, 1] },
+    },
+    size: {
+        field: "a",
+        type: "quantitative",
+        scale: { domain: [0, 100], range: [0, 10] },
+        condition: {
+            param: "p",
+            empty: false,
+            value: 5000,
+        },
+    },
+};
+
+const scaleSource = (
+    /** @type {import("../spec/channel.js").ChannelWithScale} */ channel
+) => {
+    // @ts-ignore
+    const props = encoding[channel].scale ?? encoding[channel].condition?.scale;
+
+    return Object.assign(
+        scaleLinear().domain(props.domain).range(props.range),
+        {
+            type: "linear",
         }
-        return encoders;
-    }
+    );
+};
 
-    const datum = {
-        a: 5,
-        b: 6,
-        c: "Pink Floyd",
-    };
+const datum = {
+    a: 100,
+    b: 6,
+    c: "Pink Floyd",
+    [UNIQUE_ID_KEY]: 1234,
+};
 
-    test("Throws on a broken spec", () =>
-        expect(() => createEncoders({ x: {} })).toThrow());
+describe("Encoder", () => {
+    const pm = new ParamMediator();
+    /** @type {Partial<Record<import("../spec/channel.js").Channel, import("../types/encoder.js").Encoder>>} */
+    const e = Object.fromEntries(
+        Object.entries(encoding).map(([channel, channelDef]) => {
+            const accessor = createAccessor(channel, channelDef, pm);
+            return [channel, createEncoder(accessor, scaleSource)];
+        })
+    );
+
+    test("has a single accessors", () => {
+        expect(e.x.accessors?.length).toBe(1);
+    });
 
-    const encoders = createEncoders(encodingSpecs);
+    test("provides a data accessor for a FieldDef", () =>
+        expect(e.y.dataAccessor.fields).toContain("a"));
 
-    test("The encoder object contains all channels", () =>
-        expect(
-            ["x", "y", "z", "size"].every(
-                (channel) => typeof encoders[channel] === "function"
-            )
-        ).toBeTruthy());
+    test("doesn't provide a data accessor for a ValueDef", () =>
+        expect(e.x.dataAccessor).toBeUndefined());
 
-    test("Returns a value", () => expect(encoders.x(datum)).toEqual(0));
+    test("returns a value", () => expect(e.x(datum)).toEqual(42));
 
-    test("Encodes and returns a constant using a scale", () =>
-        expect(encoders.z(datum)).toBeCloseTo(0.1));
+    test("accesses a field and uses a scale", () => expect(e.y(datum)).toBe(1));
 
-    test("Accesses a field and uses a scale", () =>
-        expect(encoders.y(datum)).toBeCloseTo(0.5));
+    // TODO: Text ExprRef
+});
 
-    /*
-    test("Accesses a field on a secondary channel and uses the scale from the primary", () =>
-        expect(encoders.y2(datum)).toBeCloseTo(0.6));
-        */
+describe("Conditional encoder with a field and a conditional value", () => {
+    const pm = new ParamMediator();
+    const setter = pm.allocateSetter("p", createSinglePointSelection(null));
 
-    test("Constant encoder is annotated", () => {
-        expect(encoders.y.constant).toBeFalsy();
-        expect(encoders.z.constant).toBeTruthy();
-        expect(encoders.size.constant).toBeTruthy();
-    });
+    const e = createSimpleOrConditionalEncoder(
+        createConditionalAccessors("size", encoding.size, pm),
+        scaleSource
+    );
 
-    test("Constant value encoder is annotated", () => {
-        expect(encoders.y.constantValue).toBeFalsy();
-        expect(encoders.z.constantValue).toBeFalsy();
-        expect(encoders.size.constantValue).toBeTruthy();
+    test("has multiple accessors", () => {
+        expect(e.accessors.length).toBe(2);
     });
 
-    test("Inverts a value", () => {
-        expect(encoders.y.invert(0.5)).toBeCloseTo(5);
-        expect(encoders.z.invert(0.5)).toBeCloseTo(10);
-        // A value, no scale, can't invert
-        expect(() => encoders.size.invert(123)).toThrow();
-    });
+    test("accesses the field using the dataAccessor", () =>
+        expect(e.dataAccessor(datum)).toBe(100));
 
-    test("Accessors are provided", () => {
-        expect(encoders.y.accessor).toBeDefined();
-        expect(encoders.z.accessor).toBeDefined();
-        expect(encoders.x.accessor).toBeUndefined();
+    test("encodes the default when a predicate is false", () => {
+        setter(createSinglePointSelection(null));
+        expect(e(datum)).toBe(10);
     });
 
-    // TODO: Test indexer
-
-    // TODO: Text ExprRef
+    test("encodes the conditional value when a predicate is true", () => {
+        setter(createSinglePointSelection(datum));
+        expect(e(datum)).toBe(5000);
+    });
 });

package/dist/src/fonts/bmFontManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bmFontManager.d.ts","sourceRoot":"","sources":["../../../src/fonts/bmFontManager.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACI;;OAEG;IACH,0BAFW,OAAO,sBAAsB,EAAE,OAAO,EAgChD;IA7BG,qDAA+B;IAE/B,uBACiF;IAEjF;;OAEG;IACH,QAFU,IAAI,OAAO,EAAE,SAAS,CAAC,CAEc;IAE/C,8DAA8D;IAC9D,mBADW,IAAI,MAAM,EAAE,QAAQ,uBAAuB,EAAE,CAAC,CAAC,CACxB;IAElC,kDAAkD;IAClD,eADW,IAAI,MAAM,EAAE,QAAQ,aAAa,CAAC,CAAC,CAChB;IAE9B,uEAAuE;IACvE,WADW,QAAQ,IAAI,CAAC,EAAE,CACP;IAEnB;;;OAGG;IACH,mBAFU,SAAS,CAOlB;IAGL,gCAEC;IAED;;;;;;OAMG;IACH,gBALW,MAAM,UACN,SAAS,WACT,UAAU,GAAG;;;;;;;;KAAa,GACxB,SAAS,CAyBrB;IAED;;;;OAIG;IACH,0BAHW,SAAS,OACT,OAAO,iBAwBjB;IAED;;OAEG;IACH,eAFW,MAAM,uDAoBhB;IAED;;;OAGG;IACH,sBAFW,MAAM,sCA2BhB;IAED,4BAEC;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,QAAQ,YAAY,CAAC,CAqBjC;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,YAAY,CA0BxB;CACJ;;;;;;;;;;UAgBS,MAAM;;;;WACN,MAAM;;;;YACN,MAAM;;;;cACN,MAAM;;;;sBACN,MAAM;;;;eACN,MAAM;;;;eACN,MAAM;;;;;;;;;qBA5PH,OAAO,oBAAoB,EAAE,MAAM;;;;;;;;4BACnC,OAAO,oBAAoB,EAAE,aAAa;;;;;;;;wBAE1C,QAAQ,GAAG,QAAQ;;;;;;;;yBACnB,MAAM;;;;;;;;;YAGT,MAAM;WACN,SAAS;YACT,UAAU;;;;;;;;;;aAGV,aAAa;aACb,YAAY"}
+{"version":3,"file":"bmFontManager.d.ts","sourceRoot":"","sources":["../../../src/fonts/bmFontManager.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACI;;OAEG;IACH,0BAFW,OAAO,sBAAsB,EAAE,OAAO,EAgChD;IA7BG,qDAA+B;IAE/B,uBACiF;IAEjF;;OAEG;IACH,QAFU,IAAI,OAAO,EAAE,SAAS,CAAC,CAEc;IAE/C,8DAA8D;IAC9D,mBADW,IAAI,MAAM,EAAE,QAAQ,uBAAuB,EAAE,CAAC,CAAC,CACxB;IAElC,kDAAkD;IAClD,eADW,IAAI,MAAM,EAAE,QAAQ,aAAa,CAAC,CAAC,CAChB;IAE9B,uEAAuE;IACvE,WADW,QAAQ,IAAI,CAAC,EAAE,CACP;IAEnB;;;OAGG;IACH,mBAFU,SAAS,CAOlB;IAGL,gCAEC;IAED;;;;;;OAMG;IACH,gBALW,MAAM,UACN,SAAS,WACT,UAAU,GAAG;;;;;;;;KAAa,GACxB,SAAS,CAyBrB;IAED;;;;OAIG;IACH,0BAHW,SAAS,OACT,OAAO,iBA0BjB;IAED;;OAEG;IACH,eAFW,MAAM,uDAoBhB;IAED;;;OAGG;IACH,sBAFW,MAAM,sCA+BhB;IAED,4BAEC;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,QAAQ,YAAY,CAAC,CAqBjC;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,YAAY,CA0BxB;CACJ;;;;;;;;;;UAgBS,MAAM;;;;WACN,MAAM;;;;YACN,MAAM;;;;cACN,MAAM;;;;sBACN,MAAM;;;;eACN,MAAM;;;;eACN,MAAM;;;;;;;;;qBAlQH,OAAO,oBAAoB,EAAE,MAAM;;;;;;;;4BACnC,OAAO,oBAAoB,EAAE,aAAa;;;;;;;;wBAE1C,QAAQ,GAAG,QAAQ;;;;;;;;yBACnB,MAAM;;;;;;;;;YAGT,MAAM;WACN,SAAS;YACT,UAAU;;;;;;;;;;aAGV,aAAa;aACb,YAAY"}

package/dist/src/fonts/bmFontManager.js

@@ -132,7 +132,9 @@ export default class BmFontManager {
             fontEntry.texture = await texturePromise;
             fontEntry.metrics = await metricsPromise;
         } catch (error) {
-            console.log("Cannot load font. Using default.", error);
+            console.warn(
+                `Cannot load font: "${key.family}". Using the embedded default font.`
+            );
 
             fontEntry.metrics = this._defaultFontEntry.metrics;
             fontEntry.texture = this._defaultFontEntry.texture;
@@ -171,11 +173,15 @@ export default class BmFontManager {
 
         let promise = this._metadataPromises.get(dir);
         if (!promise) {
-            promise = fetch(this.fontRepository + dir + "/METADATA.pb")
+            const url = this.fontRepository + dir + "/METADATA.pb";
+            promise = fetch(url)
                 .then((response) => {
                     if (!response.ok) {
                         throw new Error(
-                            "Could not load font metadata: " + response.status
+                            "Could not load font metadata. Response status: " +
+                                response.status +
+                                ", url: " +
+                                url
                         );
                     }
                     return response;
@@ -183,7 +189,7 @@ export default class BmFontManager {
                 .then((response) => response.text())
                 .then((text) => parseMetadataPb(text))
                 .catch((error) => {
-                    console.warn(error);
+                    console.warn(error.message);
                     return undefined;
                 });
 

package/dist/src/genome/genome.test.d.ts

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

package/dist/src/genome/genome.test.d.ts.map

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