@genome-spy/core 0.48.1 → 0.49.0

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":""}

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

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

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

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

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

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

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

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

package/dist/src/genomeSpy.d.ts

@@ -18,7 +18,6 @@ export default class GenomeSpy {
     _destructionCallbacks: (() => void)[];
     /** Root level configuration object */
     spec: import("./spec/root.js").RootSpec;
-    accessorFactory: AccessorFactory;
     viewFactory: ViewFactory;
     /** @type {(function(string):object[])[]} */
     namedDataProviders: ((arg0: string) => object[])[];
@@ -83,6 +82,8 @@ export default class GenomeSpy {
      * @type {HTMLElement}
      */
     _inputBindingContainer: HTMLElement;
+    /** @type {Point} */
+    _mouseDownCoords: Point;
     /**
      *
      * @param {(name: string) => any[]} provider
@@ -151,12 +152,12 @@ export default class GenomeSpy {
  * Events that are broadcasted to all views.
  */
 export type BroadcastEventType = "dataFlowBuilt" | "dataLoaded" | "layout" | "layoutComputed";
-import AccessorFactory from "./encoder/accessor.js";
 import { ViewFactory } from "./view/viewFactory.js";
 import Animator from "./utils/animator.js";
 import GenomeStore from "./genome/genomeStore.js";
 import BufferedViewRenderingContext from "./view/renderingContext/bufferedViewRenderingContext.js";
 import Inertia from "./utils/inertia.js";
+import Point from "./view/layout/point.js";
 import WebGLHelper from "./gl/webGLHelper.js";
 import Tooltip from "./utils/ui/tooltip.js";
 import UnitView from "./view/unitView.js";

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

@@ -1 +1 @@
-{"version":3,"file":"genomeSpy.d.ts","sourceRoot":"","sources":["../../src/genomeSpy.js"],"names":[],"mappings":"AA+CA;IACI;;;;;OAKG;IAEH;;;;;OAKG;IACH,uBAJW,WAAW,qDAEX,OAAO,qBAAqB,EAAE,YAAY,EA2FpD;IAxFG,uBAA0B;IAC1B,oDAAsB;IAItB,6BAA6B;IAC7B,uBADW,CAAC,MAAM,IAAI,CAAC,EAAE,CACM;IAE/B,sCAAsC;IACtC,wCAAgB;IAEhB,iCAA4C;IAC5C,yBAAoC;IAEpC,4CAA4C;IAC5C,oBADW,QAAU,MAAM,KAAE,MAAM,EAAE,CAAC,EAAE,CACZ;IAE5B,mBAAoD;IAEpD,0BAA0B;IAC1B,aADW,WAAW,CACM;IAE5B;;;;;OAKG;IACH,qEAF0B,OAAO,CAE8B;IAE/D,2CAA2C;IAC3C,mBADW,4BAA4B,CACL;IAClC,2CAA2C;IAC3C,iBADW,4BAA4B,CACP;IAEhC,oDAAoD;IACpD,6BAAgC;IAEhC;;;OAGG;IACH,eAFU;QAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,oBAAoB,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAEpF;IAE9B,uBAA+C;IAE/C;;;OAGG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAU,aAAa,KAAE,IAAI,CAAC,EAAE,CAAC,CAEpB;IAEnC;;;;;;OAMG;IACH,yCAFkC,GAAG,KAAK,IAAI,GAEd;IAEhC;;;OAGG;IACH,kDAFkC,GAAG,KAAK,IAAI,GAEL;IAEzC,oFAAoF;IACpF,iBADW,OAAO,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,CAK9E;IAED,mBAAmB;IACnB,2CAAyB;IAEzB;;;;OAIG;IACH;gBAF8B,OAAO,wBAAwB,EAAE,iBAAiB;iBAAW,MAAM;OAEnE;IAE9B;;OAEG;IACH,wBAFU,WAAW,CAEkB;IA2C3C;;;OAGG;IACH,2CAFkB,MAAM,KAAK,GAAG,EAAE,QAIjC;IAED;;OAEG;IACH,+BAFW,MAAM,YAShB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QACN,GAAG,EAAE,QAaf;IAED;;;;;OAKG;IACH,gBAHW,kBAAkB,YAClB,GAAG,QAQb;IAED;;;OAGG;IACH,iCAqDC;IA0DG,uBAQC;IAGD,mCAGE;IAOF,sCAEE;IAGF,iBAAyC;IAW7C;;OAEG;IACH,gBAuBC;IAED,sCA8MC;IAED;;;OAGG;IACH,UAFa,QAAQ,OAAO,CAAC,CA6B5B;IAED,4BAqJC;IA9He,iCAAoC;IAgIpD;;;OAGG;IACH,kBAHW,MAAM,KACN,MAAM,QAsEhB;IAED;;;;;;;OAOG;IACH,oDAHuB,QAAQ,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAYlF;IAED,sBA6CC;IAED,kBAIC;IAED,iCAOC;IAED,iCASC;IAED,qFAWC;;CACJ;;;;iCAx7BY,eAAe,GAAG,YAAY,GAAG,QAAQ,GAAG,gBAAgB;4BAlC7C,uBAAuB;4BA2BP,uBAAuB;qBAZ9C,qBAAqB;wBAIlB,yBAAyB;yCARR,yDAAyD;oBAYvD,oBAAoB;wBAdvC,qBAAqB;oBAXzB,uBAAuB;qBAStB,oBAAoB"}
+{"version":3,"file":"genomeSpy.d.ts","sourceRoot":"","sources":["../../src/genomeSpy.js"],"names":[],"mappings":"AA8CA;IACI;;;;;OAKG;IAEH;;;;;OAKG;IACH,uBAJW,WAAW,qDAEX,OAAO,qBAAqB,EAAE,YAAY,EA6FpD;IA1FG,uBAA0B;IAC1B,oDAAsB;IAItB,6BAA6B;IAC7B,uBADW,CAAC,MAAM,IAAI,CAAC,EAAE,CACM;IAE/B,sCAAsC;IACtC,wCAAgB;IAEhB,yBAAoC;IAEpC,4CAA4C;IAC5C,oBADW,QAAU,MAAM,KAAE,MAAM,EAAE,CAAC,EAAE,CACZ;IAE5B,mBAAoD;IAEpD,0BAA0B;IAC1B,aADW,WAAW,CACM;IAE5B;;;;;OAKG;IACH,qEAF0B,OAAO,CAE8B;IAE/D,2CAA2C;IAC3C,mBADW,4BAA4B,CACL;IAClC,2CAA2C;IAC3C,iBADW,4BAA4B,CACP;IAEhC,oDAAoD;IACpD,6BAAgC;IAEhC;;;OAGG;IACH,eAFU;QAAE,IAAI,EAAE,OAAO,iBAAiB,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,oBAAoB,EAAE,KAAK,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAEpF;IAE9B,uBAA+C;IAE/C;;;OAGG;IACH,oBAFU,IAAI,MAAM,EAAE,QAAU,aAAa,KAAE,IAAI,CAAC,EAAE,CAAC,CAEpB;IAEnC;;;;;;OAMG;IACH,yCAFkC,GAAG,KAAK,IAAI,GAEd;IAEhC;;;OAGG;IACH,kDAFkC,GAAG,KAAK,IAAI,GAEL;IAEzC,oFAAoF;IACpF,iBADW,OAAO,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC,CAK9E;IAED,mBAAmB;IACnB,2CAAyB;IAEzB;;;;OAIG;IACH;gBAF8B,OAAO,wBAAwB,EAAE,iBAAiB;iBAAW,MAAM;OAEnE;IAE9B;;OAEG;IACH,wBAFU,WAAW,CAEkB;IAEvC,oBAAoB;IACpB,kBADW,KAAK,CACiB;IA2CrC;;;OAGG;IACH,2CAFkB,MAAM,KAAK,GAAG,EAAE,QAIjC;IAED;;OAEG;IACH,+BAFW,MAAM,YAShB;IAED;;;;OAIG;IACH,sBAHW,MAAM,QACN,GAAG,EAAE,QAaf;IAED;;;;;OAKG;IACH,gBAHW,kBAAkB,YAClB,GAAG,QAQb;IAED;;;OAGG;IACH,iCAqDC;IA0DG,uBAQC;IAGD,mCAGE;IAOF,sCAEE;IAGF,iBAAyC;IAW7C;;OAEG;IACH,gBAuBC;IAED,sCA6MC;IAED;;;OAGG;IACH,UAFa,QAAQ,OAAO,CAAC,CA6B5B;IAED,4BA8JC;IAvIe,iCAAoC;IAyIpD;;;OAGG;IACH,kBAHW,MAAM,KACN,MAAM,QAqEhB;IAED;;;;;;;OAOG;IACH,oDAHuB,QAAQ,MAAM,GAAG,WAAW,GAAG,OAAO,KAAK,EAAE,cAAc,CAAC,QAYlF;IAED,sBA6CC;IAED,kBAIC;IAED,iCAOC;IAED,iCASC;IAED,qFAWC;;CACJ;;;;iCAj8BY,eAAe,GAAG,YAAY,GAAG,QAAQ,GAAG,gBAAgB;4BAP7B,uBAAuB;qBAZ9C,qBAAqB;wBAIlB,yBAAyB;yCARR,yDAAyD;oBAYvD,oBAAoB;kBAT7C,wBAAwB;wBALlB,qBAAqB;oBAVzB,uBAAuB;qBAQtB,oBAAoB"}