linting improvements

- check tsx as well
- check brace-style
- error more instead of warn

.eslintrc.json

@@ -14,8 +14,9 @@
     "rules": {
         "@typescript-eslint/ban-types": "warn",
         "@typescript-eslint/class-name-casing": "off",
+        "indent": "off",
         "@typescript-eslint/indent": [
-            "warn",
+            "error",
             4
         ],
         "@typescript-eslint/member-delimiter-style": [
@@ -33,7 +34,7 @@
         ],
         "@typescript-eslint/prefer-namespace-keyword": "warn",
         "@typescript-eslint/quotes": [
-            "warn",
+            "error",
             "single",
             {
                 "avoidEscape": true,
@@ -44,22 +45,27 @@
             "off",
             null
         ],
-        "@typescript-eslint/type-annotation-spacing": "warn",
+        "@typescript-eslint/type-annotation-spacing": "error",
         "arrow-parens": [
             "off",
             "as-needed"
         ],
+        "brace-style": "off",
+        "@typescript-eslint/brace-style": [
+            "error",
+            "1tbs", { "allowSingleLine": true }
+        ],
         "comma-dangle": "off",
         "eqeqeq": [
-            "warn",
+            "error",
             "smart"
         ],
         "import/order": "off",
         "no-eval": "warn",
         "no-new-wrappers": "warn",
-        "no-trailing-spaces": "warn",
+        "no-trailing-spaces": "error",
         "no-unsafe-finally": "warn",
-        "no-var": "warn",
-        "spaced-comment": "warn"
+        "no-var": "error",
+        "spaced-comment": "error"
     }
 }

package.json

@@ -11,7 +11,7 @@
     "url": "https://github.com/molstar/molstar/issues"
   },
   "scripts": {
-    "lint": "eslint src/**/*.ts",
+    "lint": "eslint src/**/*.{ts,tsx}",
     "test": "npm run lint && jest",
     "build": "npm run build-tsc && npm run build-extra && npm run build-webpack",
     "build-tsc": "tsc --incremental",

src/examples/proteopedia-wrapper/ui/controls.tsx

@@ -13,7 +13,6 @@ import { StateElements } from '../helpers';
 
 export function volumeStreamingControls(plugin: PluginContext, parent: Element) {
     ReactDOM.render(<PluginContextContainer plugin={plugin}>
-            <TransformUpdaterControl nodeRef={StateElements.VolumeStreaming} />
-        </PluginContextContainer>,
-        parent);
+        <TransformUpdaterControl nodeRef={StateElements.VolumeStreaming} />
+    </PluginContextContainer>, parent);
 }

src/mol-data/generic/linked-list.ts

@@ -89,15 +89,13 @@ class LinkedListImpl<T> implements LinkedList<T> {
 
         if (node.previous !== null) {
             node.previous.next = node.next;
-        }
-        else if (/* first == item*/ node.previous === null) {
+        } else if (/* first == item*/ node.previous === null) {
             this.first = node.next;
         }
 
         if (node.next !== null) {
             node.next.previous = node.previous;
-        }
-        else if (/* last == item*/ node.next === null) {
+        } else if (/* last == item*/ node.next === null) {
             this.last = node.previous;
         }
 

src/mol-data/int/impl/ordered-set.ts

@@ -150,8 +150,11 @@ function unionII(a: I, b: I) {
     const minA = I.min(a), minB = I.min(b);
     if (areRangesIntersecting(a, b)) return I.ofRange(Math.min(minA, minB), Math.max(I.max(a), I.max(b)));
     let lSize, lMin, rSize, rMin;
-    if (minA < minB) { lSize = sizeA; lMin = minA; rSize = sizeB; rMin = minB; }
-    else { lSize = sizeB; lMin = minB; rSize = sizeA; rMin = minA; }
+    if (minA < minB) {
+        lSize = sizeA; lMin = minA; rSize = sizeB; rMin = minB;
+    } else {
+        lSize = sizeB; lMin = minB; rSize = sizeA; rMin = minA;
+    }
     const arr = new Int32Array(sizeA + sizeB);
     for (let i = 0; i < lSize; i++) arr[i] = i + lMin;
     for (let i = 0; i < rSize; i++) arr[i + lSize] = i + rMin;
@@ -328,9 +331,13 @@ export function indexedIntersect(idxA: OrderedSetImpl, a: S, b: S): OrderedSetIm
     let j = startJ;
     while (O < lenI && j < endJ) {
         const x = a[getAt(idxA, O)], y = b[j];
-        if (x < y) { O++; }
-        else if (x > y) { j++; }
-        else { commonCount++; O++; j++; }
+        if (x < y) {
+            O++;
+        } else if (x > y) {
+            j++;
+        } else {
+            commonCount++; O++; j++;
+        }
     }
 
     // no common elements
@@ -345,9 +352,13 @@ export function indexedIntersect(idxA: OrderedSetImpl, a: S, b: S): OrderedSetIm
     j = startJ;
     while (O < lenI && j < endJ) {
         const x = a[getAt(idxA, O)], y = b[j];
-        if (x < y) { O++; }
-        else if (x > y) { j++; }
-        else { indices[offset++] = j; O++; j++; }
+        if (x < y) {
+            O++;
+        } else if (x > y) {
+            j++;
+        } else {
+            indices[offset++] = j; O++; j++;
+        }
     }
 
     return ofSortedArray(indices);

src/mol-data/int/impl/sorted-array.ts

@@ -146,8 +146,8 @@ export function areIntersecting(a: Nums, b: Nums) {
     let { startI: i, startJ: j, endI, endJ } = getSuitableIntersectionRange(a, b);
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { i++; }
-        else if (x > y) { j++; }
+        if (x < y) i++;
+        else if (x > y) j++;
         else return true;
     }
     return false;
@@ -164,9 +164,13 @@ export function isSubset(a: Nums, b: Nums) {
     let equal = 0;
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { i++; }
-        else if (x > y) { j++; }
-        else { i++; j++; equal++; }
+        if (x < y) {
+            i++;
+        } else if (x > y) {
+            j++;
+        } else {
+            i++; j++; equal++;
+        }
     }
     return equal === lenB;
 }
@@ -197,9 +201,13 @@ export function union(a: Nums, b: Nums): Nums {
     // insert the common part
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { indices[offset++] = x; i++; }
-        else if (x > y) { indices[offset++] = y; j++; }
-        else { indices[offset++] = x; i++; j++; }
+        if (x < y) {
+            indices[offset++] = x; i++;
+        } else if (x > y) {
+            indices[offset++] = y; j++;
+        } else {
+            indices[offset++] = x; i++; j++;
+        }
     }
 
     // insert the remaining common part
@@ -224,9 +232,13 @@ function getCommonCount(a: Nums, b: Nums, startI: number, startJ: number, endI:
     let commonCount = 0;
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { i++; }
-        else if (x > y) { j++; }
-        else { i++; j++; commonCount++; }
+        if (x < y) {
+            i++;
+        } else if (x > y) {
+            j++;
+        } else {
+            i++; j++; commonCount++;
+        }
     }
     return commonCount;
 }
@@ -251,9 +263,13 @@ export function intersect(a: Nums, b: Nums) {
     let j = startJ;
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { i++; }
-        else if (x > y) { j++; }
-        else { indices[offset++] = x; i++; j++; }
+        if (x < y) {
+            i++;
+        } else if (x > y) {
+            j++;
+        } else {
+            indices[offset++] = x; i++; j++;
+        }
     }
 
     return ofSortedArray(indices);
@@ -268,9 +284,13 @@ export function subtract(a: Nums, b: Nums) {
     let commonCount = 0;
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { i++; }
-        else if (x > y) { j++; }
-        else { i++; j++; commonCount++; }
+        if (x < y) {
+            i++;
+        } else if (x > y) {
+            j++;
+        } else {
+            i++; j++; commonCount++;
+        }
     }
 
     // A isnt intersecting B ===> A
@@ -288,9 +308,13 @@ export function subtract(a: Nums, b: Nums) {
     j = sJ;
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { indices[offset++] = x; i++; }
-        else if (x > y) { j++; }
-        else { i++; j++; }
+        if (x < y) {
+            indices[offset++] = x; i++;
+        } else if (x > y) {
+            j++;
+        } else {
+            i++; j++;
+        }
     }
 
     // insert the "tail"
@@ -323,9 +347,13 @@ export function indicesOf(a: Nums, b: Nums): Nums {
     let commonCount = 0;
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { i++; }
-        else if (x > y) { j++; }
-        else { i++; j++; commonCount++; }
+        if (x < y) {
+            i++;
+        } else if (x > y) {
+            j++;
+        } else {
+            i++; j++; commonCount++;
+        }
     }
 
     const lenA = a.length;
@@ -340,9 +368,13 @@ export function indicesOf(a: Nums, b: Nums): Nums {
     j = sJ;
     while (i < endI && j < endJ) {
         const x = a[i], y = b[j];
-        if (x < y) { i++; }
-        else if (x > y) { j++; }
-        else { indices[offset++] = i; i++; j++; }
+        if (x < y) {
+            i++;
+        } else if (x > y) {
+            j++;
+        } else {
+            indices[offset++] = i; i++; j++;
+        }
     }
 
     return ofSortedArray(indices);

src/mol-io/common/msgpack/encode.ts

@@ -88,8 +88,7 @@ function encodedSize(value: any) {
             for (let i = 0; i < length; i++) {
                 size += encodedSize(value[i]);
             }
-        }
-        else {
+        } else {
             let keys = Object.keys(value);
             length = keys.length;
             for (let i = 0; i < length; i++) {
@@ -257,8 +256,7 @@ function encodeInternal(value: any, view: DataView, bytes: Uint8Array, offset: n
 
         if (isArray) {
             length = value.length;
-        }
-        else {
+        } else {
             keys = Object.keys(value);
             length = keys.length;
         }
@@ -266,13 +264,11 @@ function encodeInternal(value: any, view: DataView, bytes: Uint8Array, offset: n
         if (length < 0x10) {
             view.setUint8(offset, length | (isArray ? 0x90 : 0x80));
             size = 1;
-        }
-        else if (length < 0x10000) {
+        } else if (length < 0x10000) {
             view.setUint8(offset, isArray ? 0xdc : 0xde);
             view.setUint16(offset + 1, length);
             size = 3;
-        }
-        else if (length < 0x100000000) {
+        } else if (length < 0x100000000) {
             view.setUint8(offset, isArray ? 0xdd : 0xdf);
             view.setUint32(offset + 1, length);
             size = 5;
@@ -282,8 +278,7 @@ function encodeInternal(value: any, view: DataView, bytes: Uint8Array, offset: n
             for (let i = 0; i < length; i++) {
                 size += encodeInternal(value[i], view, bytes, offset + size);
             }
-        }
-        else {
+        } else {
             for (let i = 0, _i = keys!.length; i < _i; i++) {
                 const key = keys![i];
                 size += encodeInternal(key, view, bytes, offset + size);

src/mol-io/common/utf8.ts

@@ -59,24 +59,21 @@ function _utf8Read(data: Uint8Array, offset: number, length: number) {
 
     for (let i = offset, end = offset + length; i < end; i++) {
         let byte = data[i];
-        // One byte character
         if ((byte & 0x80) === 0x00) {
+            // One byte character
             chunk[chunkOffset++] = chars[byte];
-        }
-        // Two byte character
-        else if ((byte & 0xe0) === 0xc0) {
+        } else if ((byte & 0xe0) === 0xc0) {
+            // Two byte character
             chunk[chunkOffset++] = chars[((byte & 0x0f) << 6) | (data[++i] & 0x3f)];
-        }
-        // Three byte character
-        else if ((byte & 0xf0) === 0xe0) {
+        } else if ((byte & 0xf0) === 0xe0) {
+            // Three byte character
             chunk[chunkOffset++] = String.fromCharCode(
                 ((byte & 0x0f) << 12) |
                 ((data[++i] & 0x3f) << 6) |
                 ((data[++i] & 0x3f) << 0)
             );
-        }
-        // Four byte character
-        else if ((byte & 0xf8) === 0xf0) {
+        } else if ((byte & 0xf8) === 0xf0) {
+            // Four byte character
             chunk[chunkOffset++] = String.fromCharCode(
                 ((byte & 0x07) << 18) |
                 ((data[++i] & 0x3f) << 12) |

src/mol-io/reader/common/text/number-parser.ts

@@ -71,8 +71,9 @@ export function parseFloat(str: string, start: number, end: number) {
             return neg * (ret + point / div);
         } else if (c === 53 || c === 21) { // 'e'/'E'
             return parseScientific(neg * ret, str, _start + 1, end);
+        } else {
+            break;
         }
-        else break;
     }
     return neg * ret;
 }
@@ -137,8 +138,9 @@ export function getNumberType(str: string): NumberType {
                 return NumberType.NaN; // string starts with e/E or -e/-E
             }
             return getNumberTypeScientific(str, start + 1, end);
+        } else {
+            break;
         }
-        else break;
     }
     return start === end ? NumberType.Int : NumberType.NaN;
 }

src/mol-io/writer/cif/encoder/binary.ts

@@ -188,8 +188,7 @@ function getFieldData(field: Field<any, any>, arrayCtor: ArrayCtor<string | numb
                 if (isStr)
                     array[offset] = '';
                 allPresent = false;
-            }
-            else {
+            } else {
                 mask[offset] = Column.ValueKind.Present;
                 array[offset] = getter(key, d, offset);
             }

src/mol-math/graph/int-adjacency-graph.ts

@@ -54,8 +54,11 @@ export namespace IntAdjacencyGraph {
 
         getEdgeIndex(i: VertexIndex, j: VertexIndex): number {
             let a, b;
-            if (i < j) { a = i; b = j; }
-            else { a = j; b = i; }
+            if (i < j) {
+                a = i; b = j;
+            } else {
+                a = j; b = i;
+            }
             for (let t = this.offset[a], _t = this.offset[a + 1]; t < _t; t++) {
                 if (this.b[t] === b) return t;
             }

src/mol-math/linear-algebra/matrix/evd.ts

@@ -77,8 +77,7 @@ function symmetricTridiagonalize(a: number[], d: number[], e: number[], order: n
                 a[(j * order) + i] = 0.0;
                 a[(i * order) + j] = 0.0;
             }
-        }
-        else {
+        } else {
             // Generate Householder vector.
             for (let k = 0; k < i; k++) {
                 d[k] /= scale;

src/mol-model/structure/query/utils/structure-set.ts

@@ -44,8 +44,11 @@ export function structureAreIntersecting(sA: Structure, sB: Structure): boolean
     if (sA === sB) return true;
 
     let a, b;
-    if (sA.units.length < sB.units.length) { a = sA; b = sB; }
-    else { a = sB; b = sA; }
+    if (sA.units.length < sB.units.length) {
+        a = sA; b = sB;
+    } else {
+        a = sB; b = sA;
+    }
 
     const aU = a.units, bU = b.unitMap;
 
@@ -64,8 +67,11 @@ export function structureIntersect(sA: Structure, sB: Structure): Structure {
     if (!structureAreIntersecting(sA, sB)) return Structure.Empty;
 
     let a, b;
-    if (sA.units.length < sB.units.length) { a = sA; b = sB; }
-    else { a = sB; b = sA; }
+    if (sA.units.length < sB.units.length) {
+        a = sA; b = sB;
+    } else {
+        a = sB; b = sA;
+    }
 
     const aU = a.units, bU = b.unitMap;
     const units: Unit[] = [];

src/mol-model/structure/structure/util/subset-builder.ts

@@ -21,8 +21,9 @@ export class StructureSubsetBuilder {
 
     addToUnit(parentId: number, e: ElementIndex) {
         const unit = this.unitMap.get(parentId);
-        if (!!unit) { unit[unit.length] = e; }
-        else {
+        if (!!unit) {
+            unit[unit.length] = e;
+        } else {
             this.unitMap.set(parentId, [e]);
             this.ids[this.ids.length] = parentId;
         }

src/mol-model/structure/structure/util/unique-subset-builder.ts

@@ -24,8 +24,7 @@ export class StructureUniqueSubsetBuilder {
         const unit = this.unitMap.get(parentId);
         if (!!unit) {
             if (UniqueArray.add(unit, e, e)) this.elementCount++;
-        }
-        else {
+        } else {
             const arr: UArray = UniqueArray.create();
             UniqueArray.add(arr, e, e);
             this.unitMap.set(parentId, arr);

src/mol-plugin-state/snapshots.ts

@@ -210,8 +210,9 @@ class PluginStateSnapshotManager extends StatefulPluginComponent<{
         if (this.state.isPlaying) {
             this.stop();
             this.plugin.state.animation.stop();
+        } else {
+            this.play();
         }
-        else this.play();
     }
 
     constructor(private plugin: PluginContext) {

src/mol-plugin-ui/controls/line-graph/line-graph-component.tsx

@@ -15,7 +15,7 @@ interface LineGraphComponentState {
 }
 
 export default class LineGraphComponent extends React.Component<any, LineGraphComponentState> {
-    private myRef:any;
+    private myRef: any;
     private height: number;
     private width: number;
     private padding: number;
@@ -123,11 +123,11 @@ export default class LineGraphComponent extends React.Component<any, LineGraphCo
         // TODO: SET canSelectMultiple = fasle
     }
 
-    private handleClick = (id:number) => (event:any) => {
+    private handleClick = (id: number) => (event: any) => {
         // TODO: add point to selected array
     }
 
-    private handleMouseDown = (id:number) => (event: any) => {
+    private handleMouseDown = (id: number) => (event: any) => {
         if(id === 0 || id === this.state.points.length-1){
             return;
         }
@@ -164,17 +164,13 @@ export default class LineGraphComponent extends React.Component<any, LineGraphCo
 
         if ((svgP.x < (padding) || svgP.x > (this.width+(padding))) && (svgP.y > (this.height+(padding)) || svgP.y < (padding))) {
             updatedCopyPoint = Vec2.create(this.updatedX, this.updatedY);
-        }
-        else if (svgP.x < padding) {
+        } else if (svgP.x < padding) {
             updatedCopyPoint = Vec2.create(padding, svgP.y);
-        }
-        else if( svgP.x > (this.width+(padding))) {
+        } else if( svgP.x > (this.width+(padding))) {
             updatedCopyPoint = Vec2.create(this.width+padding, svgP.y);
-        }
-        else if (svgP.y > (this.height+(padding))) {
+        } else if (svgP.y > (this.height+(padding))) {
             updatedCopyPoint = Vec2.create(svgP.x, this.height+padding);
-        }
-        else if (svgP.y < (padding)) {
+        } else if (svgP.y < (padding)) {
             updatedCopyPoint = Vec2.create(svgP.x, padding);
         } else {
             updatedCopyPoint = Vec2.create(svgP.x, svgP.y);
@@ -230,8 +226,8 @@ export default class LineGraphComponent extends React.Component<any, LineGraphCo
         this.change(points);
         this.gElement.innerHTML = '';
         this.ghostPoints = [];
-        document.removeEventListener("mousemove", this.handleDrag, true);
-        document.removeEventListener("mouseup", this.handlePointUpdate, true);
+        document.removeEventListener('mousemove', this.handleDrag, true);
+        document.removeEventListener('mouseup', this.handlePointUpdate, true);
     }
 
     private handleDoubleClick(event: any) {
@@ -267,8 +263,8 @@ export default class LineGraphComponent extends React.Component<any, LineGraphCo
         this.change(points);
     }
 
-    private deletePoint = (i:number) => (event: any) => {
-    if(i===0 || i===this.state.points.length-1){ return; }
+    private deletePoint = (i: number) => (event: any) => {
+        if(i===0 || i===this.state.points.length-1){ return; }
         const points = this.state.points.filter((_,j) => j !== i);
         points.sort((a, b) => {
             if(a[0] === b[0]){
@@ -334,21 +330,21 @@ export default class LineGraphComponent extends React.Component<any, LineGraphCo
         const points: any[] = [];
         let point: Vec2;
         for (let i = 0; i < this.state.points.length; i++){
-            if(i != 0 && i != this.state.points.length-1){
+            if(i !== 0 && i !== this.state.points.length-1){
                 point = this.normalizePoint(this.state.points[i]);
                 points.push(<PointComponent
-                        key={i}
-                        id={i}
-                        x={point[0]}
-                        y={point[1]}
-                        nX={this.state.points[i][0]}
-                        nY={this.state.points[i][1]}
-                        selected={false}
-                        delete={this.deletePoint}
-                        onmouseover={this.props.onHover}
-                        onmousedown={this.handleMouseDown(i)}
-                        onclick={this.handleClick(i)}
-                    />);
+                    key={i}
+                    id={i}
+                    x={point[0]}
+                    y={point[1]}
+                    nX={this.state.points[i][0]}
+                    nY={this.state.points[i][1]}
+                    selected={false}
+                    delete={this.deletePoint}
+                    onmouseover={this.props.onHover}
+                    onmousedown={this.handleMouseDown(i)}
+                    onclick={this.handleClick(i)}
+                />);
             }
         }
         return points;
@@ -357,8 +353,8 @@ export default class LineGraphComponent extends React.Component<any, LineGraphCo
     private renderLines() {
         const points: Vec2[] = [];
         let lines = [];
-        let min:number;
-        let maxX:number;
+        let min: number;
+        let maxX: number;
         let maxY: number;
         let normalizedX: number;
         let normalizedY: number;

src/mol-plugin-ui/controls/slider.tsx

@@ -733,7 +733,7 @@ export class SliderBase extends React.Component<SliderBaseProps, SliderBaseState
             ref: this.handleElements[i]
         }));
         if (!range) { handles.shift(); }
- 
+
         const sliderClassName = classNames({
             [prefixCls!]: true,
             [`${prefixCls}-with-marks`]: Object.keys(marks).length,
@@ -743,8 +743,8 @@ export class SliderBase extends React.Component<SliderBaseProps, SliderBaseState
         });
 
         return (
-            <div ref={this.sliderElement} className={sliderClassName} 
-                onTouchStart={disabled ? noop : this.onTouchStart as any} 
+            <div ref={this.sliderElement} className={sliderClassName}
+                onTouchStart={disabled ? noop : this.onTouchStart as any}
                 onMouseDown={disabled ? noop : this.onMouseDown as any}
             >
                 <div className={`${prefixCls}-rail`} />

src/mol-script/runtime/query/table.ts

@@ -228,36 +228,46 @@ const symbols = [
     })(ctx)),
 
     // ============= GENERATORS ================
-    D(MolScript.structureQuery.generator.atomGroups, function structureQuery_generator_atomGroups(ctx, xs) { return Queries.generators.atoms({
-        entityTest: xs['entity-test'],
-        chainTest: xs['chain-test'],
-        residueTest: xs['residue-test'],
-        atomTest: xs['atom-test'],
-        groupBy: xs['group-by']
-    })(ctx) }),
+    D(MolScript.structureQuery.generator.atomGroups, function structureQuery_generator_atomGroups(ctx, xs) {
+        return Queries.generators.atoms({
+            entityTest: xs['entity-test'],
+            chainTest: xs['chain-test'],
+            residueTest: xs['residue-test'],
+            atomTest: xs['atom-test'],
+            groupBy: xs['group-by']
+        })(ctx)
+    }),
 
     D(MolScript.structureQuery.generator.all, function structureQuery_generator_all(ctx) { return Queries.generators.all(ctx) }),
     D(MolScript.structureQuery.generator.empty, function structureQuery_generator_empty(ctx) { return Queries.generators.none(ctx) }),
-    D(MolScript.structureQuery.generator.bondedAtomicPairs, function structureQuery_generator_bondedAtomicPairs(ctx, xs) { return Queries.generators.bondedAtomicPairs(xs && xs[0])(ctx) }),
-    D(MolScript.structureQuery.generator.rings, function structureQuery_generator_rings(ctx, xs) { return Queries.generators.rings(xs?.['fingerprint']?.(ctx) as any, xs?.['only-aromatic']?.(ctx))(ctx) }),
+    D(MolScript.structureQuery.generator.bondedAtomicPairs, function structureQuery_generator_bondedAtomicPairs(ctx, xs) {
+        return Queries.generators.bondedAtomicPairs(xs && xs[0])(ctx)
+    }),
+    D(MolScript.structureQuery.generator.rings, function structureQuery_generator_rings(ctx, xs) {
+        return Queries.generators.rings(xs?.['fingerprint']?.(ctx) as any, xs?.['only-aromatic']?.(ctx))(ctx)
+    }),
 
     // ============= MODIFIERS ================
 
-    D(MolScript.structureQuery.modifier.includeSurroundings, function structureQuery_modifier_includeSurroundings(ctx, xs) { return Queries.modifiers.includeSurroundings(xs[0] as any, {
-        radius: xs['radius'](ctx),
-        wholeResidues: !!(xs['as-whole-residues'] && xs['as-whole-residues'](ctx)),
-        elementRadius: xs['atom-radius']
-    })(ctx) }),
+    D(MolScript.structureQuery.modifier.includeSurroundings, function structureQuery_modifier_includeSurroundings(ctx, xs) {
+        return Queries.modifiers.includeSurroundings(xs[0] as any, {
+            radius: xs['radius'](ctx),
+            wholeResidues: !!(xs['as-whole-residues'] && xs['as-whole-residues'](ctx)),
+            elementRadius: xs['atom-radius']
+        })(ctx)
+    }),
     D(MolScript.structureQuery.modifier.wholeResidues, function structureQuery_modifier_wholeResidues(ctx, xs) { return Queries.modifiers.wholeResidues(xs[0] as any)(ctx) }),
     D(MolScript.structureQuery.modifier.union, function structureQuery_modifier_union(ctx, xs) { return Queries.modifiers.union(xs[0] as any)(ctx) }),
     D(MolScript.structureQuery.modifier.expandProperty, function structureQuery_modifier_expandProperty(ctx, xs) { return Queries.modifiers.expandProperty(xs[0] as any, xs['property'])(ctx) }),
     D(MolScript.structureQuery.modifier.exceptBy, function structureQuery_modifier_exceptBy(ctx, xs) { return Queries.modifiers.exceptBy(xs[0] as any, xs['by'] as any)(ctx) }),
-    D(MolScript.structureQuery.modifier.includeConnected, function structureQuery_modifier_includeConnected(ctx, xs) { return Queries.modifiers.includeConnected({
-        query: xs[0] as any,
-        bondTest: xs['bond-test'],
-        wholeResidues: !!(xs['as-whole-residues'] && xs['as-whole-residues'](ctx)),
-        layerCount: (xs['layer-count'] && xs['layer-count'](ctx)) || 1
-    })(ctx) }),
+    D(MolScript.structureQuery.modifier.includeConnected, function structureQuery_modifier_includeConnected(ctx, xs) {
+        return Queries.modifiers.includeConnected({
+            query: xs[0] as any,
+            bondTest: xs['bond-test'],
+            wholeResidues: !!(xs['as-whole-residues'] && xs['as-whole-residues'](ctx)),
+            layerCount: (xs['layer-count'] && xs['layer-count'](ctx)) || 1
+        })(ctx)
+    }),
 
     // ============= COMBINATORS ================
 

src/mol-util/make-dir.ts

@@ -12,8 +12,9 @@ export function makeDir(path: string, root?: string): boolean {
 
     root = (root || '') + dir + '/';
 
-    try { fs.mkdirSync(root); }
-    catch (e) {
+    try {
+        fs.mkdirSync(root);
+    } catch (e) {
         if (!fs.statSync(root).isDirectory()) throw new Error(e);
     }
 

src/mol-util/param-mapping.ts

@@ -23,8 +23,7 @@ export function ParamMapping<S, T, Ctx>(def: {
         values(t: T, ctx: Ctx): S,
         update(s: S, t: Mutable<T>, ctx: Ctx): void,
         apply?(t: T, ctx: Ctx): void | Promise<void>
-    }) => ParamMapping<S, T, Ctx>
-{
+    }) => ParamMapping<S, T, Ctx> {
     return ({ values, update, apply }) => ({
         params: typeof def.params === 'function' ? def.params as any : ctx => def.params,
         getTarget: def.target,

src/mol-util/zip/bin.ts

@@ -91,11 +91,17 @@ export function sizeUTF8(str: string) {
     let i = 0;
     for(let ci = 0; ci < strl; ci++) {
         const code = str.charCodeAt(ci);
-        if     ((code&(0xffffffff-(1<< 7)+1)) === 0) {  i++ ;  }
-        else if((code&(0xffffffff-(1<<11)+1)) === 0) {  i+=2;  }
-        else if((code&(0xffffffff-(1<<16)+1)) === 0) {  i+=3;  }
-        else if((code&(0xffffffff-(1<<21)+1)) === 0) {  i+=4;  }
-        else throw 'e';
+        if ((code&(0xffffffff-(1<< 7)+1)) === 0) {
+            i++ ;
+        } else if((code&(0xffffffff-(1<<11)+1)) === 0) {
+            i+=2;
+        } else if((code&(0xffffffff-(1<<16)+1)) === 0) {
+            i+=3;
+        } else if((code&(0xffffffff-(1<<21)+1)) === 0) {
+            i+=4;
+        } else {
+            throw 'e';
+        }
     }
     return i;
 }

src/mol-util/zip/deflate.ts

@@ -96,8 +96,9 @@ export function _deflateRaw(data: Uint8Array, out: Uint8Array, opos: number, lvl
                 const dgi = _goodIndex(dst, U.df0);  U.dhst[    dgi]++;  ebits += U.exb[lgi] + U.dxb[dgi];
                 lits[li] = (len<<23)|(i-cvrd);  lits[li+1] = (dst<<16)|(lgi<<8)|dgi;  li+=2;
                 cvrd = i + len;
+            } else {
+                U.lhst[data[i]]++;
             }
-            else {	U.lhst[data[i]]++;  }
             lc++;
         }
     }
@@ -302,8 +303,9 @@ function _lenCodes(tree: number[], set: number[]) {
             const zc = Math.min((lz+1-i)>>>1, 6);
             set.push(16, zc-3);
             i += zc*2-2;
+        } else {
+            set.push(l, 0);
         }
-        else set.push(l, 0);
     }
     return len>>>1;
 }

src/mol-util/zip/zip.ts

@@ -105,8 +105,9 @@ async function _readLocal(runtime: RuntimeContext, data: Uint8Array, o: number,
         const buf = new Uint8Array(usize);
         await inflateRaw(runtime, file, buf);
         out[name] = buf;
+    } else {
+        throw `unknown compression method: ${cmpr}`;
     }
-    else throw `unknown compression method: ${cmpr}`;
 }
 
 export async function inflateRaw(runtime: RuntimeContext, file: Uint8Array, buf?: Uint8Array) {

src/servers/volume/common/file.ts

@@ -34,8 +34,9 @@ function makeDir(path: string, root?: string): boolean {
 
     root = (root || '') + dir + '/';
 
-    try { fs.mkdirSync(root); }
-    catch (e) {
+    try {
+        fs.mkdirSync(root);
+    } catch (e) {
         if (!fs.statSync(root).isDirectory()) throw new Error(e);
     }
 

src/servers/volume/server/local-api.ts

@@ -104,8 +104,9 @@ function makeDir(path: string, root?: string): boolean {
 
     root = (root || '') + dir + '/';
 
-    try { fs.mkdirSync(root); }
-    catch (e) {
+    try {
+        fs.mkdirSync(root);
+    } catch (e) {
         if (!fs.statSync(root).isDirectory()) throw new Error(e);
     }