@genome-spy/core 0.36.1 → 0.37.1

package/dist/src/view/concatView.js

@@ -0,0 +1,84 @@
+import { isConcatSpec, isHConcatSpec, isVConcatSpec } from "./viewFactory";
+import GridView from "./gridView";
+
+/**
+ * Creates a vertically or horizontally concatenated layout for children.
+ */
+export default class ConcatView extends GridView {
+    /**
+     *
+     * @param {import("../spec/view").AnyConcatSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {import("./containerView").default} layoutParent
+     * @param {import("./view").default} dataParent
+     * @param {string} name
+     */
+    constructor(spec, context, layoutParent, dataParent, name) {
+        super(
+            spec,
+            context,
+            layoutParent,
+            dataParent,
+            name,
+            isConcatSpec(spec)
+                ? spec.columns
+                : isVConcatSpec(spec)
+                ? 1
+                : Infinity
+        );
+
+        this.spec = spec;
+    }
+
+    _createChildren() {
+        const spec = this.spec;
+        const childSpecs = isConcatSpec(spec)
+            ? spec.concat
+            : isVConcatSpec(spec)
+            ? spec.vconcat
+            : spec.hconcat;
+
+        this.setChildren(
+            childSpecs.map((childSpec, i) =>
+                // @ts-expect-error TODO: Fix typing
+                this.context.createView(childSpec, this, this, "grid" + i)
+            )
+        );
+    }
+
+    /**
+     * @param {import("../spec/channel").Channel} channel
+     * @param {import("../spec/view").ResolutionTarget} resolutionType
+     * @returns {import("../spec/view").ResolutionBehavior}
+     */
+    getDefaultResolution(channel, resolutionType) {
+        if (resolutionType == "axis") {
+            return "independent";
+        }
+
+        // Consider a typical uses case: a view that resembles a genome browser with multiple
+        // tracks displaying/ genomic or protein coordinates. In these cases, the default
+        // resolution for stacked tracks should be "shared".
+        // For others, it should be "independent" to provide better compatibility with Vega-Lite.
+
+        if (
+            (isVConcatSpec(this.spec) && channel === "x") ||
+            (isHConcatSpec(this.spec) && channel === "y")
+        ) {
+            const types = new Set(
+                this.children
+                    .map((child) => child.getEncoding()[channel])
+                    .filter((x) => x)
+                    .map((e) => "type" in e && e.type)
+                    .filter((type) => type)
+            );
+
+            return types.size === 1 &&
+                (types.has("index") || types.has("locus"))
+                ? "shared"
+                : "independent";
+        } else {
+            return "independent";
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+/**
+ * Compositor view represents a non-leaf node in the view hierarchy.
+ */
+export default class ContainerView extends View {
+    /**
+     *
+     * @param {import("../spec/view").ContainerSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {ContainerView} layoutParent
+     * @param {import("./view").default} dataParent
+     * @param {string} name
+     */
+    constructor(spec: import("../spec/view").ContainerSpec, context: import("../types/viewContext").default, layoutParent: ContainerView, dataParent: import("./view").default, name: string);
+    spec: import("../spec/view").ContainerSpec;
+    /**
+     * Replaces a child view with another one. Does not alter the old or new child.
+     *
+     * @param {import("./view").default} child
+     * @param {import("./view").default} replacement
+     */
+    replaceChild(child: import("./view").default, replacement: import("./view").default): void;
+    /**
+     * @param {string[]} path An array of view names
+     * @returns {View}
+     */
+    findDescendantByPath(path: string[]): View;
+    /**
+     *
+     * @param {string} name
+     */
+    findChildByName(name: string): View;
+    /**
+     *
+     * @param {string} name
+     */
+    findDescendantByName(name: string): View;
+    /**
+     * @returns {IterableIterator<View>}
+     */
+    [Symbol.iterator](): IterableIterator<View>;
+}
+import View from "./view";
+//# sourceMappingURL=containerView.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"containerView.d.ts","sourceRoot":"","sources":["../../../src/view/containerView.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI;;;;;;;OAOG;IACH,kBANW,OAAO,cAAc,EAAE,aAAa,WACpC,OAAO,sBAAsB,EAAE,OAAO,gBACtC,aAAa,cACb,OAAO,QAAQ,EAAE,OAAO,QACxB,MAAM,EAMhB;IADG,2CAAgB;IAUpB;;;;;OAKG;IACH,oBAHW,OAAO,QAAQ,EAAE,OAAO,eACxB,OAAO,QAAQ,EAAE,OAAO,QAIlC;IA+CD;;;OAGG;IACH,2BAHW,MAAM,EAAE,GACN,IAAI,CAYhB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAchB;IA1GD;;OAEG;IACH,qBAFa,iBAAiB,IAAI,CAAC,CAIlC;CA+GJ;iBAxI4C,QAAQ"}

package/dist/src/view/containerView.js

@@ -0,0 +1,137 @@
+import View, { VISIT_STOP, VISIT_SKIP } from "./view";
+
+/**
+ * Compositor view represents a non-leaf node in the view hierarchy.
+ */
+export default class ContainerView extends View {
+    /**
+     *
+     * @param {import("../spec/view").ContainerSpec} spec
+     * @param {import("../types/viewContext").default} context
+     * @param {ContainerView} layoutParent
+     * @param {import("./view").default} dataParent
+     * @param {string} name
+     */
+    constructor(spec, context, layoutParent, dataParent, name) {
+        super(spec, context, layoutParent, dataParent, name);
+
+        this.spec = spec;
+    }
+
+    /**
+     * @returns {IterableIterator<View>}
+     */
+    *[Symbol.iterator]() {
+        // override
+    }
+
+    /**
+     * Replaces a child view with another one. Does not alter the old or new child.
+     *
+     * @param {import("./view").default} child
+     * @param {import("./view").default} replacement
+     */
+    replaceChild(child, replacement) {
+        throw new Error("Not implemented");
+    }
+
+    /**
+     * Visits child views in depth-first pre-order. Terminates the search and returns
+     * the value if the visitor returns a defined value. The `afterChildren` callback
+     * allows for post-order traversal
+     *
+     * @param {import("./view").Visitor} visitor
+     * @returns {import("./view").VisitResult}
+     */
+    visit(visitor) {
+        /** @type  {import("./view").VisitResult}*/
+        let result;
+        try {
+            result = visitor(this);
+        } catch (e) {
+            // Augment the exception with the view
+            e.view = this;
+            throw e;
+        }
+
+        if (result === VISIT_STOP) {
+            return result;
+        }
+
+        if (result !== VISIT_SKIP) {
+            if (visitor.beforeChildren) {
+                visitor.beforeChildren(this);
+            }
+
+            for (const view of this) {
+                const result = view.visit(visitor);
+                if (result === VISIT_STOP) {
+                    return result;
+                }
+            }
+
+            if (visitor.afterChildren) {
+                visitor.afterChildren(this);
+            }
+
+            if (visitor.postOrder) {
+                visitor.postOrder(this);
+            }
+        }
+    }
+
+    /**
+     * @param {string[]} path An array of view names
+     * @returns {View}
+     */
+    findDescendantByPath(path) {
+        for (const child of this) {
+            if (child.name === path[0]) {
+                if (path.length == 1) {
+                    return child;
+                } else if (child instanceof ContainerView) {
+                    return child.findDescendantByPath(path.slice(1));
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {string} name
+     */
+    findChildByName(name) {
+        for (const child of this) {
+            if (child.name === name) {
+                return child;
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {string} name
+     */
+    findDescendantByName(name) {
+        /** @type {View} */
+        let view;
+
+        this.visit((v) => {
+            if (v.name == name) {
+                view = v;
+                return VISIT_STOP;
+            }
+        });
+
+        return view;
+    }
+
+    /**
+     * @param {import("../spec/channel").Channel} channel
+     * @param {import("../spec/view").ResolutionTarget} resolutionType
+     * @returns {import("../spec/view").ResolutionBehavior}
+     */
+    getDefaultResolution(channel, resolutionType) {
+        return "shared";
+    }
+}

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

@@ -0,0 +1,71 @@
+/**
+ * Implements (a subset of) the Vega-Lite's Facet-operator:
+ * https://vega.github.io/vega-lite/docs/facet.html
+ *
+ * TODO:
+ *  - Facet channel titles
+ *  - Suppress redundant axes
+ *  - Make this thing configurable
+ *
+ * @typedef {object} FacetDimension Stuff for working with facet dimensions
+ * @prop {function} accessor
+ * @prop {boolean[] | string[] | number[]} factors
+ * @prop {FacetFieldDef} facetFieldDef
+ *
+ */
+export default class FacetView extends ContainerView {
+    /**
+     * @typedef {import("./view").default} View
+     * @typedef {import("./layerView").default} LayerView
+     * @typedef {import("./viewUtils").FacetFieldDef} FacetFieldDef
+     * @typedef {import("./viewUtils").FacetMapping} FacetMapping
+     * @typedef {import("../utils/layout/flexLayout").LocSize} LocSize
+     * @typedef {import("../utils/layout/flexLayout").SizeDef} SizeDef
+     */
+    /**
+     *
+     * @param {import("./viewUtils").FacetSpec} spec
+     * @param {import("./viewUtils").ViewContext} context
+     * @param {ContainerView} parent
+     * @param {string} name
+     */
+    constructor(spec: any, context: any, parent: ContainerView, name: string);
+    spec: any;
+    child: any;
+    /**
+     * Faceted views for displaying the facet labels
+     *
+     * @type {Record<FacetChannel, UnitView>}
+     */
+    _labelViews: Record<FacetChannel, UnitView>;
+    /**  @type {Record<FacetChannel, FacetDimension>} */
+    _facetDimensions: Record<FacetChannel, FacetDimension>;
+    transformData(): void;
+    /**
+     *
+     * @param {"row" | "column"} channel
+     */
+    getAccessor(channel: "row" | "column"): import("../types/encoder").Accessor;
+    updateFacets(): void;
+    updateLabels(): void;
+    getFacetGroups(): any[];
+    /**
+     * @param {import("./renderingContext/viewRenderingContext").default} context
+     * @param {import("../utils/layout/rectangle").default} coords
+     * @param {import("./view").RenderingOptions} [options]
+     */
+    render(context: import("./renderingContext/viewRenderingContext").default, coords: import("../utils/layout/rectangle").default, options?: any): void;
+    _labelsUpdated: boolean;
+}
+export type FacetChannel = "column" | "row";
+/**
+ * Stuff for working with facet dimensions
+ */
+export type FacetDimension = {
+    accessor: Function;
+    factors: boolean[] | string[] | number[];
+    facetFieldDef: any;
+};
+import ContainerView from "./containerView";
+import UnitView from "./unitView";
+//# sourceMappingURL=facetView.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"facetView.d.ts","sourceRoot":"","sources":["../../../src/view/facetView.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;GAcG;AACH;IACI;;;;;;;OAOG;IACH;;;;;;OAMG;IACH,6CAHW,aAAa,QACb,MAAM,EA8BhB;IAzBG,UAAgB;IAEhB,WAEC;IAED;;;;OAIG;IACH,aAFU,OAAO,YAAY,EAAE,QAAQ,CAAC,CAYvC;IAED,oDAAoD;IACpD,kBADY,OAAO,YAAY,EAAE,cAAc,CAAC,CACa;IA2BjE,sBAIC;IAED;;;OAGG;IACH,qBAFW,KAAK,GAAG,QAAQ,uCAwB1B;IAED,qBAyCC;IAED,qBASC;IA6BD,wBAgBC;IAOD;;;;OAIG;IACH,gBAJW,OAAO,yCAAyC,EAAE,OAAO,UACzD,OAAO,2BAA2B,EAAE,OAAO,uBA4LrD;IA3KO,wBAA0B;CA4KrC;2BA/bY,QAAQ,GAAG,KAAK;;;;;;aA4CnB,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;;;0BA1Df,iBAAiB;qBACtB,YAAY"}