@genome-spy/core 0.30.0 → 0.30.3

package/src/data/transforms/sample.js

@@ -1,101 +0,0 @@
-import FlowNode from "../flowNode";
-
-/**
- * A reservoir sampler, based on: https://www.wikiwand.com/en/Reservoir_sampling
- *
- * @typedef {import("../../spec/transform").SampleParams} SampleParams
- */
-export default class SampleTransform extends FlowNode {
-    /**
-     *
-     * @param {SampleParams} params
-     */
-    constructor(params) {
-        super();
-
-        this.k = params.size || 500;
-        this.reset();
-    }
-
-    reset() {
-        super.reset();
-
-        /** @type {any[]} */
-        this.reservoir = [];
-        /** @type {number} */
-        this.W = undefined;
-        this.ingester = this._initialIngester;
-    }
-
-    /**
-     *
-     * @param {any} item
-     */
-    _initialIngester(item) {
-        this.reservoir.push(item);
-
-        if (this.reservoir.length == this.k) {
-            this.W = Math.exp(Math.log(Math.random()) / this.k);
-            this.i = this.k;
-            this.next = this.i;
-            this.ingester = this._finalIngester;
-            this._setNextStop();
-        }
-    }
-
-    /**
-     *
-     * @param {any} item
-     */
-    _finalIngester(item) {
-        if (++this.i == this.next) {
-            this.reservoir[Math.floor(Math.random() * this.k)] = item;
-            this.W *= Math.exp(Math.log(Math.random()) / this.k);
-            this._setNextStop();
-        }
-    }
-
-    _setNextStop() {
-        this.next +=
-            Math.floor(Math.log(Math.random()) / Math.log(1 - this.W)) + 1;
-    }
-
-    /**
-     *
-     * @param {import("../flowNode").Datum} datum
-     */
-    handle(datum) {
-        this.ingester(datum);
-    }
-
-    complete() {
-        for (const datum of this.reservoir) {
-            this._propagate(datum);
-        }
-
-        super.complete();
-    }
-}
-
-/**
- * A convenience function that uses SampleTransform to sample an iterable.
- *
- * @param {number} n
- * @param {Iterable<T>} iterable
- * @param {function(T):R} accessor
- * @returns {R[]}
- * @template T
- * @template R
- */
-export function sampleIterable(n, iterable, accessor) {
-    const sampler = new SampleTransform({
-        type: "sample",
-        size: n,
-    });
-    for (const d of iterable) {
-        sampler.handle(accessor(d));
-    }
-    sampler.complete();
-
-    return sampler.reservoir;
-}

package/src/data/transforms/sample.test.js

@@ -1,38 +0,0 @@
-import { expect, test } from "vitest";
-import SampleTransform from "./sample";
-import { extent } from "d3-array";
-import { createChain } from "../../view/flowBuilder";
-
-test("SampleTransform produces roughly uniform distributions", () => {
-    const size = 10;
-    const n = 20;
-    const rounds = 10000;
-
-    const freqs = [];
-    for (let i = 0; i < n; i++) {
-        freqs[i] = 0;
-    }
-
-    const { dataSource, collector } = createChain(
-        new SampleTransform({ type: "sample", size })
-    );
-
-    for (let r = 0; r < rounds; r++) {
-        for (let i = 0; i < n; i++) {
-            dataSource.handle({ data: i });
-        }
-        dataSource.complete();
-
-        for (const datum of collector.getData()) {
-            freqs[datum.data] = freqs[datum.data] + 1;
-        }
-
-        dataSource.reset();
-    }
-
-    const e = extent(freqs);
-
-    // Not a deterministic test! TODO: Come up with some sensical testing method
-    expect(e[0]).toBeGreaterThan(4800);
-    expect(e[1]).toBeLessThan(5200);
-});

package/src/data/transforms/stack.js

@@ -1,137 +0,0 @@
-import { compare } from "vega-util";
-import { groups as d3groups, sum as d3sum } from "d3-array";
-import FlowNode, { BEHAVIOR_MODIFIES } from "../flowNode";
-import { field } from "../../utils/field";
-
-/**
- * @typedef {import("../../spec/transform").StackParams} StackParams
- */
-export default class StackTransform extends FlowNode {
-    get behavior() {
-        return BEHAVIOR_MODIFIES;
-    }
-
-    /**
-     * @param {StackParams} params
-     */
-    constructor(params) {
-        super();
-        this.params = params;
-
-        /** @type {any[]} */
-        this.buffer = [];
-    }
-
-    reset() {
-        this.buffer = [];
-    }
-
-    /**
-     *
-     * @param {import("../flowNode").Datum} datum
-     */
-    handle(datum) {
-        this.buffer.push(datum);
-    }
-
-    complete() {
-        const params = this.params;
-
-        const as = params.as || ["y0", "y1"]; // TODO: Validate
-
-        const comparator = params.sort
-            ? compare(params.sort.field, params.sort.order)
-            : undefined;
-
-        const valueAccessor = params.field ? field(params.field) : () => 1;
-
-        const groupFields = params.groupby.map((f) => field(f));
-
-        const groups = d3groups(this.buffer, (row) =>
-            groupFields.map((f) => f(row)).join()
-        ).map((a) => a[1]);
-
-        /** @type {(datum: any) => boolean} */
-        let inclusionPredicate = (_datum) => true;
-
-        if (params.baseField) {
-            const baseAccessor = field(params.baseField);
-            inclusionPredicate = (datum) => baseAccessor(datum) !== null;
-        }
-
-        /** @type {(value: number, sum: number) => number} */
-        let offsetF;
-
-        /** @type {(values: number[], accessor: (datum: any) => number) => number} */
-        let sumF;
-
-        switch (params.offset) {
-            case "normalize":
-                offsetF = (value, sum) => value / sum;
-                sumF = (values, accessor) => d3sum(values, accessor);
-                break;
-            case "center":
-                offsetF = (value, sum) => value - sum / 2;
-                sumF = (values, accessor) => d3sum(values, accessor);
-                break;
-            case "information":
-                {
-                    // Sequence logos: a new way to display consensus sequences (Schneider and Stephens)
-                    // doi://10.1093/nar/18.20.6097
-
-                    const maxBits = Math.log2(params.cardinality ?? 4);
-                    offsetF = (value, sum) => value / sum;
-                    sumF = (values, accessor) => {
-                        const e = 0; // TODO: Correction factor for small sample sizes
-
-                        const gaps = d3sum(
-                            values,
-                            (d) => +!inclusionPredicate(d)
-                        );
-                        const total = d3sum(values, accessor);
-                        const nonGaps = total - gaps;
-
-                        let H = 0;
-                        for (let i = 0; i < values.length; i++) {
-                            const datum = values[i];
-                            if (inclusionPredicate(datum)) {
-                                const b = accessor(datum) / nonGaps;
-                                H -= b * Math.log2(b);
-                            }
-                        }
-
-                        return (
-                            (nonGaps / (maxBits - (H + e))) * (nonGaps / total)
-                        );
-                    };
-                }
-                break;
-            default:
-                offsetF = (value, sum) => value;
-                sumF = (_values, _accessor) => 1;
-        }
-
-        for (const group of groups) {
-            if (comparator) {
-                group.sort(comparator);
-            }
-
-            const sum = sumF(group, valueAccessor);
-
-            let prev = 0;
-            for (const datum of group) {
-                const current = prev + valueAccessor(datum);
-
-                if (inclusionPredicate(datum)) {
-                    datum[as[0]] = offsetF(prev, sum);
-                    datum[as[1]] = offsetF(current, sum);
-
-                    this._propagate(datum);
-                    prev = current;
-                }
-            }
-        }
-
-        super.complete();
-    }
-}

package/src/data/transforms/stack.test.js

@@ -1,91 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { processData } from "../flowTestUtils";
-import StackTransform from "./stack";
-
-const sampleData = [
-    { group: "a", choice: "q", value: 1 },
-    { group: "b", choice: "x", value: 1 },
-    { group: "b", choice: "y", value: 3 },
-];
-
-/** @type {import("./stack").StackParams} */
-const baseConf = {
-    type: "stack",
-    field: "value",
-    groupby: ["group"],
-    sort: {
-        field: "value",
-        order: "ascending",
-    },
-    offset: "zero",
-    as: ["z0", "z1"],
-};
-
-/**
- *
- * @param {import("./stack").StackParams} params
- * @param {any[]} data
- */
-function transform(params, data) {
-    return processData(new StackTransform(params), data);
-}
-
-describe("Stack transform", () => {
-    test("No field", () => {
-        const conf = Object.assign({}, baseConf, {
-            field: undefined,
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 1, z1: 2 },
-        ]);
-    });
-
-    test("Zero offset", () => {
-        expect(transform(baseConf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 1, z1: 4 },
-        ]);
-    });
-
-    test("Normalize offset", () => {
-        const conf = Object.assign({}, baseConf, {
-            offset: "normalize",
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "x", value: 1, z0: 0, z1: 0.25 },
-            { group: "b", choice: "y", value: 3, z0: 0.25, z1: 1 },
-        ]);
-    });
-
-    test("Center offset", () => {
-        const conf = Object.assign({}, baseConf, {
-            offset: "center",
-        });
-
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: -0.5, z1: 0.5 },
-            { group: "b", choice: "x", value: 1, z0: -2, z1: -1 },
-            { group: "b", choice: "y", value: 3, z0: -1, z1: 2 },
-        ]);
-    });
-
-    test("Descending sort", () => {
-        const conf = Object.assign({}, baseConf, {
-            sort: {
-                field: "value",
-                order: "descending",
-            },
-        });
-        expect(transform(conf, sampleData)).toEqual([
-            { group: "a", choice: "q", value: 1, z0: 0, z1: 1 },
-            { group: "b", choice: "y", value: 3, z0: 0, z1: 3 },
-            { group: "b", choice: "x", value: 1, z0: 3, z1: 4 },
-        ]);
-    });
-});

package/src/data/transforms/transformFactory.js

@@ -1,60 +0,0 @@
-import Collector from "../collector";
-import CoverageTransform from "./coverage";
-import FilterScoredLabelsTransform from "./filterScoredLabels";
-import FilterTransform from "./filter";
-import FlattenCompressedExonsTransform from "./flattenCompressedExons";
-import FlattenDelimitedTransform from "./flattenDelimited";
-import FormulaTransform from "./formula";
-import LinearizeGenomicCoordinate from "./linearizeGenomicCoordinate";
-import MeasureTextTransform from "./measureText";
-import PileupTransform from "./pileup";
-import ProjectTransform from "./project";
-import RegexExtractTransform from "./regexExtract";
-import RegexFoldTransform from "./regexFold";
-import SampleTransform from "./sample";
-import StackTransform from "./stack";
-import FlattenSequenceTransform from "./flattenSequence";
-import AggregateTransform from "./aggregate";
-import IdentifierTransform from "./identifier";
-
-/**
- * TODO: Make this dynamic
- *
- * @typedef {import("../../view/view").default} View
- * @typedef {import("../flowNode").default} FlowNode
- *
- * @type {Record<string, new (params: any, view?: View) => FlowNode>}
- */
-export const transforms = {
-    aggregate: AggregateTransform,
-    collect: Collector,
-    coverage: CoverageTransform,
-    filterScoredLabels: FilterScoredLabelsTransform,
-    filter: FilterTransform,
-    flattenCompressedExons: FlattenCompressedExonsTransform,
-    flattenDelimited: FlattenDelimitedTransform,
-    flattenSequence: FlattenSequenceTransform,
-    formula: FormulaTransform,
-    identifier: IdentifierTransform,
-    linearizeGenomicCoordinate: LinearizeGenomicCoordinate,
-    measureText: MeasureTextTransform,
-    pileup: PileupTransform,
-    project: ProjectTransform,
-    regexExtract: RegexExtractTransform,
-    regexFold: RegexFoldTransform,
-    sample: SampleTransform,
-    stack: StackTransform,
-};
-
-/**
- * @param {import("../../spec/transform").TransformParamsBase} params
- * @param {View} [view]
- */
-export default function createTransform(params, view) {
-    const Transform = transforms[params.type];
-    if (Transform) {
-        return new Transform(params, view);
-    } else {
-        throw new Error("Unknown transform: " + params.type);
-    }
-}

package/src/embedApi.d.ts

@@ -1,67 +0,0 @@
-import { ScaleResolutionApi } from "./view/scaleResolutionApi";
-import { TooltipHandler } from "./tooltip/tooltipHandler";
-import { RootSpec } from "./spec/root";
-
-/**
- * Embeds GenomeSpy into the DOM
- *
- * @param el HTMLElement or a query selector
- * @param spec A spec object or an URL to a JSON spec
- * @param options Options
- */
-export type EmbedFunction = (
-    el: HTMLElement | string,
-    spec: RootSpec | string,
-    options?: EmbedOptions
-) => EmbedResult;
-
-export interface EmbedOptions {
-    /**
-     * A function that allows retrieval of named data. There are two ways to provide named data:
-     * 1. A data provider (this)
-     * 2. Explicit updates using the `updateNamedData` method (the other).
-     */
-    namedDataProvider?: (name: string) => any[];
-
-    /**
-     * Custom tooltip handlers. Use `"default"` to override the default handler
-     */
-    tooltipHandlers?: Record<string, TooltipHandler>;
-}
-
-/**
- * An API for controlling the embedded GenomeSpy instance.
- */
-export interface EmbedResult {
-    /**
-     * Releases all resources and unregisters event listeners, etc.
-     */
-    finalize: () => void;
-
-    /**
-     * Adds an event listener, which is called when the user interacts with a mark
-     * instance. Currently, only `"click"` events are supported. The callback receives
-     * an event object as its first (and only) parameter. Its `datum` property
-     * contains the datum that the user interacted with.
-     */
-    addEventListener: (type: string, listener: (event: any) => void) => void;
-
-    /**
-     * Removes a registered event listener.
-     */
-    removeEventListener: (type: string, listener: (event: any) => void) => void;
-
-    /**
-     * Returns a named `ScaleResolution` object that allows for attaching event
-     * listeners and controlling the scale domain.
-     */
-    getScaleResolutionByName: (name: string) => ScaleResolutionApi;
-
-    /**
-     * Updates a named dataset
-     *
-     * @param name data source to update
-     * @param data new data. If left undefined, the data is retrieved from a provider.
-     */
-    updateNamedData: (name: string, data?: any[]) => void;
-}

package/src/encoder/accessor.js

@@ -1,82 +0,0 @@
-import createFunction from "../utils/expression";
-
-import { accessorFields, constant } from "vega-util";
-import { isDatumDef, isExprDef, isFieldDef } from "./encoder";
-import { field } from "../utils/field";
-
-/**
- * @typedef {Object} AccessorMetadata
- * @prop {boolean} constant True if the accessor returns the same value for all objects
- * @prop {string[]} fields The fields that the return value is based on (if any)
- *
- * @typedef {(function(any):any) & AccessorMetadata} Accessor
- *
- * @typedef {import("../view/viewUtils").ChannelDef} ChannelDef
- */
-export default class AccessorFactory {
-    constructor() {
-        /** @type {(function(ChannelDef):Accessor)[]} */
-        this.accessorCreators = [];
-
-        this.register((channelDef) => {
-            if (isFieldDef(channelDef)) {
-                try {
-                    const accessor = /** @type {Accessor} */ (
-                        field(channelDef.field)
-                    );
-                    accessor.constant = false;
-                    accessor.fields = accessorFields(accessor);
-                    return accessor;
-                } catch (e) {
-                    throw new Error(`Invalid field definition: ${e.message}`);
-                }
-            }
-        });
-
-        this.register((channelDef) =>
-            isExprDef(channelDef)
-                ? createExpressionAccessor(channelDef.expr)
-                : undefined
-        );
-
-        this.register((channelDef) => {
-            if (isDatumDef(channelDef)) {
-                const c = /** @type {any} */ (constant(channelDef.datum));
-                const accessor = /** @type {Accessor} */ (c);
-                accessor.constant = true; // Can be optimized downstream
-                accessor.fields = [];
-                return accessor;
-            }
-        });
-    }
-
-    /**
-     *
-     * @param {function(ChannelDef):Accessor} creator
-     */
-    register(creator) {
-        this.accessorCreators.push(creator);
-    }
-
-    /**
-     *
-     * @param {ChannelDef} encoding
-     */
-    createAccessor(encoding) {
-        for (const creator of this.accessorCreators) {
-            const accessor = creator(encoding);
-            if (accessor) {
-                return accessor;
-            }
-        }
-    }
-}
-
-/**
- * @param {string} expr
- */
-function createExpressionAccessor(expr) {
-    const accessor = /** @type {Accessor} */ (createFunction(expr));
-    accessor.constant = accessor.fields.length == 0; // Not bulletproof, eh
-    return accessor;
-}

package/src/encoder/accessor.test.js

@@ -1,47 +0,0 @@
-import { expect, test } from "vitest";
-import AccessorFactory from "./accessor";
-
-const af = new AccessorFactory();
-
-const datum = {
-    a: 1,
-    b: 2,
-    "x.c": 3,
-};
-
-test("Creates a field accessor", () => {
-    const a = af.createAccessor({ field: "a" });
-    expect(a(datum)).toEqual(1);
-    expect(a.constant).toBeFalsy();
-    expect(a.fields).toEqual(["a"]);
-});
-
-test("Creates an expression accessor", () => {
-    const a = af.createAccessor({ expr: `datum.b + datum['x\.c']` });
-    expect(a(datum)).toEqual(5);
-    expect(a.constant).toBeFalsy();
-    expect(a.fields.sort()).toEqual(["b", "x.c"].sort());
-});
-
-test("Creates a constant accessor", () => {
-    const a = af.createAccessor({ datum: 0 });
-    expect(a(datum)).toEqual(0);
-    expect(a.constant).toBeTruthy();
-    expect(a.fields).toEqual([]);
-});
-
-test("Returns undefined on incomplete encoding spec", () => {
-    expect(af.createAccessor({})).toBeUndefined();
-});
-
-test("Registers and creates a custom accessor", () => {
-    const af = new AccessorFactory();
-    af.register((encoding) => {
-        if (encoding.iddqd && encoding.idkfa) {
-            return (datum) =>
-                `${datum[encoding.iddqd]}-${datum[encoding.idkfa]}`;
-        }
-    });
-
-    expect(af.createAccessor({ iddqd: "a", idkfa: "b" })(datum)).toEqual("1-2");
-});