oncoprintjs 5.0.3 → 6.0.1

package/src/js/svgfactory.ts

@@ -1,12 +1,12 @@
 import makeSVGElement from './makesvgelement';
 import shapeToSVG from './oncoprintshapetosvg';
-import {ComputedShapeParams} from "./oncoprintshape";
-import {RGBAColor} from "./oncoprintruleset";
-import {rgbString} from "./utils";
+import { ComputedShapeParams } from './oncoprintshape';
+import { RGBAColor } from './oncoprintruleset';
+import { rgbString } from './utils';
 
 function makeIdCounter() {
     let id = 0;
-    return function () {
+    return function() {
         id += 1;
         return id;
     };
@@ -15,131 +15,186 @@ function makeIdCounter() {
 const gradientId = makeIdCounter();
 
 export default {
-    text: function(content:string,x?:number,y?:number,size?:number,family?:string,weight?:string,alignment_baseline?:string,fill?:string,text_decoration?:string) {
+    text: function(
+        content: string,
+        x?: number,
+        y?: number,
+        size?: number,
+        family?: string,
+        weight?: string,
+        alignment_baseline?: string,
+        fill?: string,
+        text_decoration?: string
+    ) {
         size = size || 12;
         var alignment_baseline_y_offset = size;
-        if (alignment_baseline === "middle") {
-            alignment_baseline_y_offset = size/2;
-        } else if (alignment_baseline === "bottom") {
+        if (alignment_baseline === 'middle') {
+            alignment_baseline_y_offset = size / 2;
+        } else if (alignment_baseline === 'bottom') {
             alignment_baseline_y_offset = 0;
         }
         var elt = makeSVGElement('text', {
-            'x':(x || 0),
-            'y':(y || 0) + alignment_baseline_y_offset,
-            'font-size':size,
-            'font-family':(family || 'serif'),
-            'font-weight':(weight || 'normal'),
-            'text-anchor':'start',
-            'fill':fill,
-            'text-decoration':text_decoration
+            x: x || 0,
+            y: (y || 0) + alignment_baseline_y_offset,
+            'font-size': size,
+            'font-family': family || 'serif',
+            'font-weight': weight || 'normal',
+            'text-anchor': 'start',
+            fill: fill,
+            'text-decoration': text_decoration,
         });
         elt.textContent = content + '';
         return elt as SVGTextElement;
     },
-    group: function(x:number|undefined,y:number|undefined) {
+    group: function(x: number | undefined, y: number | undefined) {
         x = x || 0;
         y = y || 0;
         return makeSVGElement('g', {
-            'transform':'translate('+x+','+y+')'
+            transform: 'translate(' + x + ',' + y + ')',
         }) as SVGGElement;
     },
-    svg: function(width:number|undefined, height:number|undefined) {
+    svg: function(width: number | undefined, height: number | undefined) {
         return makeSVGElement('svg', {
-            'width':(width || 0),
-            'height':(height || 0),
+            width: width || 0,
+            height: height || 0,
         }) as SVGSVGElement;
     },
-    wrapText: function(in_dom_text_svg_elt:SVGTextElement, width:number) {
+    wrapText: function(in_dom_text_svg_elt: SVGTextElement, width: number) {
         const text = in_dom_text_svg_elt.textContent;
-        in_dom_text_svg_elt.textContent = "";
+        in_dom_text_svg_elt.textContent = '';
 
-        const words = text.split(" ");
+        const words = text.split(' ');
         let dy = 0;
-        let tspan = makeSVGElement('tspan', {'x':'0', 'dy':dy}) as SVGTSpanElement;
+        let tspan = makeSVGElement('tspan', {
+            x: '0',
+            dy: dy,
+        }) as SVGTSpanElement;
         in_dom_text_svg_elt.appendChild(tspan);
 
-        let curr_tspan_words:string[] = [];
-        for (var i=0; i<words.length; i++) {
+        let curr_tspan_words: string[] = [];
+        for (var i = 0; i < words.length; i++) {
             curr_tspan_words.push(words[i]);
-            tspan.textContent = curr_tspan_words.join(" ");
+            tspan.textContent = curr_tspan_words.join(' ');
             if (tspan.getComputedTextLength() > width) {
-                tspan.textContent = curr_tspan_words.slice(0, curr_tspan_words.length-1).join(" ");
+                tspan.textContent = curr_tspan_words
+                    .slice(0, curr_tspan_words.length - 1)
+                    .join(' ');
                 dy = in_dom_text_svg_elt.getBBox().height;
                 curr_tspan_words = [words[i]];
-                tspan = makeSVGElement('tspan', {'x':'0', 'dy':dy}) as SVGTSpanElement;
+                tspan = makeSVGElement('tspan', {
+                    x: '0',
+                    dy: dy,
+                }) as SVGTSpanElement;
                 in_dom_text_svg_elt.appendChild(tspan);
                 tspan.textContent = words[i];
             }
         }
     },
-    fromShape: function(oncoprint_shape_computed_params:ComputedShapeParams, offset_x:number, offset_y:number) {
+    fromShape: function(
+        oncoprint_shape_computed_params: ComputedShapeParams,
+        offset_x: number,
+        offset_y: number
+    ) {
         return shapeToSVG(oncoprint_shape_computed_params, offset_x, offset_y);
     },
-    polygon: function(points:[number,number][], fill:RGBAColor) {
-        return makeSVGElement('polygon', {'points': points, 'fill':rgbString(fill), 'fill-opacity':fill[3]}) as SVGPolygonElement;
+    polygon: function(points: [number, number][], fill: RGBAColor) {
+        return makeSVGElement('polygon', {
+            points: points,
+            fill: rgbString(fill),
+            'fill-opacity': fill[3],
+        }) as SVGPolygonElement;
     },
-    rect: function(x:number,y:number,width:number,height:number,fillSpecification:{
-        type: "rgba",
-        value: RGBAColor
-    }| {
-        type: "gradientId",
-        value: string
-    }) {
-        let fill:string;
+    rect: function(
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+        fillSpecification:
+            | {
+                  type: 'rgba';
+                  value: RGBAColor;
+              }
+            | {
+                  type: 'gradientId';
+                  value: string;
+              }
+    ) {
+        let fill: string;
         let fillOpacity = 1;
-        if (fillSpecification.type === "rgba") {
+        if (fillSpecification.type === 'rgba') {
             fill = rgbString(fillSpecification.value);
             fillOpacity = fillSpecification.value[3];
         } else {
             fill = `url(#${fillSpecification.value})`;
         }
-        return makeSVGElement('rect', {'x':x, 'y':y, 'width':width, 'height':height, 'fill':fill, 'fill-opacity':fillOpacity}) as SVGRectElement;
+        return makeSVGElement('rect', {
+            x: x,
+            y: y,
+            width: width,
+            height: height,
+            fill: fill,
+            'fill-opacity': fillOpacity,
+        }) as SVGRectElement;
     },
-    bgrect: function(width:number, height:number, fill:RGBAColor) {
-        return makeSVGElement('rect', {'width':width, 'height':height, 'fill':rgbString(fill), 'fill-opacity':fill[3]}) as SVGRectElement;
+    bgrect: function(width: number, height: number, fill: RGBAColor) {
+        return makeSVGElement('rect', {
+            width: width,
+            height: height,
+            fill: rgbString(fill),
+            'fill-opacity': fill[3],
+        }) as SVGRectElement;
     },
-    path: function(points:[number,number][], stroke:RGBAColor, fill:RGBAColor, linearGradient:SVGGradientElement) {
-        let pointsStrArray = points.map(function(pt) { return pt.join(","); });
-        pointsStrArray[0] = 'M'+points[0];
-        for (var i=1; i<points.length; i++) {
-            pointsStrArray[i] = 'L'+points[i];
+    path: function(
+        points: [number, number][],
+        stroke: RGBAColor,
+        fill: RGBAColor,
+        linearGradient: SVGGradientElement
+    ) {
+        let pointsStrArray = points.map(function(pt) {
+            return pt.join(',');
+        });
+        pointsStrArray[0] = 'M' + points[0];
+        for (var i = 1; i < points.length; i++) {
+            pointsStrArray[i] = 'L' + points[i];
         }
         return makeSVGElement('path', {
-            'd': pointsStrArray.join(" "),
-            'stroke': linearGradient ? 'url(#'+linearGradient.getAttribute('id')+')' : rgbString(stroke),
+            d: pointsStrArray.join(' '),
+            stroke: linearGradient
+                ? 'url(#' + linearGradient.getAttribute('id') + ')'
+                : rgbString(stroke),
             'stroke-opacity': linearGradient ? 0 : stroke[3],
-            'fill': linearGradient ? 'url(#'+linearGradient.getAttribute('id')+')' : rgbString(fill),
-            'fill-opacity': linearGradient ? 1 : fill[3]
+            fill: linearGradient
+                ? 'url(#' + linearGradient.getAttribute('id') + ')'
+                : rgbString(fill),
+            'fill-opacity': linearGradient ? 1 : fill[3],
         }) as SVGPathElement;
     },
-    stop: function (offset:number, color:RGBAColor) {
+    stop: function(offset: number, color: RGBAColor) {
         return makeSVGElement('stop', {
-            'offset': offset + '%',
+            offset: offset + '%',
             'stop-color': rgbString(color),
-            'stop-opacity': color[3]
+            'stop-opacity': color[3],
         }) as SVGStopElement;
     },
-    linearGradient: function () {
-        return makeSVGElement('linearGradient', {'id': 'linearGradient'+gradientId()}) as SVGLinearGradientElement;
+    linearGradient: function() {
+        return makeSVGElement('linearGradient', {
+            id: 'linearGradient' + gradientId(),
+        }) as SVGLinearGradientElement;
     },
     defs: function() {
         return makeSVGElement('defs', {}) as SVGDefsElement;
     },
-    gradient: function(colorFn:(val:number)=>RGBAColor) {
+    gradient: function(colorFn: (val: number) => RGBAColor) {
         const gradient = makeSVGElement('linearGradient', {
-            'id': 'gradient'+gradientId(),
-            'x1':0,
-            'y1':0,
-            'x2':1,
-            'y2':0
+            id: 'gradient' + gradientId(),
+            x1: 0,
+            y1: 0,
+            x2: 1,
+            y2: 0,
         });
-        for (let i=0; i<=100; i++) {
-            gradient.appendChild(
-                this.stop(i, colorFn(i/100))
-            );
+        for (let i = 0; i <= 100; i++) {
+            gradient.appendChild(this.stop(i, colorFn(i / 100)));
         }
-        return gradient as SVGLinearGradientElement
-    }
+        return gradient as SVGLinearGradientElement;
+    },
 };
-
-

package/src/js/utils.ts

@@ -1,26 +1,30 @@
-import {ComputedShapeParams} from "./oncoprintshape";
-import {RGBAColor} from "./oncoprintruleset";
+import { ComputedShapeParams } from './oncoprintshape';
+import { RGBAColor } from './oncoprintruleset';
 
 export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
-export function cloneShallow<T extends Object>(obj:T) {
-    const ret:Partial<T> = {};
-    for (const key of (Object.keys(obj) as (keyof T)[])) {
+export function cloneShallow<T extends Object>(obj: T) {
+    const ret: Partial<T> = {};
+    for (const key of Object.keys(obj) as (keyof T)[]) {
         ret[key] = obj[key];
     }
     return ret as T;
 }
 
-export function extendArray(target:any[], source:any[]) {
-    for (let i=0; i<source.length; i++) {
+export function extendArray(target: any[], source: any[]) {
+    for (let i = 0; i < source.length; i++) {
         target.push(source[i]);
     }
 }
 
-export function doesCellIntersectPixel(cellHitzone:[number, number], pixelX:number) {
+export function doesCellIntersectPixel(
+    cellHitzone: [number, number],
+    pixelX: number
+) {
     // checks intersection with the half-open interval [pixelX, pixelX+1)
 
-    const lower = cellHitzone[0], upper = cellHitzone[1];
+    const lower = cellHitzone[0],
+        upper = cellHitzone[1];
     if (upper < pixelX) {
         return false;
     } else if (lower < pixelX + 1) {
@@ -30,28 +34,37 @@ export function doesCellIntersectPixel(cellHitzone:[number, number], pixelX:numb
     }
 }
 
-export function ifndef<T>(x:T|undefined, val:T):T {
-    return (typeof x === "undefined" ? val : x);
+export function ifndef<T>(x: T | undefined, val: T): T {
+    return typeof x === 'undefined' ? val : x;
 }
 
-export function shallowExtend<T extends Object, S extends Object>(target:T, source:S):T&S {
-    const ret:Partial<T&S> = {};
-    for (const key of Object.keys(target) as (keyof T&S)[]) {
+export function shallowExtend<T extends Object, S extends Object>(
+    target: T,
+    source: S
+): T & S {
+    const ret: Partial<T & S> = {};
+    for (const key of Object.keys(target) as (keyof T & S)[]) {
         ret[key] = target[key as keyof T] as any;
     }
-    for (const key of Object.keys(source) as (keyof T&S)[]) {
+    for (const key of Object.keys(source) as (keyof T & S)[]) {
         ret[key] = source[key as keyof S] as any;
     }
-    return ret as T&S;
+    return ret as T & S;
 }
 
-export function objectValues<T extends Object>(obj:T):(T[keyof T][]) {
-    return Object.keys(obj).map(function(key:string&keyof T) { return obj[key]; });
+export function objectValues<T extends Object>(obj: T): T[keyof T][] {
+    return Object.keys(obj).map(function(key: string & keyof T) {
+        return obj[key];
+    });
 }
 
-export function arrayFindIndex<T>(arr:T[], predicate:(t:T)=>boolean, start_index?:number) {
+export function arrayFindIndex<T>(
+    arr: T[],
+    predicate: (t: T) => boolean,
+    start_index?: number
+) {
     start_index = start_index || 0;
-    for (let i=start_index; i<arr.length; i++) {
+    for (let i = start_index; i < arr.length; i++) {
         if (predicate(arr[i])) {
             return i;
         }
@@ -59,7 +72,7 @@ export function arrayFindIndex<T>(arr:T[], predicate:(t:T)=>boolean, start_index
     return -1;
 }
 
-export function sgndiff(a:number, b:number) {
+export function sgndiff(a: number, b: number) {
     if (a < b) {
         return -1;
     } else if (a > b) {
@@ -69,10 +82,13 @@ export function sgndiff(a:number, b:number) {
     }
 }
 
-export function clamp(x:number, lower:number, upper:number) {
+export function clamp(x: number, lower: number, upper: number) {
     return Math.max(lower, Math.min(upper, x));
 }
-export function z_comparator(shapeA:ComputedShapeParams, shapeB:ComputedShapeParams) {
+export function z_comparator(
+    shapeA: ComputedShapeParams,
+    shapeB: ComputedShapeParams
+) {
     const zA = shapeA.z;
     const zB = shapeB.z;
     if (zA < zB) {
@@ -84,27 +100,31 @@ export function z_comparator(shapeA:ComputedShapeParams, shapeB:ComputedShapePar
     }
 }
 
-export function fastParseInt10(x:string, substringStart?:number, substringEnd?:number) {
+export function fastParseInt10(
+    x: string,
+    substringStart?: number,
+    substringEnd?: number
+) {
     // simple, fast parseInt when you know its a base-10 int and
     //  you don't need any error handling.
     // Performance testing shows this is 85% faster than built-in parseInt
     substringStart = substringStart || 0;
     substringEnd = substringEnd || x.length;
     let ret = 0;
-    for (let i=substringStart; i<substringEnd; i++){
+    for (let i = substringStart; i < substringEnd; i++) {
         ret *= 10;
-        ret += x.charCodeAt(i)-48; // the integer character codes from 0 to 9 are 48, 49, ..., 58
+        ret += x.charCodeAt(i) - 48; // the integer character codes from 0 to 9 are 48, 49, ..., 58
     }
     return ret;
 }
 
-export function fastParseInt16(x:string) {
+export function fastParseInt16(x: string) {
     // simple, fast parseInt when you know its a base-16 int and
     //  you don't need any error handling.
     // Performance testing shows this is 43% faster than parseInt(x,16)
     let ret = 0;
-    let nextCharCode:number;
-    for (let i=0; i<x.length; i++) {
+    let nextCharCode: number;
+    for (let i = 0; i < x.length; i++) {
         ret *= 16;
         nextCharCode = x.charCodeAt(i);
         if (nextCharCode > 96) {
@@ -119,6 +139,6 @@ export function fastParseInt16(x:string) {
     return ret;
 }
 
-export function rgbString(color:RGBAColor) {
+export function rgbString(color: RGBAColor) {
     return `rgb(${color[0]},${color[1]},${color[2]})`;
-}
+}

package/src/js/workers/clustering-worker.ts

@@ -22,63 +22,67 @@
  */
 
 // @ts-ignore
-import clusterfck from "tayden-clusterfck";
+import clusterfck from 'tayden-clusterfck';
 // @ts-ignore
-import jStat from "jstat";
+import jStat from 'jstat';
 
 type Item = {
-    orderedValueList:number[];
-}
+    orderedValueList: number[];
+};
 
 type ProcessedItem = Item & {
-    isAllNaNs:boolean;
-    preProcessedValueList:number[];
-}
+    isAllNaNs: boolean;
+    preProcessedValueList: number[];
+};
 
-export type EntityItem = Item & { entityId: string};
+export type EntityItem = Item & { entityId: string };
 export type CaseItem = Item & { caseId: string };
 
 export type CasesAndEntities = {
-    [caseId:string]:{
-        [entityId:string]:number
-    }
+    [caseId: string]: {
+        [entityId: string]: number;
+    };
 };
 
 export type ClusteringMessage = {
-    dimension: "CASES" | "ENTITIES";
-    casesAndEntities:CasesAndEntities;
+    dimension: 'CASES' | 'ENTITIES';
+    casesAndEntities: CasesAndEntities;
 };
 
-
-const ctx:Worker = (self as any as Worker);
+const ctx: Worker = (self as any) as Worker;
 /**
  * "Routing" logic for this worker, based on given message.
  *
  * @param m : message object with m.dimension (CASES or ENTITIES) and m.casesAndEntitites
  *      which is the input for the clustering method.
  */
-ctx.onmessage = function(m:MessageEvent) {
+ctx.onmessage = function(m: MessageEvent) {
     console.log('Clustering worker received message');
     var result = null;
-    if ((m.data as ClusteringMessage).dimension === "CASES") {
+    if ((m.data as ClusteringMessage).dimension === 'CASES') {
         result = hclusterCases((m.data as ClusteringMessage).casesAndEntities);
-    } else if ((m.data as ClusteringMessage).dimension === "ENTITIES") {
-        result = hclusterGeneticEntities((m.data as ClusteringMessage).casesAndEntities);
+    } else if ((m.data as ClusteringMessage).dimension === 'ENTITIES') {
+        result = hclusterGeneticEntities(
+            (m.data as ClusteringMessage).casesAndEntities
+        );
     } else {
-        throw new Error("Illegal argument given to clustering-worker.js for m.data.dimension: " + m.data.dimension);
+        throw new Error(
+            'Illegal argument given to clustering-worker.js for m.data.dimension: ' +
+                m.data.dimension
+        );
     }
     console.log('Posting clustering result back to main script');
     ctx.postMessage(result);
-}
+};
 
 /**
  * Returns false if any value is a valid number != 0.0,
  * and true otherwise.
  */
-function isAllNaNs(values:any[]) {
+function isAllNaNs(values: any[]) {
     for (let i = 0; i < values.length; i++) {
         const val = values[i];
-        if (!isNaN(val) && val != null && val != 0.0 ) {
+        if (!isNaN(val) && val != null && val != 0.0) {
             return false;
         }
     }
@@ -91,13 +95,12 @@ function isAllNaNs(values:any[]) {
  * of item.orderedValueList.
  *
  */
-function preRankedSpearmanDist(item1:ProcessedItem, item2:ProcessedItem) {
+function preRankedSpearmanDist(item1: ProcessedItem, item2: ProcessedItem) {
     //rules for NaN values:
     if (item1.isAllNaNs && item2.isAllNaNs) {
         //return distance 0
         return 0;
-    }
-    else if (item1.isAllNaNs || item2.isAllNaNs) {
+    } else if (item1.isAllNaNs || item2.isAllNaNs) {
         //return large distance:
         return 3;
     }
@@ -111,7 +114,7 @@ function preRankedSpearmanDist(item1:ProcessedItem, item2:ProcessedItem) {
         //assuming the ranks1 and ranks2 lists do not contain NaN entries (and this code DOES assume all missing values have been imputed by a valid number),
         //this specific scenario should not occur, unless all values are the same (and given the same rank). In this case, there is no variation, and
         //correlation returns NaN. In theory this could happen on small number of entities being clustered. We give this a large distance:
-        console.log("NaN in correlation calculation");
+        console.log('NaN in correlation calculation');
         r = -2;
     }
     return 1 - r;
@@ -122,7 +125,7 @@ function preRankedSpearmanDist(item1:ProcessedItem, item2:ProcessedItem) {
  * It will pre-calculate ranks and store this in inputItems[x].preProcessedValueList.
  * This pre-calculation significantly improves the performance of the clustering step itself.
  */
-function _prepareForDistanceFunction(inputItems:Item[]) {
+function _prepareForDistanceFunction(inputItems: Item[]) {
     //pre-calculate ranks, and
     // split up into allNaN and notAllNaN
     var allNaN = [];
@@ -144,12 +147,10 @@ function _prepareForDistanceFunction(inputItems:Item[]) {
     }
     return {
         notAllNaN: notAllNaN,
-        allNaN: allNaN
+        allNaN: allNaN,
     };
 }
 
-
-
 /**
  * @param casesAndEntitites: Object with sample(or patient)Id and map
  * of geneticEntity/value pairs. Example:
@@ -166,7 +167,7 @@ function _prepareForDistanceFunction(inputItems:Item[]) {
  *
  *   @return the reordered list of sample(or patient) ids, after clustering.
  */
-function hclusterCases(casesAndEntitites:CasesAndEntities):CaseItem[] {
+function hclusterCases(casesAndEntitites: CasesAndEntities): CaseItem[] {
     var refEntityList = null;
     var inputItems = [];
     //add orderedValueList to all items, so the values are
@@ -189,16 +190,15 @@ function hclusterCases(casesAndEntitites:CasesAndEntities):CaseItem[] {
     if (refEntityList.length == 1) {
         //this is a special case, where the "clustering" becomes a simple sorting in 1 dimension:
         //so, just sort and return inputItems:
-        inputItems.sort(function (i1, i2) {
+        inputItems.sort(function(i1, i2) {
             var val1 = i1.orderedValueList[0];
             var val2 = i2.orderedValueList[0];
             //ensure NaNs are moved out (NaN or null which are seen here as equivalents to NA (not available)) to the end of the list:
-            val1 = (val1 == null || isNaN(val1) ? Number.MAX_VALUE : val1);
-            val2 = (val2 == null || isNaN(val2) ? Number.MAX_VALUE : val2);
+            val1 = val1 == null || isNaN(val1) ? Number.MAX_VALUE : val1;
+            val2 = val2 == null || isNaN(val2) ? Number.MAX_VALUE : val2;
             if (val1 > val2) {
                 return 1;
-            }
-            else if (val1 < val2) {
+            } else if (val1 < val2) {
                 return -1;
             }
             return 0;
@@ -207,11 +207,14 @@ function hclusterCases(casesAndEntitites:CasesAndEntities):CaseItem[] {
     }
     //else, normal clustering:
     var processedInputItems = _prepareForDistanceFunction(inputItems);
-    var clusters = clusterfck.hcluster(processedInputItems.notAllNaN, preRankedSpearmanDist);
+    var clusters = clusterfck.hcluster(
+        processedInputItems.notAllNaN,
+        preRankedSpearmanDist
+    );
     return clusters.clusters(1)[0].concat(processedInputItems.allNaN); // add all nan elements to the end post-sorting
 }
 
-function getRefList(caseItem:CasesAndEntities[""]) {
+function getRefList(caseItem: CasesAndEntities['']) {
     var result = [];
     for (var entityId in caseItem) {
         result.push(entityId);
@@ -224,7 +227,9 @@ function getRefList(caseItem:CasesAndEntities[""]) {
  *
  * @return the reordered list of entity ids, after clustering.
  */
-function hclusterGeneticEntities(casesAndEntitites:CasesAndEntities):EntityItem[] {
+function hclusterGeneticEntities(
+    casesAndEntitites: CasesAndEntities
+): EntityItem[] {
     var refEntityList = null;
     var inputItems = [];
     var refCaseIdList = [];
@@ -253,8 +258,11 @@ function hclusterGeneticEntities(casesAndEntitites:CasesAndEntities):EntityItem[
         inputItems.push(inputItem);
     }
     var processedInputItems = _prepareForDistanceFunction(inputItems);
-    var clusters = clusterfck.hcluster(processedInputItems.notAllNaN, preRankedSpearmanDist);
+    var clusters = clusterfck.hcluster(
+        processedInputItems.notAllNaN,
+        preRankedSpearmanDist
+    );
     return clusters.clusters(1)[0].concat(processedInputItems.allNaN); // add all nan elements to the end post-sorting
 }
 
-export default null;
+// export default null;