@genome-spy/core 0.36.1 → 0.37.1

package/dist/src/view/view.test.js

@@ -0,0 +1,214 @@
+import { describe, expect, test } from "vitest";
+import UnitView from "./unitView";
+
+import { create, createAndInitialize } from "./testUtils";
+import { toRegularArray as r } from "../utils/domainArray";
+import ConcatView from "./concatView";
+import PointMark from "../marks/pointMark";
+import View from "./view";
+import LayerView from "./layerView";
+
+describe("Trivial creations and initializations", () => {
+    test("Fails on empty spec", () => {
+        // @ts-ignore
+        expect(() => create({}, View)).toThrow();
+    });
+
+    test("Parses a trivial spec", () => {
+        expect(create({ mark: "point" }, View)).toBeInstanceOf(UnitView);
+        expect(create({ layer: [] }, View)).toBeInstanceOf(LayerView);
+    });
+
+    test("Parses a more comples spec", () => {
+        const view = create(
+            {
+                concat: [
+                    {
+                        layer: [{ mark: "point" }, { mark: "rect" }],
+                    },
+                    { mark: "rect" },
+                ],
+            },
+            ConcatView
+        );
+
+        expect(view).toBeInstanceOf(ConcatView);
+        expect(view.children[0]).toBeInstanceOf(LayerView);
+        expect(view.children[0].children[0]).toBeInstanceOf(UnitView);
+        expect(view.children[0].children[0].mark).toBeInstanceOf(PointMark);
+        expect(view.children[1]).toBeInstanceOf(UnitView);
+        expect(view.children[2]).toBeUndefined();
+    });
+
+    test("Parses and initializes a trivial spec", () => {
+        const spec = {
+            data: { values: [1] },
+            mark: "point",
+            encoding: {
+                x: { field: "data", type: "quantitative" },
+                y: { field: "data", type: "quantitative" },
+            },
+        };
+
+        expect(createAndInitialize(spec, View)).resolves.toBeInstanceOf(
+            UnitView
+        );
+    });
+});
+
+describe("Test domain handling", () => {
+    const dataSpec = {
+        values: [
+            { a: 1, b: 3 },
+            { a: 2, b: 4 },
+            { a: 3, b: 5 },
+        ],
+    };
+
+    test("Uses domain from the scale properties", () => {
+        const spec = {
+            data: dataSpec,
+            mark: "point",
+            encoding: {
+                x: { field: "a", type: "quantitative" },
+                y: {
+                    field: "a",
+                    type: "quantitative",
+                    scale: { domain: [0, 1000] },
+                },
+            },
+        };
+
+        return createAndInitialize(spec, UnitView).then((view) =>
+            expect(r(view.getConfiguredDomain("y"))).toEqual([0, 1000])
+        );
+    });
+
+    test("Includes a constant in the data domain", () => {
+        const spec = {
+            data: dataSpec,
+            mark: "point",
+            encoding: {
+                x: { datum: 123, type: "quantitative" },
+                y: { field: "a", type: "quantitative" },
+            },
+        };
+
+        return createAndInitialize(spec, UnitView).then((view) =>
+            expect(r(view.extractDataDomain("x"))).toEqual([123, 123])
+        );
+    });
+
+    test("Extracts domain from the data", () => {
+        const spec = {
+            data: dataSpec,
+            mark: "point",
+            encoding: {
+                x: { field: "a", type: "quantitative" },
+                y: { field: "a", type: "quantitative" },
+            },
+        };
+
+        return createAndInitialize(spec, UnitView).then((view) =>
+            expect(r(view.extractDataDomain("y"))).toEqual([1, 3])
+        );
+    });
+
+    test("Extracts domain from the data when a secondary channel is being used", () => {
+        const spec = {
+            data: dataSpec,
+            mark: "rect",
+            encoding: {
+                x: { field: "a", type: "quantitative" },
+                y: { field: "a", type: "quantitative" },
+                y2: { field: "b", type: "quantitative" },
+            },
+        };
+
+        return createAndInitialize(spec, UnitView).then((view) =>
+            expect(r(view.extractDataDomain("y"))).toEqual([1, 5])
+        );
+    });
+});
+
+describe("Utility methods", () => {
+    test("BaseUrl is handled correctly", async () => {
+        createAndInitialize(
+            {
+                layer: [],
+            },
+            LayerView
+        ).then((view) => expect(view.getBaseUrl()).toBeUndefined());
+
+        await createAndInitialize(
+            {
+                baseUrl: "blaa",
+                layer: [],
+            },
+            LayerView
+        ).then((view) => expect(view.getBaseUrl()).toEqual("blaa"));
+
+        await createAndInitialize(
+            {
+                baseUrl: "https://site.com",
+                layer: [],
+            },
+            LayerView
+        ).then((view) => expect(view.getBaseUrl()).toEqual("https://site.com"));
+
+        await createAndInitialize(
+            {
+                baseUrl: "https://site.com",
+                layer: [
+                    {
+                        baseUrl: "blaa",
+                        layer: [],
+                    },
+                ],
+            },
+            LayerView
+        ).then((view) =>
+            expect(view.children[0].getBaseUrl()).toEqual(
+                "https://site.com/blaa"
+            )
+        );
+
+        await createAndInitialize(
+            {
+                baseUrl: "https://site.com",
+                layer: [
+                    {
+                        baseUrl: "https://another-site.com",
+                        layer: [],
+                    },
+                ],
+            },
+            LayerView
+        ).then((view) =>
+            expect(view.children[0].getBaseUrl()).toEqual(
+                "https://another-site.com"
+            )
+        );
+
+        await createAndInitialize(
+            {
+                baseUrl: "https://site.com",
+                layer: [
+                    {
+                        layer: [
+                            {
+                                baseUrl: "blaa",
+                                layer: [],
+                            },
+                        ],
+                    },
+                ],
+            },
+            LayerView
+        ).then((view) =>
+            expect(view.children[0].children[0].getBaseUrl()).toEqual(
+                "https://site.com/blaa"
+            )
+        );
+    });
+});

package/dist/src/view/viewFactory.d.ts

@@ -0,0 +1,76 @@
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is UnitSpec}
+ */
+export function isUnitSpec(spec: import("../spec/view").ViewSpec): spec is import("../spec/view").UnitSpec;
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is LayerSpec}
+ */
+export function isLayerSpec(spec: import("../spec/view").ViewSpec): spec is import("../spec/view").LayerSpec;
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is LayerSpec}
+ */
+export function isFacetSpec(spec: import("../spec/view").ViewSpec): spec is import("../spec/view").LayerSpec;
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is import("../spec/view").AggregateSamplesSpec}
+ */
+export function isAggregateSamplesSpec(spec: import("../spec/view").ViewSpec): spec is import("../spec/view").AggregateSamplesSpec;
+/**
+ *
+ * @param {object} spec
+ * @returns {spec is ImportSpec}
+ */
+export function isImportSpec(spec: object): spec is ImportSpec;
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is VConcatSpec}
+ */
+export function isVConcatSpec(spec: import("../spec/view").ViewSpec): spec is import("../spec/view").VConcatSpec;
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is HConcatSpec}
+ */
+export function isHConcatSpec(spec: import("../spec/view").ViewSpec): spec is HConcatSpec;
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is ConcatSpec}
+ */
+export function isConcatSpec(spec: import("../spec/view").ViewSpec): spec is import("../spec/view").ConcatSpec;
+export class ViewFactory {
+    /** @type {{specGuard: SpecGuard, factory: Factory}[]} */
+    types: {
+        specGuard: (spec: import("../spec/view").ViewSpec) => boolean;
+        factory: (spec: import("../spec/view").ViewSpec, context: import("../types/viewContext").default, layoutParent?: import("./containerView").default, dataParent?: import("./view").default, defaultName?: string) => View;
+    }[];
+    /**
+     * @param {SpecGuard} specGuard
+     * @param {Factory} factory
+     */
+    addViewType(specGuard: (spec: import("../spec/view").ViewSpec) => boolean, factory: (spec: import("../spec/view").ViewSpec, context: import("../types/viewContext").default, layoutParent?: import("./containerView").default, dataParent?: import("./view").default, defaultName?: string) => View): void;
+    /**
+     * @param {ViewSpec} spec
+     * @param {ViewContext} context
+     * @param {import("./containerView").default} [layoutParent]
+     * @param {import("./view").default} [dataParent]
+     * @param {string} [defaultName]
+     */
+    createView(spec: import("../spec/view").ViewSpec, context: import("../types/viewContext").default, layoutParent?: import("./containerView").default, dataParent?: import("./view").default, defaultName?: string): View;
+    /**
+     *
+     * @param {ViewSpec} spec
+     * @returns {spec is ViewSpec}
+     */
+    isViewSpec(spec: import("../spec/view").ViewSpec): spec is import("../spec/view").ViewSpec;
+}
+import View from "./view";
+//# sourceMappingURL=viewFactory.d.ts.map

package/dist/src/view/viewFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewFactory.d.ts","sourceRoot":"","sources":["../../../src/view/viewFactory.js"],"names":[],"mappings":"AAkGA;;;;GAIG;AACH,2GAEC;AAED;;;;GAIG;AACH,6GAEC;AAED;;;;GAIG;AACH,6GAOC;AAED;;;;GAIG;AACH,mIAMC;AAED;;;;GAIG;AACH,mCAHW,MAAM,sBAKhB;AAED;;;;GAIG;AACH,iHAEC;AAED;;;;GAIG;AACH,0FAEC;AAED;;;;GAIG;AACH,+GAEC;AAxKD;IAaQ,yDAAyD;IACzD;8DAL6B,OAAO;yHAC2B,OAAO,iBAAiB,EAAE,OAAO,eAAe,OAAO,QAAQ,EAAE,OAAO,gBAAgB,MAAM,KAAK,IAAI;QAIvJ;IA0BnB;;;OAGG;IACH,kEAnCiC,OAAO,mHAC2B,OAAO,iBAAiB,EAAE,OAAO,eAAe,OAAO,QAAQ,EAAE,OAAO,gBAAgB,MAAM,KAAK,IAAI,QAoCzK;IAED;;;;;;OAMG;IACH,kHAJW,OAAO,iBAAiB,EAAE,OAAO,eACjC,OAAO,QAAQ,EAAE,OAAO,gBACxB,MAAM,QAkBhB;IAED;;;;OAIG;IACH,2FAQC;CACJ;iBA/FgB,QAAQ"}

package/dist/src/view/viewFactory.js

@@ -0,0 +1,178 @@
+// eslint-disable-next-line no-unused-vars
+import View from "./view";
+
+import UnitView from "./unitView";
+import ImportView from "./importView";
+import LayerView from "./layerView";
+import ConcatView from "./concatView";
+import { isArray, isObject, isString } from "vega-util";
+
+export class ViewFactory {
+    /**
+     * @typedef {import("../types/viewContext").default} ViewContext
+     * @typedef {import("../spec/view").UnitSpec} UnitSpec
+     * @typedef {import("../spec/view").ViewSpec} ViewSpec
+     * @typedef {import("../spec/view").LayerSpec} LayerSpec
+     * @typedef {import("../spec/view").VConcatSpec} VConcatSpec
+     * @typedef {import("../spec/view").ConcatSpec} ConcatSpec
+     *
+     * @typedef {(spec: ViewSpec) => boolean} SpecGuard
+     * @typedef {(spec: ViewSpec, context: ViewContext, layoutParent?: import("./containerView").default, dataParent?: import("./view").default, defaultName?: string) => View} Factory
+     */
+    constructor() {
+        /** @type {{specGuard: SpecGuard, factory: Factory}[]} */
+        this.types = [];
+
+        const makeDefaultFactory =
+            (/** @type {typeof View} */ ViewClass) =>
+            /** @type {Factory} */
+            (spec, context, layoutParent, dataParent, defaultName) =>
+                /** @type {View} */ (
+                    new ViewClass(
+                        spec,
+                        context,
+                        layoutParent,
+                        dataParent,
+                        spec.name ?? defaultName
+                    )
+                );
+
+        // @ts-expect-error TODO: Fix typing
+        this.addViewType(isImportSpec, makeDefaultFactory(ImportView));
+        this.addViewType(isLayerSpec, makeDefaultFactory(LayerView));
+        this.addViewType(isUnitSpec, makeDefaultFactory(UnitView));
+        this.addViewType(isVConcatSpec, makeDefaultFactory(ConcatView));
+        this.addViewType(isHConcatSpec, makeDefaultFactory(ConcatView));
+        this.addViewType(isConcatSpec, makeDefaultFactory(ConcatView));
+        //this.addViewType(isFacetSpec, makeDefaultFactory(FacetView));
+    }
+
+    /**
+     * @param {SpecGuard} specGuard
+     * @param {Factory} factory
+     */
+    addViewType(specGuard, factory) {
+        this.types.push({ specGuard, factory });
+    }
+
+    /**
+     * @param {ViewSpec} spec
+     * @param {ViewContext} context
+     * @param {import("./containerView").default} [layoutParent]
+     * @param {import("./view").default} [dataParent]
+     * @param {string} [defaultName]
+     */
+    createView(spec, context, layoutParent, dataParent, defaultName) {
+        const type = this.types.find((type) => type.specGuard(spec));
+        if (type) {
+            return type.factory(
+                spec,
+                context,
+                layoutParent,
+                dataParent,
+                defaultName ?? "unnamed"
+            );
+        } else {
+            throw new Error(
+                "Invalid spec, cannot figure out the view type from the properties: " +
+                    JSON.stringify([...Object.keys(spec)])
+            );
+        }
+    }
+
+    /**
+     *
+     * @param {ViewSpec} spec
+     * @returns {spec is ViewSpec}
+     */
+    isViewSpec(spec) {
+        const matches = this.types.filter((type) => type.specGuard(spec));
+
+        if (matches.length > 1) {
+            throw new Error("Ambiguous spec. Cannot create a view!");
+        }
+
+        return matches.length == 1;
+    }
+}
+
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is UnitSpec}
+ */
+export function isUnitSpec(spec) {
+    return "mark" in spec && (isString(spec.mark) || isObject(spec.mark));
+}
+
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is LayerSpec}
+ */
+export function isLayerSpec(spec) {
+    return "layer" in spec && isObject(spec.layer);
+}
+
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is LayerSpec}
+ */
+export function isFacetSpec(spec) {
+    return (
+        "facet" in spec &&
+        isObject(spec.facet) &&
+        "spec" in spec &&
+        isObject(spec.spec)
+    );
+}
+
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is import("../spec/view").AggregateSamplesSpec}
+ */
+export function isAggregateSamplesSpec(spec) {
+    return (
+        spec &&
+        (isUnitSpec(spec) || isLayerSpec(spec)) &&
+        "aggregateSamples" in spec
+    );
+}
+
+/**
+ *
+ * @param {object} spec
+ * @returns {spec is ImportSpec}
+ */
+export function isImportSpec(spec) {
+    return "import" in spec;
+}
+
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is VConcatSpec}
+ */
+export function isVConcatSpec(spec) {
+    return "vconcat" in spec && isArray(spec.vconcat);
+}
+
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is HConcatSpec}
+ */
+export function isHConcatSpec(spec) {
+    return "hconcat" in spec && isArray(spec.hconcat);
+}
+
+/**
+ *
+ * @param {ViewSpec} spec
+ * @returns {spec is ConcatSpec}
+ */
+export function isConcatSpec(spec) {
+    return "concat" in spec && isArray(spec.concat);
+}

package/dist/src/view/viewFactory.test.js

@@ -0,0 +1,17 @@
+import { expect, test } from "vitest";
+import { ViewFactory } from "./viewFactory";
+
+test("isViewSpec", () => {
+    const factory = new ViewFactory();
+
+    // @ts-ignore
+    expect(factory.isViewSpec({})).toBeFalsy();
+
+    expect(factory.isViewSpec({ mark: "rect" })).toBeTruthy();
+    expect(factory.isViewSpec({ layer: [] })).toBeTruthy();
+    expect(factory.isViewSpec({ hconcat: [] })).toBeTruthy();
+    expect(factory.isViewSpec({ vconcat: [] })).toBeTruthy();
+    expect(factory.isViewSpec({ concat: [] })).toBeTruthy();
+
+    expect(() => factory.isViewSpec({ mark: "rect", layer: [] })).toThrow();
+});

package/dist/src/view/viewUtils.d.ts

@@ -0,0 +1,90 @@
+/**
+ *
+ * @param {import("../spec/channel").ChannelDef | import("../spec/view").FacetMapping} def
+ * @returns {spec is FacetFieldDef}
+ */
+export function isFacetFieldDef(def: import("../spec/channel").ChannelDef | import("../spec/view").FacetMapping): spec is FacetFieldDef;
+/**
+ *
+ * @param {import("../spec/channel").FacetFieldDef | import("../spec/view").FacetMapping} def
+ * @returns {spec is FacetMapping}
+ */
+export function isFacetMapping(def: import("../spec/channel").FacetFieldDef | import("../spec/view").FacetMapping): spec is FacetMapping;
+/**
+ *
+ * @param {object} config
+ * @returns {config is ImportConfig}
+ */
+export function isImportConfig(config: object): config is ImportConfig;
+/**
+ * Returns all marks in the order (DFS) they are rendered
+ * @param {View} root
+ */
+export function getMarks(root: View): import("../marks/mark").default[];
+/**
+ * Returns the nodes of the view hierarchy in depth-first order.
+ *
+ * @param {View} root
+ */
+export function getFlattenedViews(root: View): View[];
+/**
+ * @param {View} root
+ */
+export function resolveScalesAndAxes(root: View): void;
+/**
+ * Gives names to zoomable scales that have been pulled to the root. This allows
+ * the zoomed domains to be bookmarked without explicitly specifying the names.
+ * This only affects the trivial but common cases, e.g., a genome-browser-like
+ * view with a shared x scale.
+ *
+ * @param {View} root
+ */
+export function setImplicitScaleNames(root: View): void;
+/**
+ * @param {View} root
+ * @param {import("../data/dataFlow").default<View>} [existingFlow] Add data flow
+ *      graphs to an existing DataFlow object.
+ */
+export function initializeData(root: View, existingFlow?: import("../data/dataFlow").default<View>): Promise<import("../data/dataFlow").default<View>>;
+/**
+ *
+ * @param {View} view
+ */
+export function findEncodedFields(view: View): {
+    view: UnitView;
+    channel: import("../spec/channel").Channel;
+    field: import("../spec/channel").Field;
+    type: import("../spec/channel").Type;
+}[];
+/**
+ * @param {import("./view").default} viewRoot
+ */
+export function processImports(viewRoot: import("./view").default): Promise<void>;
+/**
+ * @param {function(View, View[]):void} visitor
+ */
+export function stackifyVisitor(visitor: (arg0: View, arg1: View[]) => void): import("./view").Visitor;
+/**
+ * Finds the descendants having the given name. The root is included in the search.
+ *
+ * @param {View} root
+ * @param {string} name View name
+ * @returns {View[]}
+ */
+export function findDescendantsByPath(root: View, name: string): View[];
+/**
+ *
+ * @param {View} root
+ */
+export function findUniqueViewNames(root: View): Set<string>;
+/**
+ * @param {View} viewRoot
+ */
+export function calculateCanvasSize(viewRoot: View): {
+    width: number;
+    height: number;
+};
+export function isCustomViewName(name: string): boolean;
+import View from "./view";
+import UnitView from "./unitView";
+//# sourceMappingURL=viewUtils.d.ts.map

package/dist/src/view/viewUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewUtils.d.ts","sourceRoot":"","sources":["../../../src/view/viewUtils.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,qCAHW,OAAO,iBAAiB,EAAE,UAAU,GAAG,OAAO,cAAc,EAAE,YAAY,yBAKpF;AAED;;;;GAIG;AACH,oCAHW,OAAO,iBAAiB,EAAE,aAAa,GAAG,OAAO,cAAc,EAAE,YAAY,wBAQvF;AAED;;;;GAIG;AACH,uCAHW,MAAM,0BAKhB;AAED;;;GAGG;AACH,+BAFW,IAAI,qCAMd;AAED;;;;GAIG;AACH,wCAFW,IAAI,UASd;AAED;;GAEG;AACH,2CAFW,IAAI,QA8Bd;AAED;;;;;;;GAOG;AACH,4CAFW,IAAI,QAUd;AAED;;;;GAIG;AACH,qCAJW,IAAI,iBACJ,OAAO,kBAAkB,EAAE,OAAO,CAAC,IAAI,CAAC,qDAclD;AAED;;;GAGG;AACH,wCAFW,IAAI;UAGO,QAAQ;aAAW,OAAO,iBAAiB,EAAE,OAAO;WAAS,OAAO,iBAAiB,EAAE,KAAK;UAAQ,OAAO,iBAAiB,EAAE,IAAI;IAqBvJ;AAqCD;;GAEG;AACH,yCAFW,OAAO,QAAQ,EAAE,OAAO,iBAoClC;AAED;;GAEG;AACH,gDAFoB,IAAI,QAAE,IAAI,EAAE,KAAE,IAAI,4BAkBrC;AAED;;;;;;GAMG;AACH,4CAJW,IAAI,QACJ,MAAM,GACJ,IAAI,EAAE,CAalB;AAED;;;GAGG;AACH,0CAFW,IAAI,eAqBd;AAOD;;GAEG;AACH,8CAFW,IAAI;;;EAgBd;AAnBM,uCAFI,MAAM,WAE0D;iBA5S9B,QAAQ;qBAHhC,YAAY"}