oncoprintjs 5.0.3 → 6.0.1

package/src/js/oncoprintzoomslider.ts

@@ -1,42 +1,49 @@
-import $ from "jquery";
+import $ from 'jquery';
 import MouseMoveEvent = JQuery.MouseMoveEvent;
 import MouseDownEvent = JQuery.MouseDownEvent;
 
-const VERTICAL = "v";
-const HORIZONTAL = "h";
+const VERTICAL = 'v';
+const HORIZONTAL = 'h';
 
-function clamp(x:number) {
+function clamp(x: number) {
     return Math.max(Math.min(x, 1), 0);
 }
 
 export type OncoprintZoomSliderParams = {
-    btn_size: number,
-    horizontal?: boolean,
-    width?:number,
+    btn_size: number;
+    horizontal?: boolean;
+    width?: number;
 
-    vertical?:boolean, // either horizontal and width, or vertical and height, must be set
-    height?:number,
+    vertical?: boolean; // either horizontal and width, or vertical and height, must be set
+    height?: number;
 
-    init_val: number,
-    left:number,
-    top:number,
-    onChange:(val:number)=>void
+    init_val: number;
+    left: number;
+    top: number;
+    onChange: (val: number) => void;
 };
 
 export default class OncoprintZoomSlider {
-    private $div:JQuery;
-    private onChange:OncoprintZoomSliderParams["onChange"];
-    private value:number;
-    private slider_bar_size:number;
-    private orientation:"v"|"h";
-    private $slider:JQuery;
-    private $plus_btn:JQuery;
-    private $minus_btn:JQuery;
-
-    constructor($container:JQuery, params?:Partial<OncoprintZoomSliderParams>) {
-        this.$div = $('<div>').css({'position':'absolute',
-            'top': params.top || 0,
-            'left': params.left || 0}).appendTo($container);
+    private $div: JQuery;
+    private onChange: OncoprintZoomSliderParams['onChange'];
+    private value: number;
+    private slider_bar_size: number;
+    private orientation: 'v' | 'h';
+    private $slider: JQuery;
+    private $plus_btn: JQuery;
+    private $minus_btn: JQuery;
+
+    constructor(
+        $container: JQuery,
+        params?: Partial<OncoprintZoomSliderParams>
+    ) {
+        this.$div = $('<div>')
+            .css({
+                position: 'absolute',
+                top: params.top || 0,
+                left: params.left || 0,
+            })
+            .appendTo($container);
         params = params || {};
         params.btn_size = params.btn_size || 13;
         this.onChange = params.onChange || function() {};
@@ -44,72 +51,110 @@ export default class OncoprintZoomSlider {
         this.initialize(params as OncoprintZoomSliderParams);
 
         this.value = params.init_val === undefined ? 0.5 : params.init_val;
-        this.slider_bar_size = (this.orientation === VERTICAL ? params.height : params.width) - 2*params.btn_size;
+        this.slider_bar_size =
+            (this.orientation === VERTICAL ? params.height : params.width) -
+            2 * params.btn_size;
         this.updateSliderPos();
     }
 
-    private initialize(params:OncoprintZoomSliderParams) {
+    private initialize(params: OncoprintZoomSliderParams) {
         var $ctr = this.$div;
         var icon_size = Math.round(params.btn_size * 0.7);
-        var icon_padding = Math.round((params.btn_size - icon_size)/2);
-        var $slider_bar = $('<div>').css({'position':'absolute',
-            'background-color':'#ffffff',
-            'outline': 'solid 1px black'}).appendTo($ctr);
-        var $slider = $('<div>').css({'position':'absolute',
-            'background-color':'#ffffff',
-            'border': 'solid 1px black',
-            'border-radius': '3px',
-            'cursor': 'pointer'}).appendTo($ctr);
-
-        var $plus_btn = $('<div>').css({'position':'absolute',
-            'min-height': params.btn_size,
-            'min-width': params.btn_size,
-            'background-color':'#ffffff',
-            'border': 'solid 1px black',
-            'border-radius': '3px',
-            'cursor': 'pointer'})
+        var icon_padding = Math.round((params.btn_size - icon_size) / 2);
+        var $slider_bar = $('<div>')
+            .css({
+                position: 'absolute',
+                'background-color': '#ffffff',
+                outline: 'solid 1px black',
+            })
+            .appendTo($ctr);
+        var $slider = $('<div>')
+            .css({
+                position: 'absolute',
+                'background-color': '#ffffff',
+                border: 'solid 1px black',
+                'border-radius': '3px',
+                cursor: 'pointer',
+            })
             .appendTo($ctr);
-        $('<span>').addClass("icon fa fa-plus").css({'position':'absolute',
-            'top':icon_padding,
-            'left':icon_padding,
-            'min-width':icon_size,
-            'min-height':icon_size})
+
+        var $plus_btn = $('<div>')
+            .css({
+                position: 'absolute',
+                'min-height': params.btn_size,
+                'min-width': params.btn_size,
+                'background-color': '#ffffff',
+                border: 'solid 1px black',
+                'border-radius': '3px',
+                cursor: 'pointer',
+            })
+            .appendTo($ctr);
+        $('<span>')
+            .addClass('icon fa fa-plus')
+            .css({
+                position: 'absolute',
+                top: icon_padding,
+                left: icon_padding,
+                'min-width': icon_size,
+                'min-height': icon_size,
+            })
             .appendTo($plus_btn);
-        var $minus_btn = $('<div>').css({'position':'absolute',
-            'min-height': params.btn_size,
-            'min-width': params.btn_size,
-            'background-color':'#ffffff',
-            'border': 'solid 1px black',
-            'border-radius': '3px',
-            'cursor': 'pointer'})
+        var $minus_btn = $('<div>')
+            .css({
+                position: 'absolute',
+                'min-height': params.btn_size,
+                'min-width': params.btn_size,
+                'background-color': '#ffffff',
+                border: 'solid 1px black',
+                'border-radius': '3px',
+                cursor: 'pointer',
+            })
             .appendTo($ctr);
-        $('<span>').addClass("icon fa fa-minus").css({'position':'absolute',
-            'top':icon_padding,
-            'left':icon_padding,
-            'min-width':icon_size,
-            'min-height':icon_size})
+        $('<span>')
+            .addClass('icon fa fa-minus')
+            .css({
+                position: 'absolute',
+                top: icon_padding,
+                left: icon_padding,
+                'min-width': icon_size,
+                'min-height': icon_size,
+            })
             .appendTo($minus_btn);
         if (params.vertical) {
-            $slider_bar.css({'min-height': params.height - 2 * params.btn_size,
-                'min-width': Math.round(params.btn_size / 5)});
-            $slider.css({'min-height': Math.round(params.btn_size / 2),
-                'min-width': params.btn_size});
-
-            $plus_btn.css({'top': 0, 'left': 0});
-            $minus_btn.css({'top': params.height - params.btn_size, 'left': 0});
-            $slider_bar.css({'top': params.btn_size, 'left': 0.4 * params.btn_size});
-            $slider.css({'left': 0});
+            $slider_bar.css({
+                'min-height': params.height - 2 * params.btn_size,
+                'min-width': Math.round(params.btn_size / 5),
+            });
+            $slider.css({
+                'min-height': Math.round(params.btn_size / 2),
+                'min-width': params.btn_size,
+            });
+
+            $plus_btn.css({ top: 0, left: 0 });
+            $minus_btn.css({ top: params.height - params.btn_size, left: 0 });
+            $slider_bar.css({
+                top: params.btn_size,
+                left: 0.4 * params.btn_size,
+            });
+            $slider.css({ left: 0 });
             this.orientation = VERTICAL;
         } else {
-            $slider_bar.css({'min-height': Math.round(params.btn_size / 5),
-                'min-width': params.width - 2 * params.btn_size});
-            $slider.css({'min-height': params.btn_size,
-                'min-width': Math.round(params.btn_size / 2)});
-
-            $plus_btn.css({'top': 0, 'left': params.width - params.btn_size});
-            $minus_btn.css({'top': 0, 'left': 0});
-            $slider_bar.css({'top': 0.4*params.btn_size, 'left': params.btn_size});
-            $slider.css({'top': 0});
+            $slider_bar.css({
+                'min-height': Math.round(params.btn_size / 5),
+                'min-width': params.width - 2 * params.btn_size,
+            });
+            $slider.css({
+                'min-height': params.btn_size,
+                'min-width': Math.round(params.btn_size / 2),
+            });
+
+            $plus_btn.css({ top: 0, left: params.width - params.btn_size });
+            $minus_btn.css({ top: 0, left: 0 });
+            $slider_bar.css({
+                top: 0.4 * params.btn_size,
+                left: params.btn_size,
+            });
+            $slider.css({ top: 0 });
             this.orientation = HORIZONTAL;
         }
 
@@ -124,23 +169,26 @@ export default class OncoprintZoomSlider {
             params.onChange(self.value);
         });
 
-        [$slider, $plus_btn, $minus_btn].map(function($btn) { $btn.hover(function() {
-            $(this).css({'background-color':'#cccccc'});
-        }, function() {
-            $(this).css({'background-color': '#ffffff'});
-        }); });
-
-
+        [$slider, $plus_btn, $minus_btn].map(function($btn) {
+            $btn.hover(
+                function() {
+                    $(this).css({ 'background-color': '#cccccc' });
+                },
+                function() {
+                    $(this).css({ 'background-color': '#ffffff' });
+                }
+            );
+        });
 
         this.$slider = $slider;
         this.$plus_btn = $plus_btn;
         this.$minus_btn = $minus_btn;
 
         (function setUpSliderDrag() {
-            let start_mouse:number;
-            let start_val:number;
-            let dragging:boolean;
-            function handleSliderDrag(evt:MouseMoveEvent) {
+            let start_mouse: number;
+            let start_val: number;
+            let dragging: boolean;
+            function handleSliderDrag(evt: MouseMoveEvent) {
                 evt.stopPropagation();
                 evt.preventDefault();
                 let delta_mouse;
@@ -158,7 +206,7 @@ export default class OncoprintZoomSlider {
                 }
                 dragging = false;
             }
-            self.$slider.on("mousedown", function (evt:MouseDownEvent) {
+            self.$slider.on('mousedown', function(evt: MouseDownEvent) {
                 if (self.orientation === VERTICAL) {
                     start_mouse = evt.pageY;
                 } else {
@@ -166,38 +214,55 @@ export default class OncoprintZoomSlider {
                 }
                 start_val = self.value;
                 dragging = true;
-                $(document).on("mousemove", handleSliderDrag);
+                $(document).on('mousemove', handleSliderDrag);
             });
-            $(document).on("mouseup click", function () {
-                $(document).off("mousemove", handleSliderDrag);
+            $(document).on('mouseup click', function() {
+                $(document).off('mousemove', handleSliderDrag);
                 stopSliderDrag();
             });
-        })()
-    };
+        })();
+    }
 
     private updateSliderPos() {
         const proportion = this.value;
         var $slider = this.$slider;
         var bounds = this.getSliderBounds();
         if (this.orientation === VERTICAL) {
-            $slider.css('top', bounds.bottom*(1-proportion) + bounds.top*proportion);
+            $slider.css(
+                'top',
+                bounds.bottom * (1 - proportion) + bounds.top * proportion
+            );
         } else if (this.orientation === HORIZONTAL) {
-            $slider.css('left', bounds.left*(1-proportion) + bounds.right*proportion);
+            $slider.css(
+                'left',
+                bounds.left * (1 - proportion) + bounds.right * proportion
+            );
         }
-    };
+    }
 
     private getSliderBounds() {
         if (this.orientation === VERTICAL) {
-            return {bottom: parseInt(this.$minus_btn.css('top'), 10) - parseInt(this.$slider.css('min-height'), 10),
-                top: parseInt(this.$plus_btn.css('top'), 10) + parseInt(this.$plus_btn.css('min-height'), 10)};
+            return {
+                bottom:
+                    parseInt(this.$minus_btn.css('top'), 10) -
+                    parseInt(this.$slider.css('min-height'), 10),
+                top:
+                    parseInt(this.$plus_btn.css('top'), 10) +
+                    parseInt(this.$plus_btn.css('min-height'), 10),
+            };
         } else {
-            return {left: parseInt(this.$minus_btn.css('left'), 10) + parseInt(this.$minus_btn.css('min-width'), 10),
-                right: parseInt(this.$plus_btn.css('left'), 10) - parseInt(this.$slider.css('min-width'), 10)};
+            return {
+                left:
+                    parseInt(this.$minus_btn.css('left'), 10) +
+                    parseInt(this.$minus_btn.css('min-width'), 10),
+                right:
+                    parseInt(this.$plus_btn.css('left'), 10) -
+                    parseInt(this.$slider.css('min-width'), 10),
+            };
         }
-    };
-
+    }
 
-    public setSliderValue(proportion:number) {
+    public setSliderValue(proportion: number) {
         this.value = clamp(proportion);
         this.updateSliderPos();
     }

package/src/js/polyfill.ts

@@ -30,7 +30,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-export type OMath = Math & { log2:(x:number)=>number };
-export const OMath:OMath = (Math as any);
+export type OMath = Math & { log2: (x: number) => number };
+export const OMath: OMath = Math as any;
 
-OMath.log2 = OMath.log2 || function(x:number) { return Math.log(x) / Math.LN2; };
+OMath.log2 =
+    OMath.log2 ||
+    function(x: number) {
+        return Math.log(x) / Math.LN2;
+    };

package/src/js/precomputedcomparator.ts

@@ -1,48 +1,71 @@
-import * as BucketSort from "./bucketsort";
-import binarysearch from "./binarysearch";
-import hasElementsInInterval from "./haselementsininterval";
+import * as BucketSort from './bucketsort';
+import binarysearch from './binarysearch';
+import hasElementsInInterval from './haselementsininterval';
 import {
     ColumnId,
     TrackSortComparator,
     TrackSortDirection,
     TrackSortSpecification,
-    TrackSortSpecificationComparators, TrackSortSpecificationVectors, TrackSortVector
-} from "./oncoprintmodel";
-import {SortingVector} from "./bucketsort";
+    TrackSortSpecificationComparators,
+    TrackSortSpecificationVectors,
+    TrackSortVector,
+} from './oncoprintmodel';
+import { SortingVector } from './bucketsort';
 
 type DatumWithVectors<T> = {
-    d:T;
-    preferred_vector:SortingVector;
-    mandatory_vector:SortingVector;
+    d: T;
+    preferred_vector: SortingVector;
+    mandatory_vector: SortingVector;
 };
 
 export default class PrecomputedComparator<T> {
+    private preferred_change_points: number[];
+    private mandatory_change_points: number[];
+    private id_to_index: { [columnId: string]: number };
 
-    private preferred_change_points:number[];
-    private mandatory_change_points:number[];
-    private id_to_index:{[columnId:string]:number};
-
-    constructor(list:T[], comparator:TrackSortSpecification<T>, sort_direction:TrackSortDirection, element_identifier_key:string&keyof T) {
+    constructor(
+        list: T[],
+        comparator: TrackSortSpecification<T>,
+        sort_direction: TrackSortDirection,
+        element_identifier_key: string & keyof T
+    ) {
         if (comparator.isVector) {
-            this.initializeVector(list, comparator, sort_direction, element_identifier_key);
+            this.initializeVector(
+                list,
+                comparator,
+                sort_direction,
+                element_identifier_key
+            );
         } else {
-            this.initializeComparator(list, comparator as TrackSortSpecificationComparators<T>, sort_direction, element_identifier_key);
+            this.initializeComparator(
+                list,
+                comparator as TrackSortSpecificationComparators<T>,
+                sort_direction,
+                element_identifier_key
+            );
         }
     }
 
-    private initializeComparator(list:T[], comparator:TrackSortComparator<T> | TrackSortSpecificationComparators<T>, sort_direction:TrackSortDirection, element_identifier_key:keyof T) {
+    private initializeComparator(
+        list: T[],
+        comparator:
+            | TrackSortComparator<T>
+            | TrackSortSpecificationComparators<T>,
+        sort_direction: TrackSortDirection,
+        element_identifier_key: keyof T
+    ) {
         // initializeComparator initializes the PrecomputedComparator in the case that
         //	the sort order is given using a comparator
         let preferred, mandatory;
-        if (typeof comparator === "function") {
+        if (typeof comparator === 'function') {
             preferred = comparator;
             mandatory = comparator;
         } else {
             preferred = comparator.preferred;
             mandatory = comparator.mandatory;
         }
-        function makeDirectedComparator(cmp:TrackSortComparator<T>) {
-            return function (d1:T, d2:T) {
+        function makeDirectedComparator(cmp: TrackSortComparator<T>) {
+            return function(d1: T, d2: T) {
                 if (sort_direction === 0) {
                     return 0;
                 }
@@ -65,51 +88,70 @@ export default class PrecomputedComparator<T> {
         this.mandatory_change_points = [0]; // i is a mandatory change pt iff its a change pt with comp = mandatoryComparator
 
         // note that by the following process, preferred_change_points and mandatory_change_points are sorted
-        for (let i=1; i<sorted_list.length; i++) {
-            if (mandatoryComparator(sorted_list[i-1], sorted_list[i]) !== 0) {
+        for (let i = 1; i < sorted_list.length; i++) {
+            if (mandatoryComparator(sorted_list[i - 1], sorted_list[i]) !== 0) {
                 this.mandatory_change_points.push(i);
-            } else if (preferredComparator(sorted_list[i-1], sorted_list[i]) !== 0) {
+            } else if (
+                preferredComparator(sorted_list[i - 1], sorted_list[i]) !== 0
+            ) {
                 this.preferred_change_points.push(i);
             }
         }
         this.id_to_index = {};
-        for (let i=0; i<sorted_list.length; i++) {
-            this.id_to_index[sorted_list[i][element_identifier_key] as any as string] = i;
+        for (let i = 0; i < sorted_list.length; i++) {
+            this.id_to_index[
+                (sorted_list[i][element_identifier_key] as any) as string
+            ] = i;
         }
     }
 
-    private initializeVector(list:T[], getVector:TrackSortSpecificationVectors<T>, sort_direction:TrackSortDirection, element_identifier_key:keyof T) {
+    private initializeVector(
+        list: T[],
+        getVector: TrackSortSpecificationVectors<T>,
+        sort_direction: TrackSortDirection,
+        element_identifier_key: keyof T
+    ) {
         // initializeVector initializes the PrecomputedComparator in the case that the sort order is specified by vectors for bucket sort
-        function makeDirectedVector(vec:TrackSortVector<T>) {
+        function makeDirectedVector(vec: TrackSortVector<T>) {
             if (sort_direction === 0) {
-                return function(d:T) { return 0; };
+                return function(d: T) {
+                    return 0;
+                };
             } else {
-                return function(d:T) {
-                    return vec(d).map(function(n:number|string) {
-                        if (typeof n === "number") {
+                return function(d: T) {
+                    return vec(d).map(function(n: number | string) {
+                        if (typeof n === 'number') {
                             return n * sort_direction;
                         } else {
                             return n;
                         }
                     });
-                }
+                };
             }
         }
         const preferredVector = makeDirectedVector(getVector.preferred);
         const mandatoryVector = makeDirectedVector(getVector.mandatory);
 
         // associate each data to its vector and sort them together
-        const list_with_vectors:DatumWithVectors<T>[] = list.map(function(d) {
-            return { d: d, preferred_vector: preferredVector(d), mandatory_vector: mandatoryVector(d) };
+        const list_with_vectors: DatumWithVectors<T>[] = list.map(function(d) {
+            return {
+                d: d,
+                preferred_vector: preferredVector(d),
+                mandatory_vector: mandatoryVector(d),
+            };
         }) as DatumWithVectors<T>[];
         // sort by preferred vector
         const _compareEquals = getVector.compareEquals;
-        const compareEquals = _compareEquals ? function(d1:DatumWithVectors<T>, d2:DatumWithVectors<T>) {
-            return _compareEquals(d1.d, d2.d);
-        } : undefined;
+        const compareEquals = _compareEquals
+            ? function(d1: DatumWithVectors<T>, d2: DatumWithVectors<T>) {
+                  return _compareEquals(d1.d, d2.d);
+              }
+            : undefined;
         const sorted_list = BucketSort.bucketSort(
             list_with_vectors,
-            function(d) { return d.preferred_vector; },
+            function(d) {
+                return d.preferred_vector;
+            },
             compareEquals
         );
 
@@ -118,37 +160,78 @@ export default class PrecomputedComparator<T> {
         this.mandatory_change_points = [0]; // i (besides 0) is a mandatory change pt iff its a change pt with comp = mandatoryComparator
 
         // note that by the following process, preferred_change_points and mandatory_change_points are sorted
-        const getMandatoryVector = function(d:{ mandatory_vector:(number|string)[]}) { return d.mandatory_vector; };
-        const getPreferredVector = function(d:{ preferred_vector:(number|string)[]}) { return d.preferred_vector; };
-        for (let i=1; i<sorted_list.length; i++) {
-            if (BucketSort.compareFull(sorted_list[i-1], sorted_list[i], getMandatoryVector) !== 0) {
+        const getMandatoryVector = function(d: {
+            mandatory_vector: (number | string)[];
+        }) {
+            return d.mandatory_vector;
+        };
+        const getPreferredVector = function(d: {
+            preferred_vector: (number | string)[];
+        }) {
+            return d.preferred_vector;
+        };
+        for (let i = 1; i < sorted_list.length; i++) {
+            if (
+                BucketSort.compareFull(
+                    sorted_list[i - 1],
+                    sorted_list[i],
+                    getMandatoryVector
+                ) !== 0
+            ) {
                 this.mandatory_change_points.push(i);
-            } else if (BucketSort.compareFull(sorted_list[i-1], sorted_list[i], getPreferredVector, compareEquals) !== 0) {
+            } else if (
+                BucketSort.compareFull(
+                    sorted_list[i - 1],
+                    sorted_list[i],
+                    getPreferredVector,
+                    compareEquals
+                ) !== 0
+            ) {
                 this.preferred_change_points.push(i);
             }
         }
 
         this.id_to_index = {};
-        for (let i=0; i<sorted_list.length; i++) {
-            this.id_to_index[sorted_list[i].d[element_identifier_key] as any as string] = i;
+        for (let i = 0; i < sorted_list.length; i++) {
+            this.id_to_index[
+                (sorted_list[i].d[element_identifier_key] as any) as string
+            ] = i;
         }
     }
 
-    public getSortValue(id:ColumnId) {
+    public getSortValue(id: ColumnId) {
         const index = this.id_to_index[id];
         // find greatest lower change points - thats where this should be sorted by
         //		because everything between change points has same sort value
         let mandatory = 0;
         let preferred = 0;
         if (this.mandatory_change_points.length) {
-            mandatory = this.mandatory_change_points[binarysearch(this.mandatory_change_points, index, function(ind) { return ind; }, true)];
+            mandatory = this.mandatory_change_points[
+                binarysearch(
+                    this.mandatory_change_points,
+                    index,
+                    function(ind) {
+                        return ind;
+                    },
+                    true
+                )
+            ];
         }
         if (this.preferred_change_points.length) {
-            preferred = this.preferred_change_points[binarysearch(this.preferred_change_points, index, function(ind) { return ind; }, true)];
+            preferred = this.preferred_change_points[
+                binarysearch(
+                    this.preferred_change_points,
+                    index,
+                    function(ind) {
+                        return ind;
+                    },
+                    true
+                )
+            ];
         }
         return {
             mandatory: mandatory,
-            preferred: preferred
+            preferred: preferred,
         };
     }
-}
+}

package/src/js/shaders.ts

@@ -1,6 +1,4 @@
-export function getVertexShaderSource(
-    columnsRightAfterGapsSize:number,
-) {
+export function getVertexShaderSource(columnsRightAfterGapsSize: number) {
     return `precision highp float;
             attribute float aPosVertex;
             attribute float aColVertex;
@@ -103,4 +101,4 @@ export function getFragmentShaderSource() {
             void main(void) {
                 gl_FragColor = texture2D(uSampler, vec2(texCoord, 0.5));
             }`;
-}
+}