fixed some cyclical references & drawcall in mol-canvas3d

src/examples/domain-annotation-server/server.ts

@@ -4,7 +4,7 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import * as express from 'express'
+import express from 'express'
 import fetch from 'node-fetch'
 import createMapping from './mapping'
 

src/mol-canvas3d/canvas3d.ts

@@ -197,11 +197,6 @@ namespace Canvas3D {
         const postprocessing = new PostprocessingPass(webgl, camera, drawPass, p.postprocessing)
         const multiSample = new MultiSamplePass(webgl, camera, drawPass, postprocessing, p.multiSample)
 
-        const contextRestoredSub = contextRestored.subscribe(() => {
-            pickPass.pickDirty = true
-            draw(true)
-        })
-
         let drawPending = false
         let cameraResetRequested = false
         let nextCameraResetDuration: number | undefined = void 0
@@ -439,6 +434,11 @@ namespace Canvas3D {
 
         handleResize()
 
+        const contextRestoredSub = contextRestored.subscribe(() => {
+            pickPass.pickDirty = true
+            draw(true)
+        })
+
         return {
             webgl,
 

src/mol-model-props/computed/representations/interactions.ts

@@ -8,11 +8,12 @@ import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { Representation, RepresentationParamsGetter, RepresentationContext } from '../../../mol-repr/representation';
 import { ThemeRegistryContext } from '../../../mol-theme/theme';
 import { Structure } from '../../../mol-model/structure';
-import { UnitsRepresentation, StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationProvider, ComplexRepresentation, getUnitKindsParam } from '../../../mol-repr/structure/representation';
+import { UnitsRepresentation, StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationProvider, ComplexRepresentation } from '../../../mol-repr/structure/representation';
 import { InteractionsIntraUnitParams, InteractionsIntraUnitVisual } from './interactions-intra-unit-cylinder';
 import { InteractionsProvider } from '../interactions';
 import { InteractionsInterUnitParams, InteractionsInterUnitVisual } from './interactions-inter-unit-cylinder';
 import { CustomProperty } from '../../common/custom-property';
+import { getUnitKindsParam } from '../../../mol-repr/structure/params';
 
 const InteractionsVisuals = {
     'intra-unit': (ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, InteractionsIntraUnitParams>) => UnitsRepresentation('Intra-unit interactions cylinder', ctx, getParams, InteractionsIntraUnitVisual),

src/mol-model-props/rcsb/representations/validation-report-clashes.ts

@@ -13,7 +13,7 @@ import { PickingId } from '../../../mol-geo/geometry/picking';
 import { EmptyLoci, Loci, DataLoci } from '../../../mol-model/loci';
 import { Interval } from '../../../mol-data/int';
 import { RepresentationContext, RepresentationParamsGetter, Representation } from '../../../mol-repr/representation';
-import { UnitsRepresentation, StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationProvider, ComplexRepresentation, getUnitKindsParam } from '../../../mol-repr/structure/representation';
+import { UnitsRepresentation, StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationProvider, ComplexRepresentation } from '../../../mol-repr/structure/representation';
 import { VisualContext } from '../../../mol-repr/visual';
 import { createLinkCylinderMesh, LinkCylinderParams, LinkCylinderStyle } from '../../../mol-repr/structure/visual/util/link';
 import { UnitsMeshParams, UnitsVisual, UnitsMeshVisual, StructureGroup } from '../../../mol-repr/structure/units-visual';
@@ -27,6 +27,7 @@ import { MarkerActions } from '../../../mol-util/marker-action';
 import { CentroidHelper } from '../../../mol-math/geometry/centroid-helper';
 import { Sphere3D } from '../../../mol-math/geometry';
 import { bondLabel } from '../../../mol-theme/label';
+import { getUnitKindsParam } from '../../../mol-repr/structure/params';
 
 //
 

src/mol-repr/structure/complex-representation.ts

@@ -6,7 +6,7 @@
  */
 
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
-import { ComplexVisual, StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationState, StructureParams } from './representation';
+import { ComplexVisual, StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationState } from './representation';
 import { RepresentationContext, RepresentationParamsGetter } from '../representation';
 import { Structure, StructureElement, Bond } from '../../mol-model/structure';
 import { Subject } from 'rxjs';
@@ -17,6 +17,7 @@ import { PickingId } from '../../mol-geo/geometry/picking';
 import { EmptyLoci, Loci, isEveryLoci, isDataLoci } from '../../mol-model/loci';
 import { MarkerAction, MarkerActions } from '../../mol-util/marker-action';
 import { Overpaint } from '../../mol-theme/overpaint';
+import { StructureParams } from './params';
 
 export function ComplexRepresentation<P extends StructureParams>(label: string, ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, P>, visualCtor: (materialId: number) => ComplexVisual<P>): StructureRepresentation<P> {
     let version = 0

src/mol-repr/structure/complex-visual.ts

@@ -5,7 +5,6 @@
  */
 
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
-import { StructureMeshParams, StructureDirectVolumeParams, StructureTextParams, StructureParams } from './representation';
 import { Visual, VisualContext } from '../visual';
 import { Structure, StructureElement } from '../../mol-model/structure';
 import { Geometry, GeometryUtils } from '../../mol-geo/geometry/geometry';
@@ -30,6 +29,7 @@ import { Text } from '../../mol-geo/geometry/text/text';
 import { SizeTheme } from '../../mol-theme/size';
 import { DirectVolume } from '../../mol-geo/geometry/direct-volume/direct-volume';
 import { createMarkers } from '../../mol-geo/geometry/marker-data';
+import { StructureParams, StructureMeshParams, StructureTextParams, StructureDirectVolumeParams } from './params';
 
 export interface  ComplexVisual<P extends StructureParams> extends Visual<Structure, P> { }
 

src/mol-repr/structure/params.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2018-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { DirectVolume } from '../../mol-geo/geometry/direct-volume/direct-volume';
+import { Lines } from '../../mol-geo/geometry/lines/lines';
+import { Mesh } from '../../mol-geo/geometry/mesh/mesh';
+import { Points } from '../../mol-geo/geometry/points/points';
+import { Spheres } from '../../mol-geo/geometry/spheres/spheres';
+import { Text } from '../../mol-geo/geometry/text/text';
+import { TextureMesh } from '../../mol-geo/geometry/texture-mesh/texture-mesh';
+import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { UnitKind, UnitKindOptions } from './visual/util/common';
+
+export function getUnitKindsParam(defaultValue: UnitKind[]) {
+    return PD.MultiSelect<UnitKind>(defaultValue, UnitKindOptions, { description: 'For which kinds of units/chains to show the representation visuals.' })
+}
+
+export const StructureParams = {
+    unitKinds: getUnitKindsParam(['atomic', 'spheres']),
+}
+export type StructureParams = typeof StructureParams
+
+export const StructureMeshParams = { ...Mesh.Params }
+export type StructureMeshParams = typeof StructureMeshParams
+
+export const StructureSpheresParams = { ...Spheres.Params }
+export type StructureSpheresParams = typeof StructureSpheresParams
+
+export const StructurePointsParams = { ...Points.Params }
+export type StructurePointsParams = typeof StructurePointsParams
+
+
+export const StructureLinesParams = { ...Lines.Params }
+export type StructureLinesParams = typeof StructureLinesParams
+
+export const StructureTextParams = { ...Text.Params }
+export type StructureTextParams = typeof StructureTextParams
+
+export const StructureDirectVolumeParams = { ...DirectVolume.Params }
+export type StructureDirectVolumeParams = typeof StructureDirectVolumeParams
+
+export const StructureTextureMeshParams = { ...TextureMesh.Params }
+export type StructureTextureMeshParams = typeof StructureTextureMeshParams

src/mol-repr/structure/representation.ts

@@ -5,27 +5,10 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import { DirectVolume } from '../../mol-geo/geometry/direct-volume/direct-volume';
-import { Lines } from '../../mol-geo/geometry/lines/lines';
-import { Mesh } from '../../mol-geo/geometry/mesh/mesh';
-import { Points } from '../../mol-geo/geometry/points/points';
-import { Spheres } from '../../mol-geo/geometry/spheres/spheres';
-import { Text } from '../../mol-geo/geometry/text/text';
-import { TextureMesh } from '../../mol-geo/geometry/texture-mesh/texture-mesh';
 import { Structure } from '../../mol-model/structure';
 import { StructureUnitTransforms } from '../../mol-model/structure/structure/util/unit-transforms';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { Representation, RepresentationProps, RepresentationProvider } from '../representation';
-import { UnitKind, UnitKindOptions } from './visual/util/common';
-
-export function getUnitKindsParam(defaultValue: UnitKind[]) {
-    return PD.MultiSelect<UnitKind>(defaultValue, UnitKindOptions, { description: 'For which kinds of units/chains to show the representation visuals.' })
-}
-
-export const StructureParams = {
-    unitKinds: getUnitKindsParam(['atomic', 'spheres']),
-}
-export type StructureParams = typeof StructureParams
 
 export interface StructureRepresentationState extends Representation.State {
     unitTransforms: StructureUnitTransforms | null,
@@ -50,29 +33,8 @@ export interface StructureRepresentation<P extends RepresentationProps = {}> ext
 export type StructureRepresentationProvider<P extends PD.Params, Id extends string = string> = RepresentationProvider<Structure, P, StructureRepresentationState, Id>
 export function StructureRepresentationProvider<P extends PD.Params, Id extends string>(p: StructureRepresentationProvider<P, Id>): StructureRepresentationProvider<P, Id> { return p; }
 //
-
-export const StructureMeshParams = { ...Mesh.Params }
-export type StructureMeshParams = typeof StructureMeshParams
-
-export const StructureSpheresParams = { ...Spheres.Params }
-export type StructureSpheresParams = typeof StructureSpheresParams
-
-export const StructurePointsParams = { ...Points.Params }
-export type StructurePointsParams = typeof StructurePointsParams
-
-export const StructureLinesParams = { ...Lines.Params }
-export type StructureLinesParams = typeof StructureLinesParams
-
-export const StructureTextParams = { ...Text.Params }
-export type StructureTextParams = typeof StructureTextParams
-
-export const StructureDirectVolumeParams = { ...DirectVolume.Params }
-export type StructureDirectVolumeParams = typeof StructureDirectVolumeParams
-
-export const StructureTextureMeshParams = { ...TextureMesh.Params }
-export type StructureTextureMeshParams = typeof StructureTextureMeshParams
-
 export { ComplexRepresentation } from './complex-representation';
 export { ComplexVisual } from './complex-visual';
 export { UnitsRepresentation } from './units-representation';
 export { UnitsVisual } from './units-visual';
+

src/mol-repr/structure/representation/ball-and-stick.ts

@@ -10,10 +10,11 @@ import { InterUnitBondVisual, InterUnitBondParams } from '../visual/bond-inter-u
 import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { UnitsRepresentation } from '../units-representation';
 import { ComplexRepresentation } from '../complex-representation';
-import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder, getUnitKindsParam } from '../representation';
+import { StructureRepresentation, StructureRepresentationProvider, StructureRepresentationStateBuilder } from '../representation';
 import { Representation, RepresentationParamsGetter, RepresentationContext } from '../../../mol-repr/representation';
 import { ThemeRegistryContext } from '../../../mol-theme/theme';
 import { Structure } from '../../../mol-model/structure';
+import { getUnitKindsParam } from '../params';
 
 const BallAndStickVisuals = {
     'element-sphere': (ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, ElementSphereParams>) => UnitsRepresentation('Element sphere mesh', ctx, getParams, getElementSphereVisual(ctx.webgl)),

src/mol-repr/structure/representation/cartoon.ts

@@ -35,6 +35,7 @@ export const CartoonParams = {
     sizeFactor: PD.Numeric(0.2, { min: 0, max: 10, step: 0.01 }),
     visuals: PD.MultiSelect(['polymer-trace', 'polymer-gap', 'nucleotide-block'], PD.objectToOptions(CartoonVisuals)),
 }
+
 export type CartoonParams = typeof CartoonParams
 export function getCartoonParams(ctx: ThemeRegistryContext, structure: Structure) {
     const params = PD.clone(CartoonParams)

src/mol-repr/structure/representation/ellipsoid.ts

@@ -8,11 +8,12 @@ import { ParamDefinition as PD } from '../../../mol-util/param-definition';
 import { RepresentationParamsGetter, RepresentationContext, Representation } from '../../../mol-repr/representation';
 import { ThemeRegistryContext } from '../../../mol-theme/theme';
 import { Structure } from '../../../mol-model/structure';
-import { UnitsRepresentation, StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationProvider, ComplexRepresentation, getUnitKindsParam } from '../../../mol-repr/structure/representation';
+import { UnitsRepresentation, StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationProvider, ComplexRepresentation } from '../../../mol-repr/structure/representation';
 import { EllipsoidMeshParams, EllipsoidMeshVisual } from '../visual/ellipsoid-mesh';
 import { AtomSiteAnisotrop } from '../../../mol-model-formats/structure/property/anisotropic';
 import { IntraUnitBondParams, IntraUnitBondVisual } from '../visual/bond-intra-unit-cylinder';
 import { InterUnitBondParams, InterUnitBondVisual } from '../visual/bond-inter-unit-cylinder';
+import { getUnitKindsParam } from '../params';
 
 const EllipsoidVisuals = {
     'ellipsoid-mesh': (ctx: RepresentationContext, getParams: RepresentationParamsGetter<Structure, EllipsoidMeshParams>) => UnitsRepresentation('Ellipsoid Mesh', ctx, getParams, EllipsoidMeshVisual),

src/mol-repr/structure/units-representation.ts

@@ -6,7 +6,7 @@
  */
 
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
-import { StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationState, StructureParams } from './representation';
+import { StructureRepresentation, StructureRepresentationStateBuilder, StructureRepresentationState } from './representation';
 import { Visual } from '../visual';
 import { StructureGroup } from './units-visual';
 import { RepresentationContext, RepresentationParamsGetter } from '../representation';
@@ -22,6 +22,7 @@ import { Overpaint } from '../../mol-theme/overpaint';
 import { Transparency } from '../../mol-theme/transparency';
 import { Mat4, EPSILON } from '../../mol-math/linear-algebra';
 import { Interval } from '../../mol-data/int';
+import { StructureParams } from './params';
 
 export interface UnitsVisual<P extends StructureParams> extends Visual<StructureGroup, P> { }
 

src/mol-repr/structure/units-visual.ts

@@ -26,7 +26,6 @@ import { createColors } from '../../mol-geo/geometry/color-data';
 import { Mat4 } from '../../mol-math/linear-algebra';
 import { Overpaint } from '../../mol-theme/overpaint';
 import { Transparency } from '../../mol-theme/transparency';
-import { StructureMeshParams, StructureSpheresParams, StructurePointsParams, StructureLinesParams, StructureDirectVolumeParams, StructureTextureMeshParams, StructureTextParams, StructureParams } from './representation';
 import { Mesh } from '../../mol-geo/geometry/mesh/mesh';
 import { SizeTheme } from '../../mol-theme/size';
 import { Spheres } from '../../mol-geo/geometry/spheres/spheres';
@@ -36,6 +35,7 @@ import { Text } from '../../mol-geo/geometry/text/text';
 import { DirectVolume } from '../../mol-geo/geometry/direct-volume/direct-volume';
 import { TextureMesh } from '../../mol-geo/geometry/texture-mesh/texture-mesh';
 import { SizeValues } from '../../mol-gl/renderable/schema';
+import { StructureParams, StructureMeshParams, StructureSpheresParams, StructurePointsParams, StructureLinesParams, StructureTextParams, StructureDirectVolumeParams, StructureTextureMeshParams } from './params';
 
 export type StructureGroup = { structure: Structure, group: Unit.SymmetryGroup }
 

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

@@ -0,0 +1,173 @@
+/**
+ * Copyright (c) 2018 Mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import Expression from '../../language/expression';
+import { QueryContext, QueryFn, Structure, CustomPropertyDescriptor } from '../../../mol-model/structure';
+import { MSymbol } from '../../language/symbol';
+
+export class QueryRuntimeTable {
+    private map = new Map<string, QuerySymbolRuntime>();
+
+    addSymbol(runtime: QuerySymbolRuntime) {
+        if (this.map.has(runtime.symbol.id)) {
+            throw new Error(`Symbol '${runtime.symbol.id}' already added.`);
+        }
+        this.map.set(runtime.symbol.id, runtime);
+    }
+
+    addCustomProp(desc: CustomPropertyDescriptor<any>) {
+        if (!desc.symbols) return;
+
+        for (const k of Object.keys(desc.symbols)) {
+            this.addSymbol((desc.symbols as any)[k]);
+        }
+    }
+
+    getRuntime(id: string) {
+        return this.map.get(id);
+    }
+}
+
+export const DefaultQueryRuntimeTable = new QueryRuntimeTable();
+
+export class QueryCompilerCtx {
+    constQueryContext: QueryContext = new QueryContext(Structure.Empty);
+
+    constructor(public table: QueryRuntimeTable) {
+
+    }
+}
+
+export type ConstQuerySymbolFn<S extends MSymbol = MSymbol> = (ctx: QueryContext, args: QueryRuntimeArguments<S>) => any
+export type QuerySymbolFn<S extends MSymbol = MSymbol> = (ctx: QueryContext, args: QueryRuntimeArguments<S>) => any
+
+
+export type QueryCompiledSymbolRuntime = { kind: 'const', value: any } | { kind: 'dynamic', runtime: QuerySymbolFn }
+
+export type CompiledQueryFn<T = any> = { isConst: boolean, fn: QueryFn }
+
+export namespace QueryCompiledSymbol {
+    export function Const(value: any): QueryCompiledSymbolRuntime  {
+        return { kind: 'const', value }
+    }
+
+    export function Dynamic(runtime: QuerySymbolFn): QueryCompiledSymbolRuntime {
+        return { kind: 'dynamic', runtime };
+    }
+}
+
+export namespace CompiledQueryFn {
+    export function Const(value: any): CompiledQueryFn  {
+        return { isConst: true, fn: function CompiledQueryFn_Const(ctx) { return value } };
+    }
+
+    export function Dynamic(fn: QueryFn): CompiledQueryFn {
+        return { isConst: false, fn };
+    }
+}
+
+export interface QuerySymbolRuntime {
+    symbol: MSymbol,
+    compile(ctx: QueryCompilerCtx, args?: Expression.Arguments): CompiledQueryFn
+}
+
+export type QueryRuntimeArguments<S extends MSymbol> =
+    { length?: number } & { [P in keyof S['args']['@type']]: QueryFn<S['args']['@type'][P]> }
+
+export namespace QueryRuntimeArguments {
+    export function forEachEval<S extends MSymbol, Ctx>(xs: QueryRuntimeArguments<S>, queryCtx: QueryContext, f: (arg: any, i: number, ctx: Ctx) => void, ctx: Ctx): Ctx {
+        if (typeof xs.length === 'number') {
+            for (let i = 0, _i = xs.length; i < _i; i++) f((xs as any)[i](queryCtx), i, ctx);
+        } else {
+            let i = 0;
+            for (const k of Object.keys(xs)) f((xs as any)[k](queryCtx), i++, ctx);
+        }
+        return ctx;
+    }
+}
+
+export namespace QuerySymbolRuntime {
+    export function Const<S extends MSymbol<any>>(symbol: S, fn: ConstQuerySymbolFn<S>): QuerySymbolRuntime {
+        return new SymbolRuntimeImpl(symbol, fn, true);
+    }
+
+    export function Dynamic<S extends MSymbol<any>>(symbol: S, fn: QuerySymbolFn<S>): QuerySymbolRuntime {
+        return new SymbolRuntimeImpl(symbol, fn, false);
+    }
+}
+
+class SymbolRuntimeImpl<S extends MSymbol> implements QuerySymbolRuntime {
+    compile(ctx: QueryCompilerCtx, inputArgs?: Expression.Arguments): CompiledQueryFn {
+        let args: any, constArgs = false;
+        if (!inputArgs) {
+            args = void 0;
+            constArgs = true;
+        } else if (Expression.isArgumentsArray(inputArgs)) {
+            args = [];
+            constArgs = false;
+            for (const arg of inputArgs) {
+                const compiled = _compile(ctx, arg);
+                constArgs = constArgs && compiled.isConst;
+                args.push(compiled.fn);
+            }
+        } else {
+            args = Object.create(null);
+            constArgs = false;
+            for (const key of Object.keys(inputArgs)) {
+                const compiled = _compile(ctx, inputArgs[key]);
+                constArgs = constArgs && compiled.isConst;
+                args[key] = compiled.fn;
+            }
+        }
+
+        if (this.isConst) {
+            if (this.isConst && constArgs) {
+                return CompiledQueryFn.Const(this.fn(ctx.constQueryContext, args))
+            }
+
+            return CompiledQueryFn.Dynamic(createDynamicFn(this.fn, args));
+        }
+
+        return CompiledQueryFn.Dynamic(createDynamicFn(this.fn, args));
+    }
+
+    constructor(public symbol: S, private fn: QuerySymbolFn<S>, private isConst: boolean) {
+
+    }
+}
+
+function createDynamicFn<S extends MSymbol>(fn: QuerySymbolFn<S>, args: any): QueryFn {
+    return function DynamicFn(ctx) { return fn(ctx, args) };
+}
+
+function _compile(ctx: QueryCompilerCtx, expression: Expression): CompiledQueryFn {
+    if (Expression.isLiteral(expression)) {
+        return CompiledQueryFn.Const(expression);
+    }
+
+    if (Expression.isSymbol(expression)) {
+        const runtime = ctx.table.getRuntime(expression.name);
+        if (!runtime) return CompiledQueryFn.Const(expression.name);
+
+        return runtime.compile(ctx);
+    }
+
+    if (!Expression.isSymbol(expression.head)) {
+        throw new Error('Can only apply symbols.');
+    }
+
+    const compiler = ctx.table.getRuntime(expression.head.name);
+    if (!compiler) {
+        throw new Error(`Symbol '${expression.head.name}' is not implemented.`);
+    }
+
+    return compiler.compile(ctx, expression.args);
+}
+
+export function compile<T = any>(expression: Expression): QueryFn<T> {
+    const ctx = new QueryCompilerCtx(DefaultQueryRuntimeTable);
+    return _compile(ctx, expression).fn;
+}

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

@@ -4,172 +4,5 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import Expression from '../../language/expression';
-import { QueryContext, QueryFn, Structure, CustomPropertyDescriptor } from '../../../mol-model/structure';
-import { MSymbol } from '../../language/symbol';
-
-export class QueryRuntimeTable {
-    private map = new Map<string, QuerySymbolRuntime>();
-
-    addSymbol(runtime: QuerySymbolRuntime) {
-        if (this.map.has(runtime.symbol.id)) {
-            throw new Error(`Symbol '${runtime.symbol.id}' already added.`);
-        }
-        this.map.set(runtime.symbol.id, runtime);
-    }
-
-    addCustomProp(desc: CustomPropertyDescriptor<any>) {
-        if (!desc.symbols) return;
-
-        for (const k of Object.keys(desc.symbols)) {
-            this.addSymbol((desc.symbols as any)[k]);
-        }
-    }
-
-    getRuntime(id: string) {
-        return this.map.get(id);
-    }
-}
-
-export const DefaultQueryRuntimeTable = new QueryRuntimeTable();
-
-export class QueryCompilerCtx {
-    constQueryContext: QueryContext = new QueryContext(Structure.Empty);
-
-    constructor(public table: QueryRuntimeTable) {
-
-    }
-}
-
-export type ConstQuerySymbolFn<S extends MSymbol = MSymbol> = (ctx: QueryContext, args: QueryRuntimeArguments<S>) => any
-export type QuerySymbolFn<S extends MSymbol = MSymbol> = (ctx: QueryContext, args: QueryRuntimeArguments<S>) => any
-
-
-export type QueryCompiledSymbolRuntime = { kind: 'const', value: any } | { kind: 'dynamic', runtime: QuerySymbolFn }
-
-export type CompiledQueryFn<T = any> = { isConst: boolean, fn: QueryFn }
-
-export namespace QueryCompiledSymbol {
-    export function Const(value: any): QueryCompiledSymbolRuntime  {
-        return { kind: 'const', value }
-    }
-
-    export function Dynamic(runtime: QuerySymbolFn): QueryCompiledSymbolRuntime {
-        return { kind: 'dynamic', runtime };
-    }
-}
-
-export namespace CompiledQueryFn {
-    export function Const(value: any): CompiledQueryFn  {
-        return { isConst: true, fn: function CompiledQueryFn_Const(ctx) { return value } };
-    }
-
-    export function Dynamic(fn: QueryFn): CompiledQueryFn {
-        return { isConst: false, fn };
-    }
-}
-
-export interface QuerySymbolRuntime {
-    symbol: MSymbol,
-    compile(ctx: QueryCompilerCtx, args?: Expression.Arguments): CompiledQueryFn
-}
-
-export type QueryRuntimeArguments<S extends MSymbol> =
-    { length?: number } & { [P in keyof S['args']['@type']]: QueryFn<S['args']['@type'][P]> }
-
-export namespace QueryRuntimeArguments {
-    export function forEachEval<S extends MSymbol, Ctx>(xs: QueryRuntimeArguments<S>, queryCtx: QueryContext, f: (arg: any, i: number, ctx: Ctx) => void, ctx: Ctx): Ctx {
-        if (typeof xs.length === 'number') {
-            for (let i = 0, _i = xs.length; i < _i; i++) f((xs as any)[i](queryCtx), i, ctx);
-        } else {
-            let i = 0;
-            for (const k of Object.keys(xs)) f((xs as any)[k](queryCtx), i++, ctx);
-        }
-        return ctx;
-    }
-}
-
-export namespace QuerySymbolRuntime {
-    export function Const<S extends MSymbol<any>>(symbol: S, fn: ConstQuerySymbolFn<S>): QuerySymbolRuntime {
-        return new SymbolRuntimeImpl(symbol, fn, true);
-    }
-
-    export function Dynamic<S extends MSymbol<any>>(symbol: S, fn: QuerySymbolFn<S>): QuerySymbolRuntime {
-        return new SymbolRuntimeImpl(symbol, fn, false);
-    }
-}
-
-class SymbolRuntimeImpl<S extends MSymbol> implements QuerySymbolRuntime {
-    compile(ctx: QueryCompilerCtx, inputArgs?: Expression.Arguments): CompiledQueryFn {
-        let args: any, constArgs = false;
-        if (!inputArgs) {
-            args = void 0;
-            constArgs = true;
-        } else if (Expression.isArgumentsArray(inputArgs)) {
-            args = [];
-            constArgs = false;
-            for (const arg of inputArgs) {
-                const compiled = _compile(ctx, arg);
-                constArgs = constArgs && compiled.isConst;
-                args.push(compiled.fn);
-            }
-        } else {
-            args = Object.create(null);
-            constArgs = false;
-            for (const key of Object.keys(inputArgs)) {
-                const compiled = _compile(ctx, inputArgs[key]);
-                constArgs = constArgs && compiled.isConst;
-                args[key] = compiled.fn;
-            }
-        }
-
-        if (this.isConst) {
-            if (this.isConst && constArgs) {
-                return CompiledQueryFn.Const(this.fn(ctx.constQueryContext, args))
-            }
-
-            return CompiledQueryFn.Dynamic(createDynamicFn(this.fn, args));
-        }
-
-        return CompiledQueryFn.Dynamic(createDynamicFn(this.fn, args));
-    }
-
-    constructor(public symbol: S, private fn: QuerySymbolFn<S>, private isConst: boolean) {
-
-    }
-}
-
-function createDynamicFn<S extends MSymbol>(fn: QuerySymbolFn<S>, args: any): QueryFn {
-    return function DynamicFn(ctx) { return fn(ctx, args) };
-}
-
-function _compile(ctx: QueryCompilerCtx, expression: Expression): CompiledQueryFn {
-    if (Expression.isLiteral(expression)) {
-        return CompiledQueryFn.Const(expression);
-    }
-
-    if (Expression.isSymbol(expression)) {
-        const runtime = ctx.table.getRuntime(expression.name);
-        if (!runtime) return CompiledQueryFn.Const(expression.name);
-
-        return runtime.compile(ctx);
-    }
-
-    if (!Expression.isSymbol(expression.head)) {
-        throw new Error('Can only apply symbols.');
-    }
-
-    const compiler = ctx.table.getRuntime(expression.head.name);
-    if (!compiler) {
-        throw new Error(`Symbol '${expression.head.name}' is not implemented.`);
-    }
-
-    return compiler.compile(ctx, expression.args);
-}
-
-export function compile<T = any>(expression: Expression): QueryFn<T> {
-    const ctx = new QueryCompilerCtx(DefaultQueryRuntimeTable);
-    return _compile(ctx, expression).fn;
-}
-
+export * from './base'
 import './table'

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

@@ -6,17 +6,18 @@
  */
 
 import { MolScriptSymbolTable as MolScript } from '../../language/symbol-table';
-import { DefaultQueryRuntimeTable, QuerySymbolRuntime, QueryRuntimeArguments } from './compiler';
+import { DefaultQueryRuntimeTable, QuerySymbolRuntime, QueryRuntimeArguments } from './base';
 import { Queries, StructureProperties, StructureElement, QueryContext, UnitRing } from '../../../mol-model/structure';
 import { ElementSymbol, BondType, SecondaryStructureType } from '../../../mol-model/structure/model/types';
 import { SetUtils } from '../../../mol-util/set';
 import { upperCaseAny } from '../../../mol-util/string';
 import { VdwRadius, AtomWeight, AtomNumber } from '../../../mol-model/structure/model/properties/atomic';
 import { cantorPairing } from '../../../mol-data/util';
-import C = QuerySymbolRuntime.Const
-import D = QuerySymbolRuntime.Dynamic
 import { bundleElementImpl, bundleGenerator } from '../../../mol-model/structure/query/queries/internal';
 
+const C = QuerySymbolRuntime.Const
+const D = QuerySymbolRuntime.Dynamic
+
 const symbols = [
     // ============= TYPES =============
 

src/servers/model/server.ts

@@ -5,8 +5,8 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import * as compression from 'compression'
-import * as express from 'express'
+import compression from 'compression'
+import express from 'express'
 import { ConsoleLogger } from '../../mol-util/console-logger'
 import { PerformanceMonitor } from '../../mol-util/performance-monitor'
 import { configureServer, ModelServerConfig as ServerConfig } from './config'

src/servers/plugin-state/index.ts

@@ -4,9 +4,9 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-import * as express from 'express'
-import * as compression from 'compression'
-import * as cors from 'cors'
+import express from 'express'
+import compression from 'compression'
+import cors from 'cors'
 import * as bodyParser from 'body-parser'
 import * as fs from 'fs'
 import * as path from 'path'

src/servers/volume/server.ts

@@ -8,8 +8,8 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import * as compression from 'compression'
-import * as express from 'express'
+import compression from 'compression'
+import express from 'express'
 import { ConsoleLogger } from '../../mol-util/console-logger'
 import { configureServer, ServerConfig } from './config'
 import { State } from './server/state'

tsconfig.json

@@ -9,7 +9,9 @@
         "noUnusedLocals": true,
         "strictNullChecks": true,
         "strictFunctionTypes": true,
-        // "downlevelIteration": true,
+        "module": "commonjs",
+        "esModuleInterop": true,
+        "moduleResolution": "node",
         "importHelpers": true,
         "noEmitHelpers": true,
         "jsx": "react",