oncoprintjs 5.0.3 → 6.0.1

package/src/js/oncoprintshape.ts

@@ -1,141 +1,207 @@
-import {Datum} from "./oncoprintmodel";
-import {RGBAColor} from "./oncoprintruleset";
+import { Datum } from './oncoprintmodel';
+import { RGBAColor } from './oncoprintruleset';
 
-type StringParameter = "type";
-type PercentNumberParameter = "width" | "height" | "x" | "y" | "x1" | "x2" | "x3" | "y1" | "y2" | "y3";
-type PlainNumberParameter = "z" | "stroke-width" | "stroke-opacity";
-type RGBAParameter = "stroke" | "fill";
+type StringParameter = 'type';
+type PercentNumberParameter =
+    | 'width'
+    | 'height'
+    | 'x'
+    | 'y'
+    | 'x1'
+    | 'x2'
+    | 'x3'
+    | 'y1'
+    | 'y2'
+    | 'y3';
+type PlainNumberParameter = 'z' | 'stroke-width' | 'stroke-opacity';
+type RGBAParameter = 'stroke' | 'fill';
 type NumberParameter = PercentNumberParameter | PlainNumberParameter;
 type Parameter = StringParameter | NumberParameter | RGBAParameter;
 
-const default_parameter_values:{[x in StringParameter]?:string} & {[x in NumberParameter]?:number} & {[x in RGBAParameter]?:RGBAColor} = {
-    'width': 100,
-    'height': 100,
-    'x': 0,
-    'y': 0,
-    'z': 0,
-    'x1': 0,
-    'x2': 0,
-    'x3': 0,
-    'y1': 0,
-    'y2': 0,
-    'y3': 0,
-    'stroke': [0,0,0,0],
-    'fill': [23,23,23,1],
+const default_parameter_values: { [x in StringParameter]?: string } &
+    { [x in NumberParameter]?: number } &
+    { [x in RGBAParameter]?: RGBAColor } = {
+    width: 100,
+    height: 100,
+    x: 0,
+    y: 0,
+    z: 0,
+    x1: 0,
+    x2: 0,
+    x3: 0,
+    y1: 0,
+    y2: 0,
+    y3: 0,
+    stroke: [0, 0, 0, 0],
+    fill: [23, 23, 23, 1],
     'stroke-width': 0,
-    'stroke-opacity': 0
+    'stroke-opacity': 0,
 };
 
-const percent_parameter_name_to_dimension_index:{[x in PercentNumberParameter]:number} = {
-    'width': 0,
-    'x':0,
-    'x1':0,
-    'x2':0,
-    'x3':0,
-    'height':1,
-    'y':1,
-    'y1':1,
-    'y2':1,
-    'y3':1
+const percent_parameter_name_to_dimension_index: {
+    [x in PercentNumberParameter]: number;
+} = {
+    width: 0,
+    x: 0,
+    x1: 0,
+    x2: 0,
+    x3: 0,
+    height: 1,
+    y: 1,
+    y1: 1,
+    y2: 1,
+    y3: 1,
 };
 
-const hash_parameter_order:Parameter[] = [
-    "width", "height", "x", "y", "z", "x1", "x2", "x3", "y1", "y2", "y3", "stroke", "fill", "stroke-width", "stroke-opacity", "type"
+const hash_parameter_order: Parameter[] = [
+    'width',
+    'height',
+    'x',
+    'y',
+    'z',
+    'x1',
+    'x2',
+    'x3',
+    'y1',
+    'y2',
+    'y3',
+    'stroke',
+    'fill',
+    'stroke-width',
+    'stroke-opacity',
+    'type',
 ];
 
-type StringParamFunction = (d:Datum)=>string;
-type NumberParamFunction = (d:Datum)=>number;
-type RGBAParamFunction = (d:Datum)=>RGBAColor;
-type ParamFunction = StringParamFunction | NumberParamFunction | RGBAParamFunction;
+type StringParamFunction = (d: Datum) => string;
+type NumberParamFunction = (d: Datum) => number;
+type RGBAParamFunction = (d: Datum) => RGBAColor;
+type ParamFunction =
+    | StringParamFunction
+    | NumberParamFunction
+    | RGBAParamFunction;
 
-export type ShapeParams =
-    {[x in StringParameter]?:string|StringParamFunction} &
-    {[x in NumberParameter]?:number|NumberParamFunction} &
-    {[x in RGBAParameter]?:RGBAColor|RGBAParamFunction };
+export type ShapeParams = {
+    [x in StringParameter]?: string | StringParamFunction;
+} &
+    { [x in NumberParameter]?: number | NumberParamFunction } &
+    { [x in RGBAParameter]?: RGBAColor | RGBAParamFunction };
 
 type ShapeParamsWithType = {
-    [x in StringParameter]?:({ type:"function", value:StringParamFunction} | {type:"value", value:string})
-} & {
-    [x in NumberParameter]?:({ type:"function", value:NumberParamFunction} | {type:"value", value:number})
-} & {
-    [x in RGBAParameter]?:({ type:"function", value:RGBAParamFunction} | {type:"value", value:RGBAColor})
-};
+    [x in StringParameter]?:
+        | { type: 'function'; value: StringParamFunction }
+        | { type: 'value'; value: string };
+} &
+    {
+        [x in NumberParameter]?:
+            | { type: 'function'; value: NumberParamFunction }
+            | { type: 'value'; value: number };
+    } &
+    {
+        [x in RGBAParameter]?:
+            | { type: 'function'; value: RGBAParamFunction }
+            | { type: 'value'; value: RGBAColor };
+    };
 
-export type ComputedShapeParams = {[x in StringParameter]?:string} & {[x in NumberParameter]?:number} & {[x in RGBAParameter]?:RGBAColor};
+export type ComputedShapeParams = { [x in StringParameter]?: string } &
+    { [x in NumberParameter]?: number } &
+    { [x in RGBAParameter]?: RGBAColor };
 
-function isPercentParam(param_name:string):param_name is PercentNumberParameter {
+function isPercentParam(
+    param_name: string
+): param_name is PercentNumberParameter {
     return param_name in percent_parameter_name_to_dimension_index;
 }
 
 export class Shape {
-
-    private static cache:{[hash:string]:ComputedShapeParams} = {}; // shape cache to reuse objects and thus save memory
-    private params_with_type:ShapeParamsWithType = {};
-    private onlyDependsOnWidthAndHeight:boolean;
+    private static cache: { [hash: string]: ComputedShapeParams } = {}; // shape cache to reuse objects and thus save memory
+    private params_with_type: ShapeParamsWithType = {};
+    private onlyDependsOnWidthAndHeight: boolean;
 
     private instanceCache = {
-        lastComputedParams: null as ComputedShapeParams|null,
-        lastWidth:-1,
-        lastHeight:-1
+        lastComputedParams: null as ComputedShapeParams | null,
+        lastWidth: -1,
+        lastHeight: -1,
     };
 
-    constructor(private params:ShapeParams) {
+    constructor(private params: ShapeParams) {
         this.completeWithDefaults();
         this.markParameterTypes();
     }
 
-    public static hashComputedShape(computed_params:ComputedShapeParams, z_index?:number|string) {
-        return hash_parameter_order.reduce(function (hash:string, param_name:Parameter) {
-            return hash + "," + computed_params[param_name];
-        }, "") + "," + z_index;
+    public static hashComputedShape(
+        computed_params: ComputedShapeParams,
+        z_index?: number | string
+    ) {
+        return (
+            hash_parameter_order.reduce(function(
+                hash: string,
+                param_name: Parameter
+            ) {
+                return hash + ',' + computed_params[param_name];
+            },
+            '') +
+            ',' +
+            z_index
+        );
     }
 
-    private static getCachedShape(computed_params:ComputedShapeParams) {
+    private static getCachedShape(computed_params: ComputedShapeParams) {
         const hash = Shape.hashComputedShape(computed_params);
         Shape.cache[hash] = Shape.cache[hash] || Object.freeze(computed_params);
         return Shape.cache[hash];
     }
 
-    public getRequiredParameters():Parameter[] {
-        throw "Not defined for base class";
+    public getRequiredParameters(): Parameter[] {
+        throw 'Not defined for base class';
     }
 
     public completeWithDefaults() {
         const required_parameters = this.getRequiredParameters();
-        for (let i=0; i<required_parameters.length; i++) {
+        for (let i = 0; i < required_parameters.length; i++) {
             const param = required_parameters[i];
-            this.params[param] = (typeof this.params[param] === 'undefined' ? default_parameter_values[param] : this.params[param]) as any;
+            this.params[param] = (typeof this.params[param] === 'undefined'
+                ? default_parameter_values[param]
+                : this.params[param]) as any;
         }
     }
     public markParameterTypes() {
         const parameters = Object.keys(this.params) as Parameter[];
         let onlyDependsOnWidthAndHeight = true;
-        for (let i=0; i<parameters.length; i++) {
+        for (let i = 0; i < parameters.length; i++) {
             const param_name = parameters[i];
             const param_val = this.params[param_name];
             if (typeof param_val === 'function') {
-                //@ts-ignore
-                this.params_with_type[param_name] = {'type':'function', 'value':param_val};
+                this.params_with_type[param_name] = {
+                    type: 'function',
+                    value: param_val as any,
+                };
                 onlyDependsOnWidthAndHeight = false;
             } else {
-                //@ts-ignore
-                this.params_with_type[param_name] = {'type':'value', 'value': param_val};
+                this.params_with_type[param_name] = {
+                    type: 'value',
+                    value: param_val,
+                } as any;
             }
         }
         this.onlyDependsOnWidthAndHeight = onlyDependsOnWidthAndHeight;
     }
-    public getComputedParams(d:Datum, base_width:number, base_height:number) {
-        if (this.onlyDependsOnWidthAndHeight &&
+    public getComputedParams(
+        d: Datum,
+        base_width: number,
+        base_height: number
+    ) {
+        if (
+            this.onlyDependsOnWidthAndHeight &&
             this.instanceCache.lastWidth === base_width &&
-            this.instanceCache.lastHeight === base_height) {
-
+            this.instanceCache.lastHeight === base_height
+        ) {
             return this.instanceCache.lastComputedParams!;
         }
 
-        const computed_params:Partial<ComputedShapeParams> = {};
+        const computed_params: Partial<ComputedShapeParams> = {};
         const param_names = Object.keys(this.params_with_type) as Parameter[];
-        const dimensions:[number, number] = [base_width, base_height];
-        for (let i=0; i<param_names.length; i++) {
+        const dimensions: [number, number] = [base_width, base_height];
+        for (let i = 0; i < param_names.length; i++) {
             const param_name = param_names[i];
             const param_val_map = this.params_with_type[param_name];
             let param_val = param_val_map.value;
@@ -147,7 +213,13 @@ export class Shape {
 
                 if (isPercentParam(param_name)) {
                     // if its a percentage param, compute value as percentage of width or height
-                    param_val = (param_val as number)/100 * dimensions[percent_parameter_name_to_dimension_index[param_name]];
+                    param_val =
+                        ((param_val as number) / 100) *
+                        dimensions[
+                            percent_parameter_name_to_dimension_index[
+                                param_name
+                            ]
+                        ];
                 }
             }
             //@ts-ignore
@@ -158,46 +230,117 @@ export class Shape {
             // only cache if its cacheable, otherwise it would be a waste of memory to save
             this.instanceCache.lastHeight = base_height;
             this.instanceCache.lastWidth = base_width;
-            this.instanceCache.lastComputedParams = Shape.getCachedShape(computed_params);
+            this.instanceCache.lastComputedParams = Shape.getCachedShape(
+                computed_params
+            );
         }
 
         return Shape.getCachedShape(computed_params);
-    };
+    }
 }
 
-type SpecificComputedShapeParams<ShapeParamType> =
-    {[x in ShapeParamType & StringParameter]:string} &
-    {[x in ShapeParamType & NumberParameter]:number} &
-    {[x in ShapeParamType & RGBAParameter]:RGBAColor};
+type SpecificComputedShapeParams<ShapeParamType> = {
+    [x in ShapeParamType & StringParameter]: string;
+} &
+    { [x in ShapeParamType & NumberParameter]: number } &
+    { [x in ShapeParamType & RGBAParameter]: RGBAColor };
 
-type RectangleParameter = "width" | "height" | "x" | "y" | "z" | "stroke" | "stroke-width" | "fill";
-export type ComputedRectangleParams = SpecificComputedShapeParams<RectangleParameter>;
+type RectangleParameter =
+    | 'width'
+    | 'height'
+    | 'x'
+    | 'y'
+    | 'z'
+    | 'stroke'
+    | 'stroke-width'
+    | 'fill';
+export type ComputedRectangleParams = SpecificComputedShapeParams<
+    RectangleParameter
+>;
 export class Rectangle extends Shape {
     public getRequiredParameters(): RectangleParameter[] {
-        return ['width', 'height', 'x', 'y', 'z', 'stroke', 'fill', 'stroke-width'];
+        return [
+            'width',
+            'height',
+            'x',
+            'y',
+            'z',
+            'stroke',
+            'fill',
+            'stroke-width',
+        ];
     }
 }
 
-type TriangleParameter = "x1" | "x2" | "x3" | "y1" | "y2" | "y3" | "z" | "stroke" | "stroke-width" | "fill";
-export type ComputedTriangleParams = SpecificComputedShapeParams<TriangleParameter>;
+type TriangleParameter =
+    | 'x1'
+    | 'x2'
+    | 'x3'
+    | 'y1'
+    | 'y2'
+    | 'y3'
+    | 'z'
+    | 'stroke'
+    | 'stroke-width'
+    | 'fill';
+export type ComputedTriangleParams = SpecificComputedShapeParams<
+    TriangleParameter
+>;
 export class Triangle extends Shape {
     public getRequiredParameters(): TriangleParameter[] {
-        return ['x1', 'x2', 'x3', 'y1', 'y2', 'y3', 'z', 'stroke', 'fill', 'stroke-width'];
+        return [
+            'x1',
+            'x2',
+            'x3',
+            'y1',
+            'y2',
+            'y3',
+            'z',
+            'stroke',
+            'fill',
+            'stroke-width',
+        ];
     }
 }
 
-export type EllipseParameter = "width" | "height" | "x" | "y" | "z" | "stroke" | "stroke-width" | "fill";
-export type ComputedEllipseParams = SpecificComputedShapeParams<EllipseParameter>;
+export type EllipseParameter =
+    | 'width'
+    | 'height'
+    | 'x'
+    | 'y'
+    | 'z'
+    | 'stroke'
+    | 'stroke-width'
+    | 'fill';
+export type ComputedEllipseParams = SpecificComputedShapeParams<
+    EllipseParameter
+>;
 export class Ellipse extends Shape {
     public getRequiredParameters(): EllipseParameter[] {
-        return ['width', 'height', 'x', 'y', 'z', 'stroke', 'fill', 'stroke-width'];
+        return [
+            'width',
+            'height',
+            'x',
+            'y',
+            'z',
+            'stroke',
+            'fill',
+            'stroke-width',
+        ];
     }
 }
 
-export type LineParameter = "x1" | "y1" | "x2" | "y2" | "z" | "stroke" | "stroke-width";
+export type LineParameter =
+    | 'x1'
+    | 'y1'
+    | 'x2'
+    | 'y2'
+    | 'z'
+    | 'stroke'
+    | 'stroke-width';
 export type ComputedLineParams = SpecificComputedShapeParams<LineParameter>;
 export class Line extends Shape {
     public getRequiredParameters(): LineParameter[] {
         return ['x1', 'x2', 'y1', 'y2', 'z', 'stroke', 'stroke-width'];
     }
-}
+}

package/src/js/oncoprintshapetosvg.ts

@@ -1,28 +1,40 @@
 import makeSVGElement from './makesvgelement';
 import extractRGBA from './extractrgba';
 import {
-    ComputedEllipseParams, ComputedLineParams,
+    ComputedEllipseParams,
+    ComputedLineParams,
     ComputedRectangleParams,
     ComputedShapeParams,
-    ComputedTriangleParams
-} from "./oncoprintshape";
-import {rgbString} from "./utils";
+    ComputedTriangleParams,
+} from './oncoprintshape';
+import { rgbString } from './utils';
 
-function extractColor(str:string) {
-    if (str.indexOf("rgb(") > -1) {
+function extractColor(str: string) {
+    if (str.indexOf('rgb(') > -1) {
         return {
-            'rgb': str,
-            'opacity': 1
+            rgb: str,
+            opacity: 1,
         };
     }
     const rgba_arr = extractRGBA(str);
     return {
-        'rgb': 'rgb('+rgba_arr[0]*255+','+rgba_arr[1]*255+','+rgba_arr[2]*255+')',
-        'opacity': rgba_arr[3]
+        rgb:
+            'rgb(' +
+            rgba_arr[0] * 255 +
+            ',' +
+            rgba_arr[1] * 255 +
+            ',' +
+            rgba_arr[2] * 255 +
+            ')',
+        opacity: rgba_arr[3],
     };
 }
 
-function rectangleToSVG(params:ComputedRectangleParams, offset_x:number, offset_y:number) {
+function rectangleToSVG(
+    params: ComputedRectangleParams,
+    offset_x: number,
+    offset_y: number
+) {
     return makeSVGElement('rect', {
         width: params.width,
         height: params.height,
@@ -32,24 +44,38 @@ function rectangleToSVG(params:ComputedRectangleParams, offset_x:number, offset_
         'stroke-opacity': params.stroke[3],
         'stroke-width': params['stroke-width'],
         fill: rgbString(params.fill),
-        'fill-opacity': params.fill[3]
+        'fill-opacity': params.fill[3],
     });
 }
 
-function triangleToSVG(params:ComputedTriangleParams, offset_x:number, offset_y:number) {
+function triangleToSVG(
+    params: ComputedTriangleParams,
+    offset_x: number,
+    offset_y: number
+) {
     return makeSVGElement('polygon', {
-        points: [[params.x1 + offset_x, params.y1 + offset_y], [params.x2 + offset_x, params.y2 + offset_y], [params.x3 + offset_x, params.y3 + offset_y]].map(function (a) {
-            return a[0] + ',' + a[1];
-        }).join(' '),
+        points: [
+            [params.x1 + offset_x, params.y1 + offset_y],
+            [params.x2 + offset_x, params.y2 + offset_y],
+            [params.x3 + offset_x, params.y3 + offset_y],
+        ]
+            .map(function(a) {
+                return a[0] + ',' + a[1];
+            })
+            .join(' '),
         stroke: rgbString(params.stroke),
         'stroke-opacity': params.stroke[3],
         'stroke-width': params['stroke-width'],
         fill: rgbString(params.fill),
-        'fill-opacity': params.fill[3]
+        'fill-opacity': params.fill[3],
     });
 }
 
-function ellipseToSVG(params:ComputedEllipseParams, offset_x:number, offset_y:number) {
+function ellipseToSVG(
+    params: ComputedEllipseParams,
+    offset_x: number,
+    offset_y: number
+) {
     return makeSVGElement('ellipse', {
         rx: params.width / 2,
         height: params.height / 2,
@@ -59,11 +85,15 @@ function ellipseToSVG(params:ComputedEllipseParams, offset_x:number, offset_y:nu
         'stroke-opacity': params.stroke[3],
         'stroke-width': params['stroke-width'],
         fill: rgbString(params.fill),
-        'fill-opacity': params.fill[3]
+        'fill-opacity': params.fill[3],
     });
 }
 
-function lineToSVG(params:ComputedLineParams, offset_x:number, offset_y:number) {
+function lineToSVG(
+    params: ComputedLineParams,
+    offset_x: number,
+    offset_y: number
+) {
     return makeSVGElement('line', {
         x1: params.x1 + offset_x,
         y1: params.y1 + offset_y,
@@ -75,15 +105,36 @@ function lineToSVG(params:ComputedLineParams, offset_x:number, offset_y:number)
     });
 }
 
-export default function shapeToSVG(oncoprint_shape_computed_params:ComputedShapeParams, offset_x:number, offset_y:number) {
+export default function shapeToSVG(
+    oncoprint_shape_computed_params: ComputedShapeParams,
+    offset_x: number,
+    offset_y: number
+) {
     var type = oncoprint_shape_computed_params.type;
     if (type === 'rectangle') {
-        return rectangleToSVG(oncoprint_shape_computed_params as ComputedRectangleParams, offset_x, offset_y);
+        return rectangleToSVG(
+            oncoprint_shape_computed_params as ComputedRectangleParams,
+            offset_x,
+            offset_y
+        );
     } else if (type === 'triangle') {
-        return triangleToSVG(oncoprint_shape_computed_params as ComputedTriangleParams, offset_x, offset_y);
+        return triangleToSVG(
+            oncoprint_shape_computed_params as ComputedTriangleParams,
+            offset_x,
+            offset_y
+        );
     } else if (type === 'ellipse') {
-        return ellipseToSVG(oncoprint_shape_computed_params as ComputedEllipseParams, offset_x, offset_y);
+        return ellipseToSVG(
+            oncoprint_shape_computed_params as ComputedEllipseParams,
+            offset_x,
+            offset_y
+        );
     } else if (type === 'line') {
-        return lineToSVG(oncoprint_shape_computed_params as ComputedLineParams, offset_x, offset_y);
+        return lineToSVG(
+            oncoprint_shape_computed_params as ComputedLineParams,
+            offset_x,
+            offset_y
+        );
     }
-}
+    return undefined;
+}