@genome-spy/core 0.64.0 → 0.66.1

package/dist/bundle/remoteFile-BuaqFGWk.js

@@ -1,94 +0,0 @@
-import { b as d } from "./index-BftNdA0O.js";
-function u(n) {
-  return (typeof n == "object" && n !== null && "message" in n ? n.message : `${n}`).replace(/\.$/, "");
-}
-class $ {
-  async getBufferFromResponse(e) {
-    const t = await e.arrayBuffer();
-    return d.Buffer.from(t);
-  }
-  constructor(e, t = {}) {
-    this.baseOverrides = {}, this.url = e;
-    const r = t.fetch || globalThis.fetch.bind(globalThis);
-    if (!r)
-      throw new TypeError("no fetch function supplied, and none found in global environment");
-    t.overrides && (this.baseOverrides = t.overrides), this.fetchImplementation = r;
-  }
-  async fetch(e, t) {
-    let r;
-    try {
-      r = await this.fetchImplementation(e, t);
-    } catch (s) {
-      if (`${s}`.includes("Failed to fetch")) {
-        console.warn(`generic-filehandle: refetching ${e} to attempt to work around chrome CORS header caching bug`);
-        try {
-          r = await this.fetchImplementation(e, {
-            ...t,
-            cache: "reload"
-          });
-        } catch (i) {
-          throw new Error(`${u(i)} fetching ${e}`, { cause: i });
-        }
-      } else
-        throw new Error(`${u(s)} fetching ${e}`, { cause: s });
-    }
-    return r;
-  }
-  async read(e, t = 0, r, s = 0, i = {}) {
-    const { headers: c = {}, signal: o, overrides: f = {} } = i;
-    r < 1 / 0 ? c.range = `bytes=${s}-${s + r}` : r === 1 / 0 && s !== 0 && (c.range = `bytes=${s}-`);
-    const a = await this.fetch(this.url, {
-      ...this.baseOverrides,
-      ...f,
-      headers: {
-        ...c,
-        ...f.headers,
-        ...this.baseOverrides.headers
-      },
-      method: "GET",
-      redirect: "follow",
-      mode: "cors",
-      signal: o
-    });
-    if (!a.ok)
-      throw new Error(`HTTP ${a.status} fetching ${this.url}`);
-    if (a.status === 200 && s === 0 || a.status === 206) {
-      const l = await this.getBufferFromResponse(a), g = l.copy(e, t, 0, Math.min(r, l.length)), w = a.headers.get("content-range"), h = /\/(\d+)$/.exec(w || "");
-      return h != null && h[1] && (this._stat = { size: parseInt(h[1], 10) }), { bytesRead: g, buffer: e };
-    }
-    throw a.status === 200 ? new Error(`${this.url} fetch returned status 200, expected 206`) : new Error(`HTTP ${a.status} fetching ${this.url}`);
-  }
-  async readFile(e = {}) {
-    let t, r;
-    typeof e == "string" ? (t = e, r = {}) : (t = e.encoding, r = e, delete r.encoding);
-    const { headers: s = {}, signal: i, overrides: c = {} } = r, o = await this.fetch(this.url, {
-      headers: s,
-      method: "GET",
-      redirect: "follow",
-      mode: "cors",
-      signal: i,
-      ...this.baseOverrides,
-      ...c
-    });
-    if (o.status !== 200)
-      throw new Error(`HTTP ${o.status} fetching ${this.url}`);
-    if (t === "utf8")
-      return o.text();
-    if (t)
-      throw new Error(`unsupported encoding: ${t}`);
-    return this.getBufferFromResponse(o);
-  }
-  async stat() {
-    if (!this._stat) {
-      const e = d.Buffer.allocUnsafe(10);
-      if (await this.read(e, 0, 10, 0), !this._stat)
-        throw new Error(`unable to determine size of file at ${this.url}`);
-    }
-    return this._stat;
-  }
-  async close() {
-  }
-}
-export {
-  $ as R
-};

package/dist/src/data/collector.test.js

@@ -1,138 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import Collector from "./collector.js";
-import { UNIQUE_ID_KEY } from "./transforms/identifier.js";
-
-const data = [1, 5, 2, 4, 3].map((x) => ({ x }));
-
-test("Collector collects data", () => {
-    const collector = new Collector();
-
-    for (const d of data) {
-        collector.handle(d);
-    }
-    collector.complete();
-
-    expect(collector.getData()).toEqual(data);
-});
-
-test("Collector collects and sorts data", () => {
-    const collector = new Collector({
-        type: "collect",
-        sort: { field: ["x"] },
-    });
-
-    for (const d of data) {
-        collector.handle(d);
-    }
-    collector.complete();
-
-    expect([...collector.getData()]).toEqual(
-        [1, 2, 3, 4, 5].map((x) => ({ x }))
-    );
-});
-
-test("Collector collects, groups, and sorts data", () => {
-    const collector = new Collector({
-        type: "collect",
-        sort: { field: ["x"] },
-        groupby: ["a", "b"],
-    });
-
-    const data = [
-        { a: 1, b: 1, x: 1 },
-        { a: 1, b: 2, x: 2 },
-        { a: 1, b: 2, x: 3 },
-        { a: 2, b: 1, x: 4 },
-        { a: 2, b: 1, x: 5 },
-        { a: 2, b: 2, x: 6 },
-    ];
-
-    for (const d of data) {
-        collector.handle(d);
-    }
-    collector.complete();
-
-    const cd = [...collector.getData()];
-
-    expect(cd.map((d) => ({ x: d.x }))).toEqual(
-        [1, 2, 3, 4, 5, 6].map((x) => ({ x }))
-    );
-
-    /** @param {any[]} group*/
-    const getGroupX = (group) =>
-        collector.facetBatches.get(group).map((d) => d.x);
-
-    expect(getGroupX([1, 1])).toEqual([1]);
-    expect(getGroupX([1, 2])).toEqual([2, 3]);
-    expect(getGroupX([2, 1])).toEqual([4, 5]);
-    expect(getGroupX([2, 2])).toEqual([6]);
-
-    expect(new Set(collector.facetBatches.keys())).toEqual(
-        new Set([
-            [1, 1],
-            [1, 2],
-            [2, 1],
-            [2, 2],
-        ])
-    );
-});
-
-test("Collector throws on incomplete flow", () => {
-    const collector = new Collector();
-
-    expect(() => collector.getData()).toThrow();
-});
-
-describe("Indexing unique ids", () => {
-    test("Collector builds a working index when ids are available", () => {
-        const collector = new Collector({
-            type: "collect",
-            groupby: ["a"],
-        });
-
-        const data = [
-            { a: 1, x: 1, [UNIQUE_ID_KEY]: 8 },
-            { a: 1, x: 2, [UNIQUE_ID_KEY]: 2 },
-            { a: 1, x: 3, [UNIQUE_ID_KEY]: 4 },
-            { a: 1, x: 4, [UNIQUE_ID_KEY]: 6 },
-            { a: 2, x: 5, [UNIQUE_ID_KEY]: 9 },
-            { a: 2, x: 6, [UNIQUE_ID_KEY]: 7 },
-            { a: 2, x: 7, [UNIQUE_ID_KEY]: 3 },
-            { a: 2, x: 8, [UNIQUE_ID_KEY]: 1 },
-        ];
-
-        for (const d of data) {
-            collector.handle(d);
-        }
-        collector.complete();
-
-        expect(collector.findDatumByUniqueId(8)).toEqual(data[0]);
-        expect(collector.findDatumByUniqueId(2)).toEqual(data[1]);
-        expect(collector.findDatumByUniqueId(4)).toEqual(data[2]);
-        expect(collector.findDatumByUniqueId(6)).toEqual(data[3]);
-        expect(collector.findDatumByUniqueId(9)).toEqual(data[4]);
-        expect(collector.findDatumByUniqueId(7)).toEqual(data[5]);
-        expect(collector.findDatumByUniqueId(3)).toEqual(data[6]);
-        expect(collector.findDatumByUniqueId(1)).toEqual(data[7]);
-    });
-
-    test("Collector returns undefined when ids are not available", () => {
-        const collector = new Collector({
-            type: "collect",
-            groupby: ["a"],
-        });
-
-        const data = [
-            { a: 1, x: 1 },
-            { a: 2, x: 5 },
-        ];
-
-        for (const d of data) {
-            collector.handle(d);
-        }
-        collector.complete();
-
-        expect(collector.findDatumByUniqueId(0)).toBeUndefined();
-    });
-});

package/dist/src/data/dataFlow.test.js

@@ -1,5 +0,0 @@
-import { describe, test } from "vitest";
-
-describe("DataFlow", () => {
-    test.todo("TODO");
-});

package/dist/src/data/flow.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, test } from "vitest";
-import FilterTransform from "./transforms/filter.js";
-import FormulaTransform from "./transforms/formula.js";
-import Collector from "./collector.js";
-import {
-    SynchronousSequenceSource,
-    makeParamMediatorProvider,
-} from "./flowTestUtils.js";
-
-describe("Test flow graphs", () => {
-    test("Trivial graph: sequence to collector", () => {
-        const source = new SynchronousSequenceSource(5);
-        const collector = new Collector();
-        source.addChild(collector);
-
-        source.dispatch();
-
-        expect(collector.getData()).toEqual(
-            [0, 1, 2, 3, 4].map((d) => ({
-                data: d,
-            }))
-        );
-    });
-
-    test("Trivial branching: sequence to two collectors", () => {
-        const source = new SynchronousSequenceSource(5);
-        const collector1 = new Collector();
-        source.addChild(collector1);
-        const collector2 = new Collector();
-        source.addChild(collector2);
-
-        source.dispatch();
-
-        expect(collector1.getData()).toEqual(
-            [0, 1, 2, 3, 4].map((d) => ({
-                data: d,
-            }))
-        );
-
-        expect(collector2.getData()).toEqual(
-            [0, 1, 2, 3, 4].map((d) => ({
-                data: d,
-            }))
-        );
-    });
-
-    test.skip("Implement stub for ParamMediator");
-
-    test("Longer chain of nodes", () => {
-        const source = new SynchronousSequenceSource(10);
-        const filter = new FilterTransform(
-            {
-                type: "filter",
-                expr: "datum.data < 5",
-            },
-            makeParamMediatorProvider()
-        );
-        const formula = new FormulaTransform(
-            {
-                type: "formula",
-                expr: "datum.data * 2",
-                as: "data",
-            },
-            makeParamMediatorProvider()
-        );
-        const collector = new Collector();
-
-        source.addChild(filter);
-        filter.addChild(formula);
-        formula.addChild(collector);
-
-        source.visit((node) => node.initialize());
-        source.dispatch();
-
-        expect(collector.getData()).toEqual(
-            [0, 2, 4, 6, 8].map((d) => ({
-                data: d,
-            }))
-        );
-    });
-});

package/dist/src/data/flowNode.test.js

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "vitest";
-import FlowNode from "./flowNode.js";
-import { validateLinks } from "./flowOptimizer.js";
-
-describe("Flow mutation", () => {
-    test("Excise a terminal node", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-
-        a.addChild(b);
-        b.excise();
-
-        expect(a.children[0]).toBeUndefined();
-        expect(b.parent).toBeUndefined();
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-
-    test("Excise a node in the middle", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-        const c = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        b.excise();
-
-        expect(a.children[0]).toBe(c);
-        expect(c.parent).toBe(a);
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-
-    test("Insert as parent", () => {
-        const a = new FlowNode();
-        const b = new FlowNode();
-        const c = new FlowNode();
-        const d = new FlowNode();
-
-        a.addChild(c);
-        a.addChild(d);
-        c.insertAsParent(b);
-
-        expect(a.children[0]).toBe(b);
-        expect(a.children[1]).toBe(d);
-        expect(a.children[0].children[0]).toBe(c);
-
-        expect(validateLinks(a)).toBeTruthy();
-    });
-});

package/dist/src/data/flowOptimizer.test.js

@@ -1,204 +0,0 @@
-import { describe, expect, test } from "vitest";
-import FlowNode, { BEHAVIOR_CLONES } from "./flowNode.js";
-import {
-    removeRedundantCloneTransforms,
-    validateLinks,
-} from "./flowOptimizer.js";
-import CloneTransform from "./transforms/clone.js";
-import Collector from "./collector.js";
-import DataFlow from "./dataFlow.js";
-import { combineIdenticalDataSources } from "./flowOptimizer.js";
-import InlineSource from "./sources/inlineSource.js";
-import UrlSource from "./sources/urlSource.js";
-import { makeParamMediatorProvider } from "./flowTestUtils.js";
-
-test("validateLinks() detects broken graph", () => {
-    const root = new FlowNode();
-    const a = new FlowNode();
-    const b = new FlowNode();
-    const c = new FlowNode();
-
-    root.addChild(a);
-    root.addChild(b);
-    root.addChild(c);
-
-    expect(validateLinks(root)).toBeTruthy();
-
-    // Break it!
-    b.parent = undefined;
-
-    expect(validateLinks(root)).toBeFalsy();
-
-    // Check handling of root
-
-    const rootWithParent = new FlowNode();
-    // Break it!
-    rootWithParent.parent = new FlowNode();
-
-    expect(validateLinks(rootWithParent)).toBeFalsy();
-});
-
-describe("removeRedundantCloneTransforms", () => {
-    test("Removes redundancy from linear graph #1", () => {
-        const a = new FlowNode();
-        const b = new CloneTransform();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new CloneTransform();
-        const f = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-        e.addChild(f);
-
-        removeRedundantCloneTransforms(a);
-
-        expect(a.children[0]).toBe(c);
-        expect(c.children[0]).toBe(f);
-    });
-
-    test("Removes redundancy from linear graph #2", () => {
-        const a = new FlowNode();
-        const b = new CloneTransform();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new CloneTransform();
-        const f = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-        e.addChild(f);
-
-        // First CloneTransform should be retained
-        removeRedundantCloneTransforms(a, true);
-
-        expect(a.children[0]).toBe(b);
-        expect(b.children[0]).toBe(c);
-        expect(c.children[0]).toBe(f);
-    });
-
-    test("Node with cloning behavior satisfies cloning requirement", () => {
-        class CloningFlowNode extends FlowNode {
-            get behavior() {
-                return BEHAVIOR_CLONES;
-            }
-        }
-
-        const a = new FlowNode();
-        const b = new CloningFlowNode();
-        const c = new FlowNode();
-        const d = new CloneTransform();
-        const e = new FlowNode();
-
-        a.addChild(b);
-        b.addChild(c);
-        c.addChild(d);
-        d.addChild(e);
-
-        removeRedundantCloneTransforms(a, true);
-
-        expect(a.children[0]).toBe(b);
-        expect(b.children[0]).toBe(c);
-        expect(c.children[0]).toBe(e);
-    });
-
-    test("Removes redundancy from a branching graph", () => {
-        const root = new FlowNode();
-        const branching = new FlowNode();
-        const a = new CloneTransform();
-        const al = new FlowNode();
-        const b = new CloneTransform();
-        const bl = new FlowNode();
-        const c = new CloneTransform();
-        const cl = new FlowNode();
-
-        root.addChild(branching);
-        branching.addChild(a);
-        branching.addChild(b);
-        branching.addChild(c);
-        a.addChild(al);
-        b.addChild(bl);
-        c.addChild(cl);
-
-        removeRedundantCloneTransforms(root);
-
-        // All but the last branch needs cloning
-        expect(branching.children[0]).toBe(a);
-        expect(branching.children[1]).toBe(b);
-        expect(branching.children[2]).toBe(c);
-    });
-});
-
-/** @type {import("../view/view.js").default} */
-const viewStub = /** @type {any} */ (
-    Object.assign(makeParamMediatorProvider(), {
-        getBaseUrl: () => "",
-    })
-);
-
-describe("Merge indentical data sources", () => {
-    test("Merges correctly", () => {
-        /** @type {DataFlow<string>} */
-        const dataFlow = new DataFlow();
-
-        const a = new UrlSource({ url: "http://genomespy.app/" }, viewStub);
-        const ac = new Collector();
-        a.addChild(ac);
-
-        const b = new UrlSource({ url: "http://genomespy.app/" }, viewStub);
-        const bc = new Collector();
-        b.addChild(bc);
-
-        const c = new UrlSource({ url: "http://helsinki.fi/" }, viewStub);
-        const cc = new Collector();
-        c.addChild(cc);
-
-        dataFlow.addDataSource(a, "a");
-        dataFlow.addDataSource(b, "b");
-        dataFlow.addDataSource(c, "c");
-
-        dataFlow.addCollector(ac, "a");
-        dataFlow.addCollector(bc, "b");
-        dataFlow.addCollector(cc, "c");
-
-        combineIdenticalDataSources(dataFlow);
-
-        expect(dataFlow.dataSources.length).toEqual(2);
-
-        expect(dataFlow.findDataSourceByKey("a")).toBe(a);
-        expect(dataFlow.findDataSourceByKey("b")).toBe(a); // Merged!
-        expect(dataFlow.findDataSourceByKey("c")).toBe(c);
-
-        expect(new Set(a.children)).toEqual(new Set([ac, bc]));
-        expect(c.children[0]).toBe(cc);
-
-        for (const dataSource of dataFlow.dataSources) {
-            // Cheat that we loaded something
-            dataSource.complete();
-        }
-
-        expect(ac.completed).toBeTruthy();
-        expect(bc.completed).toBeTruthy();
-        expect(cc.completed).toBeTruthy();
-    });
-
-    test("Does not merge those with undefined identifier", () => {
-        /** @type {DataFlow<string>} */
-        const dataFlow = new DataFlow();
-
-        const a = new InlineSource({ values: [1, 2, 3] }, viewStub);
-        const b = new InlineSource({ values: [1, 2, 3] }, viewStub);
-
-        dataFlow.addDataSource(a, "a");
-        dataFlow.addDataSource(b, "b");
-
-        combineIdenticalDataSources(dataFlow);
-
-        expect(dataFlow.findDataSourceByKey("a")).toBe(a);
-        expect(dataFlow.findDataSourceByKey("b")).toBe(b);
-    });
-});

package/dist/src/data/formats/fasta.test.js

@@ -1,27 +0,0 @@
-import { expect, test } from "vitest";
-import fasta from "./fasta.js";
-
-test("fasta", () => {
-    const fileContent = `>A stuff
---------------------------AGAGTTTGATCCTGGCTCAGGGTGAACGCTGGCG
-GCGTGC----TTAAGACATGCAAGTCGAACGG-CCT------TCTTCG-G-AAGGC-AGT
----------------------------------
->B other stuff
---------------------------AGAGTTTGATCATGGCTCAGGGTGAACGCTGGCG
-GCGTGC----TTAAGACATGCAAGTCGGACGA-TCG------GCTTCG---GCCGGTAGT
----------------------------------
-`;
-
-    expect(fasta(fileContent)).toEqual([
-        {
-            identifier: "A",
-            sequence:
-                "--------------------------AGAGTTTGATCCTGGCTCAGGGTGAACGCTGGCGGCGTGC----TTAAGACATGCAAGTCGAACGG-CCT------TCTTCG-G-AAGGC-AGT---------------------------------",
-        },
-        {
-            identifier: "B",
-            sequence:
-                "--------------------------AGAGTTTGATCATGGCTCAGGGTGAACGCTGGCGGCGTGC----TTAAGACATGCAAGTCGGACGA-TCG------GCTTCG---GCCGGTAGT---------------------------------",
-        },
-    ]);
-});

package/dist/src/data/sources/inlineSource.test.js

@@ -1,63 +0,0 @@
-import { expect, test } from "vitest";
-import Collector from "../collector.js";
-import InlineSource from "./inlineSource.js";
-
-/**
- * @param {InlineSource} source
- */
-async function collectSource(source) {
-    const collector = new Collector();
-    source.addChild(collector);
-
-    await source.load();
-
-    return [...collector.getData()];
-}
-
-test("InlineSource propagates an object", async () => {
-    expect(
-        await collectSource(new InlineSource({ values: { x: 1 } }, undefined))
-    ).toEqual([{ x: 1 }]);
-});
-
-test("InlineSource propagates an array of objects", async () => {
-    expect(
-        await collectSource(
-            new InlineSource({ values: [{ x: 1 }, { x: 2 }] }, undefined)
-        )
-    ).toEqual([{ x: 1 }, { x: 2 }]);
-});
-
-test("InlineSource wraps scalars to objects", async () => {
-    expect(
-        await collectSource(new InlineSource({ values: [1, 2] }, undefined))
-    ).toEqual([{ data: 1 }, { data: 2 }]);
-});
-
-test("InlineSource parses a string", async () => {
-    expect(
-        await collectSource(
-            new InlineSource(
-                {
-                    values: "a\n1\n2\n3",
-                    format: {
-                        type: "csv",
-                    },
-                },
-                undefined
-            )
-        )
-    ).toEqual([{ a: 1 }, { a: 2 }, { a: 3 }]);
-});
-
-test("InlineSource throws on a string and a missing format specifier", () => {
-    expect(
-        () =>
-            new InlineSource(
-                {
-                    values: "a\n1\n2\n3",
-                },
-                undefined
-            )
-    ).toThrow();
-});