wuepgg3-track 1.0.2

package/dist/models/ImageRecord.d.ts

@@ -0,0 +1,12 @@
+import Feature from "./Feature";
+import BedRecord from "./BedRecord";
+/**
+ * A data container for a idr images.
+ *
+ * @author Daofeng Li
+ */
+declare class ImageRecord extends Feature {
+    images: any[];
+    constructor(bedRecord: BedRecord);
+}
+export default ImageRecord;

package/dist/models/Json5Fetcher.d.ts

@@ -0,0 +1,10 @@
+declare class Json5Fetcher {
+    /**
+     * Gets JSON5 from a URL.
+     *
+     * @param {string} url - the URL from which to fetch
+     * @return {Promise<Object>} promise for parsed JSON
+     */
+    get(url: string): Promise<any>;
+}
+export default Json5Fetcher;

package/dist/models/LinearDrawingModel.d.ts

@@ -0,0 +1,75 @@
+import DisplayedRegionModel from "./DisplayedRegionModel";
+import OpenInterval from "./OpenInterval";
+import { FeatureSegment } from "./FeatureSegment";
+/**
+ * Utility class for converting between pixels and base numbers.
+ *
+ * @author Silas Hsu
+ */
+declare class LinearDrawingModel {
+    _viewRegion: DisplayedRegionModel;
+    _drawWidth: number;
+    _pixelsPerBase: number;
+    _basesPerPixel: number;
+    /**
+     * Makes a new instance.
+     *
+     * @param {DisplayedRegionModel} viewRegion - the displayed region
+     * @param {number} drawWidth - the width of the canvas/svg/etc on which to draw
+     */
+    constructor(viewRegion: DisplayedRegionModel, drawWidth: number);
+    /**
+     * @return {number} the drawing width with which this model was created
+     */
+    getDrawWidth(): number;
+    /**
+     * Gets the horizontal width in pixels required to represent a number of bases.
+     *
+     * @param {number} bases - width in number of bases
+     * @return {number} width in pixels
+     */
+    basesToXWidth(bases: number): number;
+    /**
+     * Gets how many bases represented by a horizontal span of the SVG.
+     *
+     * @param {number} pixels - width of a horizontal span
+     * @return {number} width in number of bases
+     */
+    xWidthToBases(pixels: number): number;
+    /**
+     * Given an nav context coordinate, gets the X coordinate that represents that base.
+     *
+     * @param {number} base - nav context coordinate
+     * @return {number} X coordinate that represents the input base
+     */
+    baseToX(base: number): number;
+    /**
+     * Given an X coordinate representing a base, gets the nav context coordinate.
+     *
+     * @param {number} pixel - X coordinate that represents a base
+     * @return {number} nav context coordinate
+     */
+    xToBase(pixel: number): number;
+    /**
+     * Converts an interval of bases to an interval of X coordinates.
+     *
+     * @param {OpenInterval} baseInterval - interval of bases to convert
+     * @return {OpenInterval} x draw interval
+     */
+    baseSpanToXSpan(baseInterval: OpenInterval): OpenInterval;
+    /**
+     * Converts an interval of bases to an interval of X coordinates, but just the center.
+     *
+     * @param {OpenInterval} baseInterval - interval of bases to convert
+     * @return {OpenInterval} x draw interval
+     */
+    baseSpanToXCenter(baseInterval: OpenInterval): OpenInterval;
+    /**
+     * Gets the segment coordinates that a pixel coordinate represents.
+     *
+     * @param {number} pixel - pixel coordinate that represents a base
+     * @return {FeatureSegment} segment coordinate that the pixel represents
+     */
+    xToSegmentCoordinate(pixel: number): FeatureSegment;
+}
+export default LinearDrawingModel;

package/dist/models/LogChoices.d.ts

@@ -0,0 +1,4 @@
+export declare enum LogChoices {
+    AUTO = "none",
+    BASE10 = "log10"
+}

package/dist/models/MethylCRecord.d.ts

@@ -0,0 +1,41 @@
+import Feature from "./Feature";
+import BedRecord from "./BedRecord";
+interface AggregationByRecordsResult {
+    depth: number;
+    contextValues: Array<{
+        context: string;
+        value: number;
+    }>;
+}
+interface AggregationByStrandResult {
+    combined: AggregationByRecordsResult;
+    forward: AggregationByRecordsResult;
+    reverse: AggregationByRecordsResult;
+}
+/**
+ * A data container for a MethylC record.
+ *
+ * @author Daofeng Li
+ */
+declare class MethylCRecord extends Feature {
+    /**
+     * Combines all MethylCRecords that (presumably) are in one pixel.  See schema below the function for return schema.
+     * If passed an empty array, returns null.
+     *
+     * @param {MethylCRecord[]} records
+     * @return {AggregationResult}
+     */
+    static aggregateRecords(records: MethylCRecord[]): AggregationByRecordsResult | null;
+    /**
+     * Combines all MethylCRecords that (presumably) are in one pixel.  See schema below the function for return schema.
+     *
+     * @param {MethylCRecord[]} records
+     * @return {Object}
+     */
+    static aggregateByStrand(records: MethylCRecord[]): AggregationByStrandResult;
+    context: any;
+    value: number;
+    depth: number;
+    constructor(bedRecord: BedRecord);
+}
+export default MethylCRecord;

package/dist/models/NavContextBuilder.d.ts

@@ -0,0 +1,17 @@
+import NavigationContext from "./NavigationContext";
+export interface Gap {
+    contextBase: number;
+    length: number;
+}
+export declare class NavContextBuilder {
+    private _baseNavContext;
+    private _gaps;
+    private _cumulativeGapBases;
+    constructor(baseNavContext: NavigationContext);
+    /**
+     * @param gaps
+     */
+    setGaps(gaps: Array<any>): void;
+    build(): NavigationContext;
+    convertOldCoordinates(base: number): number;
+}

package/dist/models/NavigationContext.d.ts

@@ -0,0 +1,168 @@
+import OpenInterval from "./OpenInterval";
+import { FeatureSegment } from "./FeatureSegment";
+import ChromosomeInterval from "./ChromosomeInterval";
+import { Feature } from "./Feature";
+/**
+ * A implicit coordinate system for the entire genome or a gene set view.  It represents everywhere that a user could
+ * potentially navigate and view.
+ *
+ * A context constructs this coordinate system through an ordered list of features.  Features in NavigationContexts must
+ * have non-empty, unique names.  In addition to this implicit coordinate system, NavContext methods also support
+ * feature coordinates, which are a feature and base number relative to the start of the feature.
+ *
+ * @author Silas Hsu
+ */
+declare class NavigationContext {
+    _name: string;
+    _features: Feature[];
+    _sortedFeatureStarts: number[];
+    _minCoordinateForFeature: Map<Feature, number>;
+    _featuresForChr: {
+        [chr: string]: Feature[];
+    };
+    _totalBases: number;
+    /**
+     * Makes a special "feature" representing a gap in the genome.  To use, insert such objects into the feature list
+     * during NavigationContext construction.
+     *
+     * @param {number} length - length of the gap in bases
+     * @param {string} [name] - custom name of the gap feature
+     * @return {Feature} a special "feature" representing a gap in the genome.
+     */
+    static makeGap(length: number, name?: string): Feature;
+    /**
+     * @param {Feature} feature - feature to inspect
+     * @return {boolean} whether the feature represents a gap in the genome
+     */
+    static isGapFeature(feature: Feature): boolean;
+    /**
+     * Makes a new instance.  Features must have non-empty, unique names.  The `isGenome` parameter does not change any
+     * of the instance's functionality, but if it is true, it optimizes mapping functions.
+     *
+     * @param {string} name - name of this context
+     * @param {Feature[]} features - list of features
+     * @param {boolean} isGenome - whether the context covers the entire genome
+     * @throws {Error} if the feature list has a problem
+     */
+    constructor(name: string, features: Array<any>);
+    /**
+     * If the input segment is in a reverse strand feature, returns a new segment that is the same size, but moved to
+     * the other end of the feature.  In effect, it rotates a feature segment 180 degrees about the feature's center.
+     *
+     * Otherwise, returns the input unmodified.
+     *
+     * @example
+     * let feature: Feature; // Pretend it has a length of 10
+     * const segment = new FeatureSegment(feature, 2, 4);
+     * this._flipIfReverseStrand(segment); // Returns new segment [6, 8)
+     *
+     * @param {FeatureSegment} segment - the feature segment to flip if on the reverse strand
+     * @return {FeatureSegment} flipped feature segment, but only if the input was on the reverse strand
+     */
+    _flipIfReverseStrand(segment: FeatureSegment): FeatureSegment;
+    /**
+     * @return {string} this navigation context's name, as specified in the constructor
+     */
+    getName(): string;
+    /**
+     * Gets the internal feature list.  This list should be treated as read-only; modifying its elements causes
+     * undefined behavior.
+     *
+     * @return {Feature[]} the internal feature list for this context
+     */
+    getFeatures(): Feature[];
+    /**
+     * @return {number} the total number of bases in this context, i.e. how many bases are navigable
+     */
+    getTotalBases(): number;
+    /**
+     * Given a context coordinate, gets whether the base is navigable.
+     *
+     * @param {number} base - context coordinate
+     * @return {boolean} whether the base is navigable
+     */
+    getIsValidBase(base: number): boolean;
+    /**
+     * Gets the lowest context coordinate that the input feature has.  Throws an error if the feature cannot be found.
+     *
+     * Note that if the feature is on the forward strand, the result will represent the feature's start.  Otherwise, it
+     * represents the feature's end.
+     *
+     * @param {Feature} feature - the feature to find
+     * @return {number} the lowest context coordinate of the feature
+     * @throws {RangeError} if the feature is not in this context
+     */
+    getFeatureStart(feature: Feature): number;
+    /**
+     * Given a context coordinate, gets the feature in which it is located.  Returns a FeatureSegment that has 1 length,
+     * representing a single base number relative to the feature's start.
+     *
+     * @param {number} base - the context coordinate to look up
+     * @return {FeatureSegment} corresponding feature coordinate
+     * @throws {RangeError} if the base is not in this context
+     */
+    convertBaseToFeatureCoordinate(base: number): FeatureSegment;
+    /**
+     * Given a segment of a feature from this navigation context, gets the context coordinates the segment occupies.
+     *
+     * @param {FeatureSegment} segment - feature segment from this context
+     * @return {OpenInterval} context coordinates the feature segment occupies
+     */
+    convertFeatureSegmentToContextCoordinates(segment: FeatureSegment): OpenInterval;
+    /**
+     * Converts genome coordinates to an interval of context coordinates.  Since coordinates can map
+     * to multiple features, or none at all, this method returns a list of OpenInterval.
+     *
+     * @param {ChromosomeInterval} chrInterval - genome interval
+     * @return {OpenInterval[]} intervals of context coordinates
+     */
+    convertGenomeIntervalToBases(chrInterval: ChromosomeInterval): OpenInterval[];
+    /**
+     * Converts a context coordinate to one that ignores gaps in this instance.  Or, put another way, if we removed all
+     * gaps in this instance, what would be the context coordinate of `base` be?
+     *
+     * @example
+     * navContext = [10bp feature, 10bp gap, 10bp feature]
+     * navContext.toGaplessCoordinate(5); // Returns 5
+     * navContext.toGaplessCoordinate(15); // Returns 10
+     * navContext.toGaplessCoordinate(25); // Returns 15
+     *
+     * @param {number} base - the context coordinate to convert
+     * @return {number} context coordinate if gaps didn't exist
+     */
+    toGaplessCoordinate(base: number): number;
+    /**
+     * Parses an location in this navigation context.  Should be formatted like "$chrName:$startBase-$endBase" OR
+     * "$featureName".  We expect 0-indexed intervals.
+     *
+     * Returns an open interval of context coordinates.  Throws RangeError on parse failure.
+     *
+     * @param {string} str - the string to parse
+     * @return {OpenInterval} the context coordinates represented by the string
+     * @throws {RangeError} when parsing an interval outside of the context or something otherwise nonsensical
+     */
+    parse(str: string): OpenInterval;
+    /**
+     * Queries features that overlap an open interval of context coordinates.  Returns a list of FeatureSegment.
+     *
+     * @param {number} queryStart - (inclusive) start of interval, as a context coordinate
+     * @param {number} queryEnd - (exclusive) end of interval, as a context coordinate
+     * @param {boolean} [includeGaps] - whether to include gaps in the results.  Default: true
+     * @return {FeatureSegment[]} list of feature intervals
+     */
+    getFeaturesInInterval(queryStart: number, queryEnd: number, includeGaps?: boolean): FeatureSegment[];
+    /**
+     * Queries genomic locations that overlap an open interval of context coordinates.  The results are guaranteed to
+     * not overlap each other.
+     *
+     * @param {number} queryStart - (inclusive) start of interval, as a context coordinate
+     * @param {number} queryEnd - (exclusive) end of interval, as a context coordinate
+     * @return {ChromosomeInterval[]} list of genomic locations
+     */
+    getLociInInterval(queryStart: number, queryEnd: number): ChromosomeInterval[];
+    /**
+     * check if a feature is in current context
+     */
+    hasFeatureWithName(queryFeature: Feature): boolean;
+}
+export default NavigationContext;

package/dist/models/OpenInterval.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Something with props `start` and `end` which represent a 0-indexed open interval
+ */
+export interface IOpenInterval {
+    start: number;
+    end: number;
+}
+/**
+ * A 0-indexed open interval.  Intervals are iterable, so code can take advantage of the spread operator:
+ *     `myFunction(...interval)` is equivalent to `myFunction(interval.start, interval.end)`
+ *
+ * @implements {Serializable}
+ * @author Silas Hsu
+ */
+export default class OpenInterval implements IOpenInterval {
+    readonly start: number;
+    readonly end: number;
+    /**
+     * Makes a new instance.  The input should represent a 0-indexed open interval.
+     *
+     * @param {number} start - start of the interval, inclusive
+     * @param {number} end - end of the interval, exclusive
+     * @throws {RangeError} if the end is less than the start
+     */
+    constructor(start: number, end: number);
+    /**
+     * @returns {IOpenInterval}
+     */
+    serialize(): IOpenInterval;
+    /**
+     * Creates an OpenInterval from an object.
+     *
+     * @param {IOpenInterval} object - object to use
+     * @return {OpenInterval} OpenInterval created from the object
+     */
+    static deserialize(object: IOpenInterval): OpenInterval;
+    /**
+     * Enables the spread operator for OpenIntervals.
+     */
+    [Symbol.iterator](): Generator<number, void, unknown>;
+    /**
+     * Intersects this and another OpenInterval, and returns the result in as a new OpenInterval.  Returns null if there
+     * is no intersection at all.
+     *
+     * @param {OpenInterval} other - other OpenInterval to intersect
+     * @return {OpenInterval} intersection of this and the other interval
+     */
+    getOverlap(other: OpenInterval): OpenInterval | null;
+    /**
+     * @return {number} the length of this interval
+     */
+    getLength(): number;
+    /**
+     * @return {string} human-readable representation of this instance
+     */
+    toString(): string;
+}

package/dist/models/QBed.d.ts

@@ -0,0 +1,15 @@
+import Feature from "./Feature";
+import BedRecord from "./BedRecord";
+/**
+ * A data container for a qBED object.
+ *
+ * @author Daofeng Li and Arnav Moudgil
+ */
+declare class QBed extends Feature {
+    annotation: any;
+    value: number;
+    relativeX: number | undefined;
+    relativeY: number | undefined;
+    constructor(bedRecord: BedRecord);
+}
+export default QBed;

package/dist/models/RegionExpander.d.ts

@@ -0,0 +1,51 @@
+import OpenInterval from "./OpenInterval";
+import DisplayedRegionModel from "./DisplayedRegionModel";
+/**
+ * Data describing an expanded view region.
+ */
+export interface ViewExpansion {
+    /**
+     * Total width, in pixels, of the expanded view
+     */
+    visWidth: number;
+    /**
+     * Expanded region
+     */
+    visRegion: DisplayedRegionModel;
+    /**
+     * The X range of pixels that would display the unexpanded region
+     */
+    viewWindow: OpenInterval;
+    /**
+     * Unexpanded region; the region displayed in the viewWindow
+     */
+    viewWindowRegion: DisplayedRegionModel;
+}
+/**
+ * Utility class that does calculations related to expanding view regions for the purposes of scrolling.
+ *
+ * @author Silas Hsu
+ */
+export declare class RegionExpander {
+    multipleOnEachSide: number;
+    static DEFAULT_EXPANSION: number;
+    /**
+     * @return a RegionExpander which does not do any expansion at all.
+     */
+    static makeIdentityExpander(): RegionExpander;
+    zoomRatio: number;
+    /**
+     * @param {number} multipleOnEachSide - magnitude of expansion on each side, as a multiple of region width.
+     */
+    constructor(multipleOnEachSide?: number);
+    /**
+     * Calculates an expansion of a view region from the input pixel width and region model.  Returns both the expanded
+     * region and how many pixels on each side of the orignal view to allocate to display additional data.  Handles
+     * cases such expanding near the edge of the genome, so that views will always remain inside the genome.
+     *
+     * @param {DisplayedRegionModel} region - the region that the unexpanded view will show
+     * @param {number} visWidth - the width, in pixels, of the view to expand
+     * @return {ViewExpansion} - data representing aspects of an expanded region
+     */
+    calculateExpansion(region: DisplayedRegionModel, visWidth: number): ViewExpansion;
+}

package/dist/models/RegionSet.d.ts

@@ -0,0 +1,85 @@
+import Feature, { IFeature } from "./Feature";
+import NavigationContext from "./NavigationContext";
+import FlankingStrategy, { IFlankingStrategy } from "./FlankingStrategy";
+import Genome from "./Genome";
+/**
+ * A RegionSet without methods.
+ */
+export interface IRegionSet {
+    name: string;
+    features: IFeature[];
+    genomeName: string;
+    flankingStrategy: IFlankingStrategy;
+    id?: any;
+    genome?: any;
+}
+/**
+ * A set of features that undergoes some configuration before being exported to a navigation context.
+ *
+ * @implements {Serializable}
+ * @author Silas Hsu
+ */
+declare class RegionSet {
+    name: string;
+    features: Feature[];
+    genome: Genome;
+    flankingStrategy: FlankingStrategy;
+    genomeName: string;
+    id: any;
+    static MIN_REGION_LENGTH: number;
+    /**
+     * Makes a new instance.  The flankingStrategy parameter is used to modify all features before constructing a
+     * NavigationContext.
+     *
+     * @param {string} [name] - name of this region set
+     * @param {Feature[]} [features] - list of features in this set
+     * @param {Genome} genome - genome to which the features belong
+     * @param {FlankingStrategy} flankingStrategy - feature modifier
+     */
+    constructor(name: string, features: Feature[], genome: Genome, flankingStrategy: FlankingStrategy, genomeName?: string, id?: any);
+    serialize(): IRegionSet;
+    static deserialize(object: IRegionSet): RegionSet;
+    /**
+     * Shallowly clones this, sets a prop to a value, and returns the result.
+     *
+     * @param {string} propName - the prop to set
+     * @param {any} value - the value to set
+     * @return {RegionSet} cloned and modified version of this
+     */
+    cloneAndSet(propName: string, value: any): RegionSet;
+    /**
+     * Clones this, and then adds a new feature to this set.  Features must have a valid name, and be in the genome;
+     * otherwise, an error will result.
+     *
+     * @param {Feature} feature - the feature to add
+     * @return {RegionSet} cloned and modified version of this
+     * @throws {RangeError} if the input feature is invalid in some way
+     */
+    cloneAndAddFeature(feature: Feature): RegionSet;
+    /**
+     * Clones this, and then deletes a feature from this set.
+     *
+     * @param {number} index - index of the feature to delete
+     * @return {RegionSet} cloned and modified version of this
+     */
+    cloneAndDeleteFeature(index: number): RegionSet;
+    /**
+     * Clones this, and then put all features on + strand.
+     *
+     * @return {RegionSet} cloned and modified version of this
+     */
+    cloneAndAllPlusStrand(): RegionSet;
+    /**
+     * Uses the associated FlankingStrategy to return a list of features originating from the features in this set.
+     *
+     * @return {Feature[]} list of flanked features
+     */
+    makeFlankedFeatures(): (Feature | null)[];
+    /**
+     * Equivalent to calling {@link makeFlankedFeatures()} and then making a navigation context out of them.
+     *
+     * @return {NavigationContext} - navigation context from flanked features
+     */
+    makeNavContext(): NavigationContext;
+}
+export default RegionSet;

package/dist/models/RepeatMaskerFeature.d.ts

@@ -0,0 +1,61 @@
+import Feature from "./Feature";
+export interface RepeatDASFeature {
+    genoLeft: string;
+    label: string;
+    max: number;
+    milliDel: string;
+    milliDiv: string;
+    milliIns: string;
+    min: number;
+    orientation: string;
+    repClass: string;
+    repEnd: string;
+    repFamily: string;
+    repLeft: string;
+    repStart: string;
+    score: number;
+    segment: string;
+    swScore: string;
+    type: string;
+    _chromId: number;
+}
+/**
+ * A data container for a RepeatMasker record.
+ *
+ * @author Daofeng Li
+ */
+export declare class RepeatMaskerFeature extends Feature {
+    static DEFAULT_CLASS_COLORS: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        11: string;
+        12: string;
+    };
+    repClass: string;
+    repFamily: string;
+    milliDiv: string;
+    _value: number | null;
+    /**
+     * Constructs a new rmskRecord, given a properly-structured DASFeature
+     *
+     * @param {RepeatDASFeature} record - DASFeature to use
+     */
+    constructor(rmskRecord: RepeatDASFeature);
+    get repeatValue(): number;
+    /**
+     * @return {number} the repeat class ID
+     */
+    getCategoryId(): number;
+    /**
+     * @return {string} human-readable description of the repeat class
+     */
+    getClassDetails(): string;
+}

package/dist/models/ScaleChoices.d.ts

@@ -0,0 +1,4 @@
+export declare enum ScaleChoices {
+    AUTO = "auto",
+    FIXED = "fixed"
+}

package/dist/models/SequenceData.d.ts

@@ -0,0 +1,6 @@
+import { Feature } from "./Feature";
+import ChromosomeInterval from "./ChromosomeInterval";
+export declare class SequenceData extends Feature {
+    sequence: string;
+    constructor(locus: ChromosomeInterval, sequence: string);
+}

package/dist/models/Snp.d.ts

@@ -0,0 +1,34 @@
+import Feature from "./Feature";
+/**
+ * A data container for snp.
+ *
+ * @author Daofeng Li and Silas Hsu
+ */
+declare class Snp extends Feature {
+    id: string;
+    alleles?: string[];
+    consequence_type?: string;
+    clinical_significance?: string[];
+    /**
+       * Constructs a new Snp, given an entry from ensembl API. .
+      @example
+      {
+          alleles: ["G", "C"]
+          assembly_name: "GRCh37"
+          clinical_significance: []
+          consequence_type: "intron_variant"
+          end: 140124755
+          feature_type: "variation"
+          id: "rs1051810366"
+          seq_region_name: "7"
+          source: "dbSNP"
+          start: 140124755
+          strand: 1
+  
+      }
+       * @param {record} record - record object to use
+       * @param {trackModel} trackModel for gene search information
+       */
+    constructor(record: any);
+}
+export default Snp;

package/dist/models/SortItemsOptions.d.ts

@@ -0,0 +1,6 @@
+export declare enum SortItemsOptions {
+    NONE = "NONE",
+    ASC = "ASC",
+    DESC = "DESC",
+    NOSORT = "NOSORT"
+}