wuepgg3-track 1.0.2

package/dist/models/DisplayedRegionModel.d.ts

@@ -0,0 +1,114 @@
+import OpenInterval from "./OpenInterval";
+import NavigationContext from "./NavigationContext";
+import { FeatureSegment } from "./FeatureSegment";
+import ChromosomeInterval from "./ChromosomeInterval";
+/**
+ * Model that stores the view window/region in a larger navigation context (e.g. a genome).  Internally stores the
+ * region as an open interval of nav context coordinates (@see {@link NavigationContext}).
+ *
+ * @author Silas Hsu
+ */
+declare class DisplayedRegionModel {
+    _navContext: NavigationContext;
+    _startBase: number | undefined;
+    _endBase: number | undefined;
+    /**
+     * Makes a new instance with specified navigation context, and optionally, initial view region.  If not specified,
+     * the view region will be the entire navigation context.
+     *
+     * @param {NavigationContext} navContext - the context in which navigation will take place
+     * @param {number} [start] - initial start of the view region
+     * @param {number} [end] - initial end of the view region
+     */
+    constructor(navContext: NavigationContext, start?: number, end?: number);
+    /**
+     * Makes copy of this object such that no methods on the copy will modify the original.
+     *
+     * @return {DisplayedRegionModel} a copy of this object
+     */
+    clone(): DisplayedRegionModel;
+    /**
+     * @return {NavigationContext} the navigation context with which this object was created
+     */
+    getNavigationContext(): NavigationContext;
+    /**
+     * @return {number} the current width of the view, in base pairs
+     */
+    getWidth(): number;
+    /**
+     * Gets a copy of the internally stored 0-indexed open interval that represents this displayed region.
+     *
+     * @return {OpenInterval} copy of the internally stored region
+     */
+    getContextCoordinates(): OpenInterval;
+    /**
+     * Gets the features that overlap this view region in the navigation context.
+     *
+     * @param {boolean} [includeGaps] - whether to include gaps in the results.  Default: true
+     * @return {FeatureSegment[]} list of feature intervals that overlap this view region
+     */
+    getFeatureSegments(includeGaps?: boolean): FeatureSegment[];
+    /**
+     * Gets the genomic locations that overlap this view region.  The results are guaranteed to not overlap each other.
+     *
+     * @return {ChromosomeInterval[]} list of genomic locations that overlap this view region.
+     */
+    getGenomeIntervals(): ChromosomeInterval[];
+    /**
+     * Safely sets the internal display interval, ensuring that it stays within the navigation context and makes sense.
+     * `start` and `end` should express a 0-indexed open interval of base numbers, [start, end).  This method will try
+     * to preserve the input length as much as possible.
+     *
+     * Errors if given a nonsensical interval, but does not error for intervals outside the navigation context.
+     *
+     * Returns this.
+     *
+     * @param {number} start - the (inclusive) start of the region interval as a base pair number
+     * @param {number} end - the (exclusive) end of the region interval as a base pair number
+     * @return {this}
+     * @throws {RangeError} if end is less than start, or the inputs are undefined/infinite
+     */
+    setRegion(start: number, end: number): this;
+    /**
+     * Pans the current region by a constant number of bases, also ensuring view boundaries stay within the genome.
+     * Negative numbers pull regions on the left into view (=pan right); positive numbers pull regions on the right into
+     * view (=pan left).
+     *
+     * Returns `this`.
+     *
+     * @param {number} numBases - number of base pairs to pan
+     * @return {this}
+     */
+    pan(numBases: number): this;
+    /**
+     * pan same width to left, pan left not same as drag left, coords get smaller
+     * @return {this}
+     */
+    panLeft(): this;
+    /**
+     * pan same width to right
+     * @return {this}
+     */
+    panRight(): this;
+    /**
+     * Multiplies the size of the current region by a factor, also ensuring view boundaries stay within the genome.
+     * Factors less than 1 zoom in (region gets shorter); factors greater than 1 zoom out (region gets longer).
+     * Additionally, one can specify the focal point of the zoom as the number of region widths from the left edge.  By
+     * default this is 0.5, which is the center of the region.
+     *
+     * Note that due to rounding, zoom() is approximate; a zoom(2) followed by a zoom(0.5) may still change the region
+     * boundaries by a base or two.
+     *
+     * Returns `this`.
+     *
+     * @param {number} factor - number by which to multiply this region's width
+     * @param {number} [focalPoint] - (optional) measured as number of region widths from the left edge.  Default: 0.5
+     * @return {this}
+     */
+    zoom(factor: number, focalPoint?: number): this;
+    /**
+     * @return {string} the currently displayed region in human-readable form
+     */
+    currentRegionAsString(): string;
+}
+export default DisplayedRegionModel;

package/dist/models/DownsamplingChoices.d.ts

@@ -0,0 +1,4 @@
+export declare enum DownsamplingChoices {
+    ALL = "all",
+    SAMPLE = "sample"
+}

package/dist/models/Feature.d.ts

@@ -0,0 +1,156 @@
+import ChromosomeInterval, { IChromosomeInterval } from "./ChromosomeInterval";
+import NavigationContext from "./NavigationContext";
+export type Strand = "+" | "-" | string;
+/**
+ * The properties of Feature without the methods.
+ */
+export interface IFeature {
+    name: string;
+    locus: IChromosomeInterval;
+    strand: Strand;
+    id?: string;
+}
+export declare const FORWARD_STRAND_CHAR = "+";
+export declare const REVERSE_STRAND_CHAR = "-";
+/**
+ * A feature, or annotation, in the genome.
+ *
+ * @implements {Serializable}
+ * @author Silas Hsu
+ */
+export declare class Feature {
+    locus: ChromosomeInterval;
+    strand: Strand;
+    name: string;
+    score?: any;
+    id?: string;
+    sequence: any;
+    variant?: any;
+    value?: any;
+    /**
+     * Makes a new instance with specified name and locus.  Empty names are valid.  If given `undefined` or `null`, it
+     * defaults to the locus as a string.
+     *
+     * @param {string} [name] - name of the feature
+     * @param {ChromosomeInterval} locus - genomic location of the feature
+     * @param {Strand} strand - strand info
+     */
+    constructor(name: string | undefined, locus: ChromosomeInterval, strand?: Strand, value?: any);
+    serialize(): IFeature;
+    static deserialize(object: IFeature): Feature;
+    /**
+     * @return {string} the name of this feature
+     */
+    getName(): string;
+    /**
+     * @return {ChromosomeInterval} the genomic location of this feature
+     */
+    getLocus(): ChromosomeInterval;
+    /**
+     * @return {number} the length of this feature's locus
+     */
+    getLength(): number;
+    /**
+     * @return {string} raw strand info of this instance
+     */
+    getStrand(): Strand;
+    /**
+     * @return {boolean} whether this feature is on the forward strand
+     */
+    getIsForwardStrand(): boolean;
+    /**
+     * @return {boolean} whether this feature is on the reverse strand
+     */
+    getIsReverseStrand(): boolean;
+    /**
+     * @return {boolean} whether this feature has strand info
+     */
+    getHasStrand(): boolean;
+    /**
+     * Shortcut for navContext.convertGenomeIntervalToBases().  Computes nav context coordinates occupied by this
+     * instance's locus.
+     *
+     * @param {NavigationContext} navContext - the navigation context for which to compute coordinates
+     * @return {OpenInterval[]} coordinates in the navigation context
+     */
+    computeNavContextCoordinates(navContext: NavigationContext): import("./OpenInterval").default[];
+}
+/**
+ * Everything a Feature is, plus a `value` prop.
+ *
+ * @author Silas Hsu
+ */
+export declare class NumericalFeature extends Feature {
+    value: number | undefined;
+    /**
+     * Sets value and returns this.
+     *
+     * @param {number} value - value to attach to this instance.
+     * @return {this}
+     */
+    withValue(value: number): this;
+}
+/**
+ * Everything a Feature is, plus a `color` prop.
+ *
+ * @author Daofeng Li
+ */
+export declare class ColoredFeature extends Feature {
+    color: string | undefined;
+    /**
+     * Sets value and returns this.
+     *
+     * @param {number} value - value to attach to this instance.
+     * @return {this}
+     */
+    withColor(color: string): this;
+}
+/**
+ * a JasparFeature.
+ *
+ * @author Daofeng Li
+ */
+export declare class JasparFeature extends Feature {
+    score: number | undefined;
+    matrixId: string | undefined;
+    /**
+     * Sets jaspar tf name and score and returns this.
+     *
+     * @param {number} score - jaspar score.
+     * @param {string} matrixId - jaspar matrixId.
+     * @return {this}
+     */
+    withJaspar(score: number, matrixId: string): this;
+}
+/**
+ * Everything a Feature is, plus a `values` prop.
+ *
+ * @author Daofeng Li
+ */
+export declare class NumericalArrayFeature extends Feature {
+    values: number[] | undefined;
+    /**
+     * Sets values and returns this.
+     *
+     * @param {number[]} values - value to attach to this instance.
+     * @return {this}
+     */
+    withValues(values: readonly number[]): this;
+}
+/**
+ * the feature for a fiber or molecular, with the on and off relative position from start.
+ *
+ * @author Daofeng Li
+ */
+export declare class Fiber extends Feature {
+    ons: number[] | undefined;
+    offs: number[] | undefined;
+    /**
+     * Sets values and returns this.
+     *
+     * @param {number[]} values - value to attach to this instance.
+     * @return {this}
+     */
+    withFiber(score: number | string, onString: string, offString: string): this;
+}
+export default Feature;

package/dist/models/FeatureAggregator.d.ts

@@ -0,0 +1,67 @@
+import { Feature } from "./Feature";
+import DisplayedRegionModel from "./DisplayedRegionModel";
+/**
+ * Available aggregators.  Note: SUM, MEAN, MIN, and MAX requires each record to have a `value` prop.
+ */
+export declare const AggregatorTypes: {
+    MEAN: string;
+    SUM: string;
+    COUNT: string;
+    MIN: string;
+    MAX: string;
+    IMAGECOUNT: string;
+};
+export declare const ArrayAggregatorTypes: {
+    MEAN: string;
+};
+/**
+ * calculate mean value of each array elements and save to a new array
+ * [
+ *  [1,2,3],
+ *  [4,5,6]
+ * ]
+ * to
+ * [2.5, 3.5, 4.5]
+ * missing number is any position is filled with 0 in original array
+ *
+ * @param records array of value objest, data stored in values property
+ * @param dataKeyName default to `values`
+ */
+export declare function calMeanOfArrays(records: any[], dataKeyName: string): number[];
+export declare const DefaultAggregators: {
+    types: {
+        MEAN: string;
+        SUM: string;
+        COUNT: string;
+        MIN: string;
+        MAX: string;
+        IMAGECOUNT: string;
+    };
+    fromId(id: string): any;
+};
+export declare const DefaultArrayAggregators: {
+    types: {
+        MEAN: string;
+    };
+    fromId(id: string): any;
+};
+/**
+ * Aggregator of features.  Includes methods to construct x-to-data maps.
+ *
+ * @author Silas Hsu
+ */
+export declare class FeatureAggregator {
+    /**
+     * Constructs a mapping from x coordinate to all Features overlapping that location.  The mapping will be limited
+     * to the range [0, width).
+     *
+     * @param {Feature[]} features - features to use
+     * @param {DisplayedRegionModel} viewRegion - used to compute drawing coordinates
+     * @param {number} width - width of the visualization
+     * @return {Feature[][]} mapping from x coordinate to all Features overlapping that location
+     */
+    makeXMap(features: Feature[], viewRegion: DisplayedRegionModel, width: number, useCenter?: boolean): any;
+    makeXWindowMap(features: Feature[], viewRegion: DisplayedRegionModel, width: number, useCenter: boolean | undefined, windowSize: number): {
+        [x: number]: Feature[];
+    };
+}

package/dist/models/FeatureArranger.d.ts

@@ -0,0 +1,48 @@
+import DisplayedRegionModel from "./DisplayedRegionModel";
+import { Feature } from "./Feature";
+import { PlacedFeature } from "./getXSpan/FeaturePlacer";
+import OpenInterval from "./OpenInterval";
+import { SortItemsOptions } from "./SortItemsOptions";
+export interface PlacedFeatureGroup {
+    feature: Feature;
+    row: number;
+    xSpan: OpenInterval;
+    placedFeatures: PlacedFeature[];
+}
+export type PaddingFunc = (feature: Feature, xSpan: OpenInterval) => number;
+/**
+ * Return value from FeatureArranger::arrange()
+ */
+interface FeatureArrangementResult {
+    placements: PlacedFeatureGroup[];
+    numRowsAssigned: number;
+    numHidden: number;
+}
+export declare class FeatureArranger {
+    /**
+     * Assigns rows to each placed feature, mutating the objects.  Returns the number of rows assigned.
+     *
+     * @param {PlacedFeature[]} groups - placed features to modify
+     * @param {number | PaddingFunc} padding - getter of padding.  See the arrange() method for more info.
+     * @return {number} the number of rows assigned
+     */
+    _assignRows(groups: PlacedFeatureGroup[] | any, padding: number | PaddingFunc, sortItems: SortItemsOptions): number;
+    _combineAdjacent(placements: PlacedFeature[]): PlacedFeatureGroup[];
+    /**
+     * Calculates draw locations for an array of features, as well rows indices to minimize overlaps.  This method skips
+     * features too small to draw; the number skipped shall be in the return result.
+     *
+     * The optional `padding` parameter configures horizontal padding for intervals:
+     * * If `padding` is a number, all intervals will have that constant padding.
+     * * If `padding` is a function, it should take a feature and return the desired horizontal padding.
+     *
+     * @param {Feature[]} features - features to draw
+     * @param {DisplayedRegionModel} viewRegion - used to compute drawing coordinates
+     * @param {number} width - width of the visualization
+     * @param {number | PaddingFunc} [padding] - horizontal padding for intervals.  Default 0.
+     * @param {number} [hiddenPixels] - hide an item when its length less than this value.  Default 0.5
+     * @return {FeatureArrangementResult} suggested draw location info
+     */
+    arrange(features: Feature[], viewRegion: DisplayedRegionModel, width: number, padding?: number | PaddingFunc, hiddenPixels?: number, sortItems?: SortItemsOptions): FeatureArrangementResult;
+}
+export default FeatureArranger;

package/dist/models/FeatureSegment.d.ts

@@ -0,0 +1,63 @@
+import OpenInterval from "./OpenInterval";
+import ChromosomeInterval from "./ChromosomeInterval";
+/**
+ * A 0-indexed open interval within a Feature.  Or, put another way, attaches an interval to a Feature.
+ *
+ * @author Silas Hsu
+ * @see Feature
+ */
+export declare class FeatureSegment {
+    readonly feature: any;
+    readonly relativeStart: number;
+    readonly relativeEnd: number;
+    /**
+     * Makes a new instance, attaching a interval to a Feature.  If start and end are not provided, the interval
+     * defaults to the entire length of the feature.  The start and end parameters should express a *0-indexed open
+     * interval*.
+     *
+     * @param {Feature} feature - the interval's feature
+     * @param {number} [start] - start base of the interval, relative to the feature's start
+     * @param {number} [end] - end base of the interval, relative to the feature's start
+     * @throws {RangeError} if end is before start or the interval lies outside the feature
+     */
+    constructor(feature: any, start?: number, end?: number | undefined);
+    get start(): number;
+    get end(): number;
+    /**
+     * @return {OpenInterval} new OpenInterval containing this segment's relative start and end.
+     */
+    toOpenInterval(): OpenInterval;
+    /**
+     * @return {string} the attached feature's name
+     */
+    getName(): string;
+    /**
+     * @return {number} this interval's length
+     */
+    getLength(): number;
+    /**
+     * @return {ChromosomeInterval} the genomic location that this segment covers
+     */
+    getLocus(): ChromosomeInterval;
+    /**
+     * Intersects this and another FeatureSegment, and returns the result as a new FeatureSegment.  Returns `null` if
+     * the *segments' features are different* or if there is no overlap.
+     *
+     * @param {FeatureSegment} other - other FeatureSegment to intersect
+     * @return {FeatureSegment} intersection of this segment and the other one, or null if none exists
+     */
+    getOverlap(other: FeatureSegment): FeatureSegment | null;
+    /**
+     * Intersects this and a genome location, and returns the result as a new FeatureSegment using the same Feature
+     * that is attached to this.  Returns null if the genome location does not intersect with this location at all.
+     *
+     * @param {ChromosomeInterval} chrInterval - input genome location
+     * @return {FeatureSegment} intersection of this and the input genomic location
+     */
+    getGenomeOverlap(chrInterval: ChromosomeInterval): FeatureSegment | null;
+    /**
+     * @return {string} human-readable representation of this interval
+     */
+    toString(): string;
+    toStringWithOther(other: FeatureSegment): string;
+}

package/dist/models/FlankingStrategy.d.ts

@@ -0,0 +1,72 @@
+import Feature from "./Feature";
+import ChromosomeInterval from "./ChromosomeInterval";
+import Genome from "./Genome";
+type FlankingStrategyType = 0 | 1 | 2;
+/**
+ * A FlankingStrategy without the methods.
+ */
+export interface IFlankingStrategy {
+    type: FlankingStrategyType;
+    upstream: number;
+    downstream: number;
+}
+/**
+ * An algorithm that modifies feature coordinates.
+ *
+ * @implements {Serializable}
+ * @author Silas Hsu
+ */
+declare class FlankingStrategy {
+    type: FlankingStrategyType;
+    upstream: number;
+    downstream: number;
+    static SURROUND_ALL: FlankingStrategyType;
+    static SURROUND_START: FlankingStrategyType;
+    static SURROUND_END: FlankingStrategyType;
+    /**
+     * Makes a new instance.  Does not do any sanity checks; nonsense parameters will cause `makeFlankedFeature` to
+     * return null.
+     *
+     * @param {FlankingStrategyType} [type] - type of strategy; see static variables for a selection
+     * @param {number} [upstream] - number of bases upstream to expand input features
+     * @param {number} [downstream] - number of bases downstream to expand input features
+     */
+    constructor(type?: FlankingStrategyType, upstream?: number, downstream?: number);
+    /**
+     * @return {this}
+     */
+    serialize(): this;
+    /**
+     * @param {IFlankingStrategy} object
+     * @return {IFlankingStrategy}
+     */
+    static deserialize(object: IFlankingStrategy): FlankingStrategy;
+    /**
+     * Shallowly clones this, sets a prop to a value, and returns the result.
+     *
+     * @param {string} prop - the prop to set
+     * @param {any} value - the value to set
+     * @return {FlankingStrategy} cloned and modified version of this
+     */
+    cloneAndSetProp(prop: string, value: any): FlankingStrategy;
+    /**
+     * Makes a new Feature with a locus that flanks some part of the input Feature, depending on strategy type.  The
+     * genome parameter ensures that the modified locus stays within the genome.  If the input Feature is not in the
+     * genome at all, returns null.
+     *
+     * @param {Feature} feature - feature whose coordinates to use
+     * @param {Genome} genome - the genome in which this feature is located
+     * @return {Feature} new Feature whose locus is based off the input Feature
+     */
+    makeFlankedFeature(feature: Feature, genome: Genome): Feature | null;
+    /**
+     * From the input genomic location, makes a new location flanking some part of it depending on this strategy type.
+     * Does no checks to ensure the output is within the genome.
+     *
+     * @param {ChromosomeInterval} locus - location to flank
+     * @param {boolean} isForwardStrand - strand of the input; affects what is upstream and downstream
+     * @return {ChromosomeInterval} flanked location
+     */
+    _makeFlankedCoordinates(locus: ChromosomeInterval, isForwardStrand: boolean): ChromosomeInterval;
+}
+export default FlankingStrategy;

package/dist/models/Gene.d.ts

@@ -0,0 +1,56 @@
+import Feature from "./Feature";
+import OpenInterval from "./OpenInterval";
+import { FeatureSegment } from "./FeatureSegment";
+export interface IdbRecord {
+    score?: any;
+    id: string;
+    name?: string;
+    chrom: string;
+    strand: string;
+    txStart: number;
+    txEnd: number;
+    cdsStart: number;
+    cdsEnd: number;
+    exonStarts: string;
+    exonEnds: string;
+    transcriptionClass?: string;
+    description?: string;
+    collection?: string;
+}
+/**
+ * A data container for gene annotations.
+ *
+ * @author Daofeng Li and Silas Hsu
+ */
+declare class Gene extends Feature {
+    dbRecord: any;
+    id: string;
+    description?: string;
+    transcriptionClass?: string;
+    collection?: string;
+    _translated: OpenInterval[] | null;
+    _utrs: OpenInterval[] | null;
+    /**
+       * Constructs a new Gene, given an entry from MongoDB.  The other parameters calculate nav context coordinates.
+      @example
+      {
+      }
+       * @param {dbRecord} record - dbRecord object to use
+       * @param {trackModel} trackModel for gene search information
+       */
+    constructor(dbRecord: IdbRecord);
+    get translated(): OpenInterval[] | null;
+    get utrs(): OpenInterval[] | null;
+    /**
+     * Parses `this.dbRecord` and sets `this._translated` and `this._utrs`.
+     */
+    _parseDetails(): void;
+    /**
+     * @return {object} exons as lists of FeatureSegment
+     */
+    getExonsAsFeatureSegments(): {
+        translated: FeatureSegment[];
+        utrs: FeatureSegment[];
+    };
+}
+export default Gene;

package/dist/models/Genome.d.ts

@@ -0,0 +1,48 @@
+import NavigationContext from "./NavigationContext";
+import ChromosomeInterval from "./ChromosomeInterval";
+import Chromosome from "./Chromosome";
+/**
+ * A named set of chromosomes.
+ *
+ * @author Silas Hsu
+ */
+export declare class Genome {
+    private _name;
+    private _chromosomes;
+    private _nameToChromosome;
+    /**
+     * Makes a new instance, with name and list of chromosomes.  For best results, chromosomes should have unique names.
+     *
+     * @param {string} name - name of the genome
+     * @param {Chromosome[]} chromosomes - list of chromosomes in the genome
+     */
+    constructor(name: string, chromosomes: Chromosome[]);
+    /**
+     * @return {string} this genome's name
+     */
+    getName(): string;
+    /**
+     * Gets a chromosome with the specified name.  Returns null if there is no such chromosome.
+     *
+     * @param {string} name - chromosome name to look up
+     * @return {Chromosome} chromosome with the query name, or null if not found
+     */
+    getChromosome(name: string): Chromosome;
+    /**
+     * Intersects a genomic location with this genome.  If there is no overlap, then returns null.  Possible reasons for
+     * null include unknown chromosome name or an interval past the end of a chromosome.  Can be used to check/ensure a
+     * location actually lies within the genome.
+     *
+     * @param {ChromosomeInterval} chrInterval - genomic location to intersect with the genome
+     * @return {ChromosomeInterval} intersection result, or null if there is no overlap at all
+     */
+    intersectInterval(chrInterval: ChromosomeInterval): ChromosomeInterval | null;
+    /**
+     * Makes a NavigationContext representing this genome.  It will have the same name as the genome, and the
+     * features/segments will consist of whole chromosomes.
+     *
+     * @return {NavigationContext} NavigationContext representing this genome
+     */
+    makeNavContext(): NavigationContext;
+}
+export default Genome;

package/dist/models/GraphNode.d.ts

@@ -0,0 +1,46 @@
+import { Feature, Strand } from "./Feature";
+import ChromosomeInterval, { IChromosomeInterval } from "./ChromosomeInterval";
+/**
+ * The properties of GraphNode without the methods.
+ */
+export interface IGraphNode {
+    name: string;
+    locus: IChromosomeInterval;
+    strand: Strand;
+    rank: number;
+}
+/**
+ * A GraphNode, in the graph genome.
+ * a feature with rank, maybe other methods and props in future so in a separate file
+ * @author Daofeng Li
+ */
+export declare class GraphNode extends Feature {
+    locus: ChromosomeInterval;
+    rank: number;
+    /**
+     *
+     * @param {string} [name] - name of the node
+     * @param {ChromosomeInterval} locus - genomic location of the node
+     */
+    constructor(name: string, locus: ChromosomeInterval, rank?: number);
+    serialize(): IGraphNode;
+    static deserialize(object: IGraphNode): GraphNode;
+    getRank(): number;
+}
+/**
+ * the raw data from brgfa file record
+ * @param raw
+ * {len: 8677
+name: "s73410"
+rank: 0
+sname: "chr7"
+soff: 26715364}
+ */
+export interface IRawNode {
+    len: number;
+    name: string;
+    rank: number;
+    sname: string;
+    soff: number;
+}
+export declare function nodeFromRawNode(raw: IRawNode): GraphNode;