Merge branch 'master' into gl-lines

README.md

@@ -17,12 +17,14 @@ The core of Mol* currently consists of these modules:
 - `mol-math` Math related (loosely) algorithms and data structures.
 - `mol-io` Parsing library. Each format is parsed into an interface that corresponds to the data stored by it. Support for common coordinate, experimental/map, and annotation data formats.
 - `mol-model` Data structures and algorithms (such as querying) for representing molecular data (including coordinate, experimental/map, and annotation data).
-- `mol-model-props` Common "custom properties"
+- `mol-model-props` Common "custom properties".
 - `mol-script` A scriting language for creating representations/scenes and querying (includes the [MolQL query language](https://molql.github.io)).
 - `mol-geo` Creating molecular geometries.
-- `mol-gl` A wrapper around WebGL. Uses `mol-geo` to generate geometries.
+- `mol-gl` A lightweight wrapper around WebGL.
+- `mol-canvas3d` A low level 3d view component. Uses `mol-geo` to generate geometries.
+- `mol-state` State representation tree with state saving and automatic updates.
 - `mol-app` Components for builduing UIs.
-- `mol-view` A reference viewer implementation.
+- `mol-plugin` Allow to define modular Mol* plugin instances utilizing `mol-state` and `mol-view3d`.
 - `mol-util` Useful things that do not fit elsewhere.
 
 Moreover, the project contains the imlementation of `servers`, including

package.json

@@ -61,8 +61,9 @@
       "mol-script($|/.*)": "<rootDir>/src/mol-script$1",
       "mol-task($|/.*)": "<rootDir>/src/mol-task$1",
       "mol-state($|/.*)": "<rootDir>/src/mol-state$1",
+      "mol-plugin($|/.*)": "<rootDir>/src/mol-plugin$1",
       "mol-util($|/.*)": "<rootDir>/src/mol-util$1",
-      "mol-view($|/.*)": "<rootDir>/src/mol-view$1"
+      "mol-canvas3d($|/.*)": "<rootDir>/src/mol-canvas3d$1"
     },
     "testRegex": "\\.spec\\.ts$"
   },

src/apps/canvas/app.ts

@@ -4,7 +4,7 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import Viewer from 'mol-view/viewer';
+import Viewer from 'mol-canvas3d/viewer';
 import { getCifFromUrl, getModelsFromMmcif, getCifFromFile, getCcp4FromUrl, getVolumeFromCcp4, getCcp4FromFile, getVolumeFromVolcif } from './util';
 import { StructureView } from './structure-view';
 import { BehaviorSubject } from 'rxjs';

src/apps/canvas/assembly-symmetry.ts

@@ -12,7 +12,7 @@ import { Tensor } from 'mol-math/linear-algebra';
 import { addSphere } from 'mol-geo/geometry/mesh/builder/sphere';
 import { addCylinder } from 'mol-geo/geometry/mesh/builder/cylinder';
 import { Shape } from 'mol-model/shape';
-import { ColorTheme } from 'mol-view/theme/color';
+import { ColorTheme } from 'mol-canvas3d/theme/color';
 import { Location } from 'mol-model/location';
 import { StructureElement, Unit, StructureProperties } from 'mol-model/structure';
 

src/apps/canvas/component/representation.tsx

@@ -5,13 +5,13 @@
  */
 
 import * as React from 'react'
-import Viewer from 'mol-view/viewer';
+import Viewer from 'mol-canvas3d/viewer';
 import { App } from '../app';
-import { Params } from 'mol-view/parameter';
+import { Params } from 'mol-util/parameter';
 import { Representation } from 'mol-geo/representation';
 import { ParametersComponent } from 'mol-app/component/parameters';
 import { Progress } from 'mol-task';
-import { ColorTheme } from 'mol-view/theme/color';
+import { ColorTheme } from 'mol-canvas3d/theme/color';
 import { getColorThemeProps } from 'mol-geo/geometry/color-data';
 import { ColorThemeComponent } from 'mol-app/component/color-theme';
 

src/apps/canvas/component/viewport.tsx

@@ -8,7 +8,7 @@ import * as React from 'react'
 import { App } from '../app';
 import { MarkerAction } from 'mol-geo/geometry/marker-data';
 import { EmptyLoci, Loci, areLociEqual } from 'mol-model/loci';
-import { labelFirst } from 'mol-view/label';
+import { labelFirst } from 'mol-canvas3d/label';
 
 interface ViewportProps {
     app: App

src/apps/canvas/structure-view.ts

@@ -11,7 +11,7 @@ import { getStructureFromModel } from './util';
 import { AssemblySymmetry } from 'mol-model-props/rcsb/symmetry';
 import { ShapeRepresentation, ShapeProps } from 'mol-geo/representation/shape';
 import { getAxesShape } from './assembly-symmetry';
-import Viewer from 'mol-view/viewer';
+import Viewer from 'mol-canvas3d/viewer';
 import { CarbohydrateRepresentation } from 'mol-geo/representation/structure/representation/carbohydrate';
 // import { MeshBuilder } from 'mol-geo/mesh/mesh-builder';
 // import { addSphere } from 'mol-geo/mesh/builder/sphere';

src/apps/canvas/volume-view.ts

@@ -4,7 +4,7 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
-import Viewer from 'mol-view/viewer';
+import Viewer from 'mol-canvas3d/viewer';
 import { BehaviorSubject } from 'rxjs';
 import { App } from './app';
 import { Progress } from 'mol-task';

src/mol-app/component/color-theme.tsx

@@ -5,7 +5,7 @@
  */
 
 import * as React from 'react'
-import { ColorTheme } from 'mol-view/theme/color';
+import { ColorTheme } from 'mol-canvas3d/theme/color';
 import { Color } from 'mol-util/color';
 
 export interface ColorThemeComponentProps {

src/mol-app/component/parameter/boolean.tsx

@@ -5,7 +5,7 @@
  */
 
 import * as React from 'react'
-import { BooleanParam } from 'mol-view/parameter';
+import { BooleanParam } from 'mol-util/parameter';
 
 export interface BooleanParamComponentProps {
     param: BooleanParam

src/mol-app/component/parameter/multi-select.tsx

@@ -5,7 +5,7 @@
  */
 
 import * as React from 'react'
-import { MultiSelectParam } from 'mol-view/parameter';
+import { MultiSelectParam } from 'mol-util/parameter';
 
 export interface MultiSelectParamComponentProps<T extends string> {
     param: MultiSelectParam<T>

src/mol-app/component/parameter/number.tsx

@@ -5,7 +5,7 @@
  */
 
 import * as React from 'react'
-import { NumberParam } from 'mol-view/parameter';
+import { NumberParam } from 'mol-util/parameter';
 
 export interface NumberParamComponentProps {
     param: NumberParam

src/mol-app/component/parameter/range.tsx

@@ -5,7 +5,7 @@
  */
 
 import * as React from 'react'
-import { RangeParam } from 'mol-view/parameter';
+import { RangeParam } from 'mol-util/parameter';
 
 export interface RangeParamComponentProps {
     param: RangeParam

src/mol-app/component/parameter/select.tsx

@@ -5,7 +5,7 @@
  */
 
 import * as React from 'react'
-import { SelectParam } from 'mol-view/parameter';
+import { SelectParam } from 'mol-util/parameter';
 
 export interface SelectParamComponentProps<T extends string> {
     param: SelectParam<T>

src/mol-app/component/parameter/text.tsx

@@ -5,7 +5,7 @@
  */
 
 import * as React from 'react'
-import { TextParam } from 'mol-view/parameter';
+import { TextParam } from 'mol-util/parameter';
 
 export interface TextParamComponentProps {
     param: TextParam

src/mol-app/component/parameters.tsx

@@ -5,7 +5,7 @@
  */
 
 import * as React from 'react'
-import { Param, Params } from 'mol-view/parameter';
+import { Param, Params } from 'mol-util/parameter';
 import { BooleanParamComponent } from './parameter/boolean';
 import { NumberParamComponent } from './parameter/number';
 import { RangeParamComponent } from './parameter/range';

src/mol-canvas3d/util.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+
+export function resizeCanvas (canvas: HTMLCanvasElement, container: Element) {
+    let w = window.innerWidth
+    let h = window.innerHeight
+    if (container !== document.body) {
+        let bounds = container.getBoundingClientRect()
+        w = bounds.right - bounds.left
+        h = bounds.bottom - bounds.top
+    }
+    canvas.width = window.devicePixelRatio * w
+    canvas.height = window.devicePixelRatio * h
+    Object.assign(canvas.style, { width: `${w}px`, height: `${h}px` })
+}

src/mol-geo/geometry/color-data.ts

@@ -10,7 +10,7 @@ import { Color } from 'mol-util/color';
 import { Vec2, Vec3 } from 'mol-math/linear-algebra';
 import { LocationIterator } from '../util/location-iterator';
 import { NullLocation } from 'mol-model/location';
-import { LocationColor, ColorThemeProps, ColorTheme, ColorThemeName } from 'mol-view/theme/color';
+import { LocationColor, ColorThemeProps, ColorTheme, ColorThemeName } from 'mol-canvas3d/theme/color';
 import { RuntimeContext } from 'mol-task';
 import { getGranularity } from './geometry';
 import { Structure } from 'mol-model/structure';

src/mol-geo/geometry/direct-volume/direct-volume.ts

@@ -7,7 +7,7 @@
 import { RuntimeContext } from 'mol-task'
 import { ValueCell } from 'mol-util'
 import { Sphere3D, Box3D } from 'mol-math/geometry'
-import { paramDefaultValues, RangeParam, SelectParam, TextParam } from 'mol-view/parameter';
+import { paramDefaultValues, RangeParam, SelectParam, TextParam } from 'mol-util/parameter';
 import { DirectVolumeValues } from 'mol-gl/renderable/direct-volume';
 import { Vec3, Mat4 } from 'mol-math/linear-algebra';
 import { Box } from '../../primitive/box';

src/mol-geo/geometry/direct-volume/transfer-function.ts

@@ -18,7 +18,7 @@ export function getControlPointsFromString(s: string): ControlPoint[] {
         return { x: parseFloat(ps[0]), alpha: parseFloat(ps[1]) }
     })
 }
-// TODO move core function to mol-view/color
+// TODO move core function to mol-canvas3d/color
 export function createTransferFunctionTexture(controlPoints: ControlPoint[], texture?: ValueCell<TextureImage<Uint8Array>>): ValueCell<TextureImage<Uint8Array>> {
     const cp = [
         { x: 0, alpha: 0 },

src/mol-geo/geometry/geometry.ts

@@ -10,13 +10,12 @@ import { RenderableState } from 'mol-gl/renderable';
 import { ValueCell } from 'mol-util';
 import { BaseValues } from 'mol-gl/renderable/schema';
 import { Color } from 'mol-util/color';
-import { ColorThemeOptions, ColorThemeName } from 'mol-view/theme/color';
+import { ColorThemeOptions, ColorThemeName } from 'mol-canvas3d/theme/color';
 import { LocationIterator } from '../util/location-iterator';
 import { ColorType } from './color-data';
 import { SizeType } from './size-data';
 import { Lines } from './lines/lines';
-import { paramDefaultValues, RangeParam, BooleanParam, SelectParam, ColorParam, StructureParam, ValueParam } from 'mol-view/parameter'
-import { Structure } from 'mol-model/structure';
+import { paramDefaultValues, RangeParam, BooleanParam, SelectParam, ColorParam, ValueParam } from 'mol-util/parameter'
 import { DirectVolume } from './direct-volume/direct-volume';
 import { Context } from 'mol-gl/webgl/context';
 
@@ -68,7 +67,6 @@ export namespace Geometry {
         quality: SelectParam<VisualQuality>('Quality', '', 'auto', VisualQualityOptions),
         colorTheme: SelectParam<ColorThemeName>('Color Theme', '', 'uniform', ColorThemeOptions),
         colorValue: ColorParam('Color Value', '', Color(0xCCCCCC)),
-        structure: StructureParam('Structure', '', Structure.Empty),
         webgl: ValueParam('WebGL Context', '', undefined as Context | undefined),
     }
     export const DefaultProps = paramDefaultValues(Params)

src/mol-geo/geometry/lines/lines.ts

@@ -14,11 +14,11 @@ import { createMarkers } from '../marker-data';
 import { createSizes } from '../size-data';
 import { TransformData } from '../transform-data';
 import { LocationIterator } from '../../util/location-iterator';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { LinesValues } from 'mol-gl/renderable/lines';
 import { Mesh } from '../mesh/mesh';
 import { LinesBuilder } from './lines-builder';
-import { BooleanParam, SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { BooleanParam, SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 /** Wide line */
 export interface Lines {

src/mol-geo/geometry/mesh/mesh.ts

@@ -16,7 +16,7 @@ import { TransformData } from '../transform-data';
 import { LocationIterator } from '../../util/location-iterator';
 import { createColors } from '../color-data';
 import { ChunkedArray } from 'mol-data/util';
-import { BooleanParam, paramDefaultValues } from 'mol-view/parameter';
+import { BooleanParam, paramDefaultValues } from 'mol-util/parameter';
 
 export interface Mesh {
     readonly kind: 'mesh',

src/mol-geo/geometry/points/points.ts

@@ -15,8 +15,8 @@ import { createMarkers } from '../marker-data';
 import { createSizes } from '../size-data';
 import { TransformData } from '../transform-data';
 import { LocationIterator } from '../../util/location-iterator';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
-import { BooleanParam, NumberParam, SelectParam, paramDefaultValues } from 'mol-view/parameter';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
+import { BooleanParam, NumberParam, SelectParam, paramDefaultValues } from 'mol-util/parameter';
 
 /** Point cloud */
 export interface Points {

src/mol-geo/geometry/size-data.ts

@@ -10,7 +10,7 @@ import { TextureImage, createTextureImage } from 'mol-gl/renderable/util';
 import { LocationIterator } from '../util/location-iterator';
 import { Location, NullLocation } from 'mol-model/location';
 import { RuntimeContext } from 'mol-task';
-import { SizeThemeProps, SizeTheme, SizeThemeName } from 'mol-view/theme/size';
+import { SizeThemeProps, SizeTheme, SizeThemeName } from 'mol-canvas3d/theme/size';
 import { getGranularity } from './geometry';
 import { Structure } from 'mol-model/structure';
 

src/mol-geo/representation/index.ts

@@ -9,7 +9,7 @@ import { RenderObject } from 'mol-gl/render-object'
 import { PickingId } from '../geometry/picking';
 import { Loci } from 'mol-model/loci';
 import { MarkerAction } from '../geometry/marker-data';
-import { Params } from 'mol-view/parameter';
+import { Params } from 'mol-util/parameter';
 
 export interface RepresentationProps {}
 

src/mol-geo/representation/shape/index.ts

@@ -11,14 +11,14 @@ import { PickingId } from '../../geometry/picking';
 import { Loci, EmptyLoci, isEveryLoci } from 'mol-model/loci';
 import { MarkerAction, applyMarkerAction } from '../../geometry/marker-data';
 import { ValueCell } from 'mol-util';
-import { ColorThemeName, ColorThemeOptions } from 'mol-view/theme/color';
+import { ColorThemeName, ColorThemeOptions } from 'mol-canvas3d/theme/color';
 import { Shape } from 'mol-model/shape';
 import { LocationIterator } from '../../util/location-iterator';
 import { OrderedSet, Interval } from 'mol-data/int';
 import { createIdentityTransform } from '../../geometry/transform-data';
 import { createRenderableState } from '../../geometry/geometry';
 import { Mesh } from '../../geometry/mesh/mesh';
-import { paramDefaultValues, SelectParam } from 'mol-view/parameter';
+import { paramDefaultValues, SelectParam } from 'mol-util/parameter';
 
 export interface ShapeRepresentation<P extends RepresentationProps = {}> extends Representation<Shape, P> { }
 

src/mol-geo/representation/structure/complex-visual.ts

@@ -19,7 +19,7 @@ import { MarkerAction, applyMarkerAction } from '../../geometry/marker-data';
 import { Interval } from 'mol-data/int';
 import { updateRenderableState, Geometry } from '../../geometry/geometry';
 import { createColors } from '../../geometry/color-data';
-import { MultiSelectParam, paramDefaultValues } from 'mol-view/parameter';
+import { MultiSelectParam, paramDefaultValues } from 'mol-util/parameter';
 import { RenderableValues } from 'mol-gl/renderable/schema';
 import { createSizes } from 'mol-geo/geometry/size-data';
 

src/mol-geo/representation/structure/index.ts

@@ -6,14 +6,14 @@
  */
 
 import { Structure } from 'mol-model/structure';
-import { ColorThemeName, ColorThemeOptions } from 'mol-view/theme/color';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { ColorThemeName, ColorThemeOptions } from 'mol-canvas3d/theme/color';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { Representation, RepresentationProps } from '..';
 import { Geometry } from '../../geometry/geometry';
 import { Mesh } from '../../geometry/mesh/mesh';
 import { Points } from '../../geometry/points/points';
 import { Lines } from '../../geometry/lines/lines';
-import { SelectParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, paramDefaultValues } from 'mol-util/parameter';
 import { DirectVolume } from '../../geometry/direct-volume/direct-volume';
 
 export interface StructureRepresentation<P extends RepresentationProps = {}> extends Representation<Structure, P> { }

src/mol-geo/representation/structure/representation/backbone.ts

@@ -12,7 +12,7 @@ import { Loci } from 'mol-model/loci';
 import { MarkerAction } from '../../../geometry/marker-data';
 import { PolymerBackboneVisual, PolymerBackboneParams } from '../visual/polymer-backbone-cylinder';
 import { getQualityProps } from '../../util';
-import { paramDefaultValues } from 'mol-view/parameter';
+import { paramDefaultValues } from 'mol-util/parameter';
 
 export const BackboneParams = {
     ...PolymerBackboneParams

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

@@ -13,9 +13,9 @@ import { Task } from 'mol-task';
 import { Loci, isEmptyLoci } from 'mol-model/loci';
 import { MarkerAction } from '../../../geometry/marker-data';
 import { InterUnitLinkVisual } from '../visual/inter-unit-link-cylinder';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { getQualityProps } from '../../util';
-import { paramDefaultValues, SelectParam, NumberParam, MultiSelectParam } from 'mol-view/parameter';
+import { paramDefaultValues, SelectParam, NumberParam, MultiSelectParam } from 'mol-util/parameter';
 import { UnitKind, UnitKindOptions } from '../visual/util/common';
 
 export const BallAndStickParams = {

src/mol-geo/representation/structure/representation/carbohydrate.ts

@@ -12,9 +12,9 @@ import { Loci, isEmptyLoci } from 'mol-model/loci';
 import { MarkerAction } from '../../../geometry/marker-data';
 import { CarbohydrateSymbolVisual, CarbohydrateSymbolParams } from '../visual/carbohydrate-symbol-mesh';
 import { CarbohydrateLinkVisual, CarbohydrateLinkParams } from '../visual/carbohydrate-link-cylinder';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { getQualityProps } from '../../util';
-import { paramDefaultValues, SelectParam, NumberParam } from 'mol-view/parameter';
+import { paramDefaultValues, SelectParam, NumberParam } from 'mol-util/parameter';
 
 export const CarbohydrateParams = {
     ...CarbohydrateSymbolParams,

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

@@ -13,9 +13,9 @@ import { MarkerAction } from '../../../geometry/marker-data';
 import { PolymerTraceVisual,  PolymerTraceParams } from '../visual/polymer-trace-mesh';
 import { PolymerGapVisual, PolymerGapParams } from '../visual/polymer-gap-cylinder';
 import { NucleotideBlockVisual, NucleotideBlockParams } from '../visual/nucleotide-block-mesh';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { getQualityProps } from '../../util';
-import { paramDefaultValues, SelectParam, NumberParam } from 'mol-view/parameter';
+import { paramDefaultValues, SelectParam, NumberParam } from 'mol-util/parameter';
 // import { PolymerDirectionVisual, DefaultPolymerDirectionProps } from '../visual/polymer-direction-wedge';
 
 export const CartoonParams = {

src/mol-geo/representation/structure/representation/distance-restraint.ts

@@ -11,9 +11,9 @@ import { Task } from 'mol-task';
 import { Loci } from 'mol-model/loci';
 import { MarkerAction } from '../../../geometry/marker-data';
 import { CrossLinkRestraintVisual, CrossLinkRestraintParams } from '../visual/cross-link-restraint-cylinder';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { getQualityProps } from '../../util';
-import { paramDefaultValues, SelectParam, NumberParam } from 'mol-view/parameter';
+import { paramDefaultValues, SelectParam, NumberParam } from 'mol-util/parameter';
 
 export const DistanceRestraintParams = {
     ...CrossLinkRestraintParams,

src/mol-geo/representation/structure/representation/molecular-surface.ts

@@ -14,9 +14,9 @@ import { PickingId } from '../../../geometry/picking';
 import { Task } from 'mol-task';
 import { GaussianWireframeVisual, GaussianWireframeParams } from '../visual/gaussian-surface-wireframe';
 import { getQualityProps } from '../../util';
-import { paramDefaultValues, MultiSelectParam, SelectParam } from 'mol-view/parameter';
+import { paramDefaultValues, MultiSelectParam, SelectParam } from 'mol-util/parameter';
 import { GaussianDensityVolumeParams, GaussianDensityVolumeVisual } from '../visual/gaussian-density-volume';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 
 const VisualOptions = [['surface', 'Surface'], ['wireframe', 'Wireframe'], ['volume', 'Volume']] as [string, string][]
 

src/mol-geo/representation/structure/representation/point.ts

@@ -11,7 +11,7 @@ import { Structure } from 'mol-model/structure';
 import { MarkerAction } from '../../../geometry/marker-data';
 import { Loci } from 'mol-model/loci';
 import { PickingId } from '../../../geometry/picking';
-import { paramDefaultValues } from 'mol-view/parameter';
+import { paramDefaultValues } from 'mol-util/parameter';
 
 export const PointParams = {
     ...ElementPointParams,

src/mol-geo/representation/structure/representation/spacefill.ts

@@ -12,7 +12,7 @@ import { PickingId } from '../../../geometry/picking';
 import { MarkerAction } from '../../../geometry/marker-data';
 import { Loci } from 'mol-model/loci';
 import { getQualityProps } from '../../util';
-import { paramDefaultValues } from 'mol-view/parameter';
+import { paramDefaultValues } from 'mol-util/parameter';
 
 export const SpacefillParams = {
     ...ElementSphereParams

src/mol-geo/representation/structure/units-visual.ts

@@ -22,7 +22,7 @@ import { updateRenderableState, Geometry } from '../../geometry/geometry';
 import { createColors } from '../../geometry/color-data';
 import { createSizes } from '../../geometry/size-data';
 import { Lines } from '../../geometry/lines/lines';
-import { MultiSelectParam, paramDefaultValues } from 'mol-view/parameter';
+import { MultiSelectParam, paramDefaultValues } from 'mol-util/parameter';
 import { DirectVolume } from '../../geometry/direct-volume/direct-volume';
 import { RenderableValues } from 'mol-gl/renderable/schema';
 

src/mol-geo/representation/structure/visual/carbohydrate-link-cylinder.ts

@@ -15,11 +15,11 @@ import { LocationIterator } from '../../../util/location-iterator';
 import { createLinkCylinderMesh, LinkCylinderProps, LinkCylinderParams } from './util/link';
 import { OrderedSet, Interval } from 'mol-data/int';
 import { ComplexMeshVisual } from '../complex-visual';
-import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { LinkType } from 'mol-model/structure/model/types';
 import { BitFlags } from 'mol-util';
 import { UnitsMeshParams } from '../units-visual';
-import { SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 // TODO create seperate visual
 // for (let i = 0, il = carbohydrates.terminalLinks.length; i < il; ++i) {

src/mol-geo/representation/structure/visual/carbohydrate-symbol-mesh.ts

@@ -16,14 +16,14 @@ import { getSaccharideShape, SaccharideShapes } from 'mol-model/structure/struct
 import { LocationIterator } from '../../../util/location-iterator';
 import { OrderedSet, Interval } from 'mol-data/int';
 import { ComplexMeshVisual, ComplexMeshParams } from '../complex-visual';
-import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { addSphere } from '../../../geometry/mesh/builder/sphere';
 import { Box, PerforatedBox } from '../../../primitive/box';
 import { OctagonalPyramid, PerforatedOctagonalPyramid } from '../../../primitive/pyramid';
 import { Star } from '../../../primitive/star';
 import { Octahedron, PerforatedOctahedron } from '../../../primitive/octahedron';
 import { DiamondPrism, PentagonalPrism, HexagonalPrism } from '../../../primitive/prism';
-import { SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 const t = Mat4.identity()
 const sVec = Vec3.zero()

src/mol-geo/representation/structure/visual/cross-link-restraint-cylinder.ts

@@ -15,10 +15,10 @@ import { Loci, EmptyLoci } from 'mol-model/loci';
 import { ComplexMeshVisual, ComplexMeshParams } from '../complex-visual';
 import { LocationIterator } from '../../../util/location-iterator';
 import { Interval } from 'mol-data/int';
-import { SizeTheme, SizeThemeOptions, SizeThemeName } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeOptions, SizeThemeName } from 'mol-canvas3d/theme/size';
 import { BitFlags } from 'mol-util';
 import { LinkType } from 'mol-model/structure/model/types';
-import { SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 async function createCrossLinkRestraintCylinderMesh(ctx: RuntimeContext, structure: Structure, props: LinkCylinderProps, mesh?: Mesh) {
 

src/mol-geo/representation/structure/visual/element-point.ts

@@ -9,11 +9,11 @@ import { RuntimeContext } from 'mol-task'
 import { UnitsVisual, VisualUpdateState } from '..';
 import { getElementLoci, StructureElementIterator, markElement } from './util/element';
 import { Vec3 } from 'mol-math/linear-algebra';
-import { SizeThemeOptions, SizeThemeName } from 'mol-view/theme/size';
+import { SizeThemeOptions, SizeThemeName } from 'mol-canvas3d/theme/size';
 import { UnitsPointsVisual, UnitsPointsParams } from '../units-visual';
 import { Points } from '../../../geometry/points/points';
 import { PointsBuilder } from '../../../geometry/points/points-builder';
-import { SelectParam, NumberParam, BooleanParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, BooleanParam, paramDefaultValues } from 'mol-util/parameter';
 
 export const ElementPointParams = {
     ...UnitsPointsParams,

src/mol-geo/representation/structure/visual/element-sphere.ts

@@ -8,8 +8,8 @@
 import { UnitsVisual, VisualUpdateState } from '..';
 import { createElementSphereMesh, markElement, getElementLoci, StructureElementIterator } from './util/element';
 import { UnitsMeshVisual, UnitsMeshParams } from '../units-visual';
-import { NumberParam, paramDefaultValues, SelectParam } from 'mol-view/parameter';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { NumberParam, paramDefaultValues, SelectParam } from 'mol-util/parameter';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 
 export const ElementSphereParams = {
     ...UnitsMeshParams,

src/mol-geo/representation/structure/visual/gaussian-density-point.ts

@@ -13,9 +13,9 @@ import { Vec3 } from 'mol-math/linear-algebra';
 import { UnitsPointsVisual, UnitsPointsParams } from '../units-visual';
 import { Points } from '../../../geometry/points/points';
 import { PointsBuilder } from '../../../geometry/points/points-builder';
-import { SizeThemeOptions, SizeThemeName } from 'mol-view/theme/size';
+import { SizeThemeOptions, SizeThemeName } from 'mol-canvas3d/theme/size';
 import { GaussianDensityProps, GaussianDensityParams } from 'mol-model/structure/structure/unit/gaussian-density';
-import { paramDefaultValues, SelectParam, NumberParam, BooleanParam } from 'mol-view/parameter';
+import { paramDefaultValues, SelectParam, NumberParam, BooleanParam } from 'mol-util/parameter';
 
 export const GaussianDensityPointParams = {
     ...UnitsPointsParams,

src/mol-geo/representation/structure/visual/gaussian-density-volume.ts

@@ -10,7 +10,7 @@ import { RuntimeContext } from 'mol-task'
 import { UnitsDirectVolumeVisual, UnitsDirectVolumeParams } from '../units-visual';
 import { StructureElementIterator, getElementLoci, markElement } from './util/element';
 import { GaussianDensityProps, GaussianDensityParams, computeUnitGaussianDensityTexture } from 'mol-model/structure/structure/unit/gaussian-density';
-import { paramDefaultValues } from 'mol-view/parameter';
+import { paramDefaultValues } from 'mol-util/parameter';
 import { DirectVolume } from '../../../geometry/direct-volume/direct-volume';
 
 async function createGaussianDensityVolume(ctx: RuntimeContext, unit: Unit, structure: Structure, props: GaussianDensityProps, directVolume?: DirectVolume): Promise<DirectVolume> {

src/mol-geo/representation/structure/visual/gaussian-surface-mesh.ts

@@ -12,7 +12,7 @@ import { UnitsMeshVisual, UnitsMeshParams } from '../units-visual';
 import { StructureElementIterator, getElementLoci, markElement } from './util/element';
 import { computeMarchingCubesMesh } from '../../../util/marching-cubes/algorithm';
 import { GaussianDensityProps, GaussianDensityParams } from 'mol-model/structure/structure/unit/gaussian-density';
-import { paramDefaultValues } from 'mol-view/parameter';
+import { paramDefaultValues } from 'mol-util/parameter';
 
 async function createGaussianSurfaceMesh(ctx: RuntimeContext, unit: Unit, structure: Structure, props: GaussianDensityProps, mesh?: Mesh): Promise<Mesh> {
     const { smoothness } = props

src/mol-geo/representation/structure/visual/gaussian-surface-wireframe.ts

@@ -12,8 +12,8 @@ import { StructureElementIterator, getElementLoci, markElement } from './util/el
 import { computeMarchingCubesLines } from '../../../util/marching-cubes/algorithm';
 import { Lines } from '../../../geometry/lines/lines';
 import { GaussianDensityProps, GaussianDensityParams } from 'mol-model/structure/structure/unit/gaussian-density';
-import { paramDefaultValues, SelectParam, NumberParam, BooleanParam } from 'mol-view/parameter';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { paramDefaultValues, SelectParam, NumberParam, BooleanParam } from 'mol-util/parameter';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 
 async function createGaussianWireframe(ctx: RuntimeContext, unit: Unit, structure: Structure, props: GaussianDensityProps, lines?: Lines): Promise<Lines> {
     const { smoothness } = props

src/mol-geo/representation/structure/visual/inter-unit-link-cylinder.ts

@@ -14,9 +14,9 @@ import { Vec3 } from 'mol-math/linear-algebra';
 import { Loci, EmptyLoci } from 'mol-model/loci';
 import { ComplexMeshVisual, ComplexMeshParams } from '../complex-visual';
 import { Interval } from 'mol-data/int';
-import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { BitFlags } from 'mol-util';
-import { SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 async function createInterUnitLinkCylinderMesh(ctx: RuntimeContext, structure: Structure, props: LinkCylinderProps, mesh?: Mesh) {
     const links = structure.links

src/mol-geo/representation/structure/visual/intra-unit-link-cylinder.ts

@@ -15,9 +15,9 @@ import { Vec3 } from 'mol-math/linear-algebra';
 import { Loci, EmptyLoci } from 'mol-model/loci';
 import { UnitsMeshVisual, UnitsMeshParams } from '../units-visual';
 import { Interval } from 'mol-data/int';
-import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { BitFlags } from 'mol-util';
-import { SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 async function createIntraUnitLinkCylinderMesh(ctx: RuntimeContext, unit: Unit, structure: Structure, props: LinkCylinderProps, mesh?: Mesh) {
     if (!Unit.isAtomic(unit)) return Mesh.createEmpty(mesh)

src/mol-geo/representation/structure/visual/nucleotide-block-mesh.ts

@@ -17,7 +17,7 @@ import { UnitsMeshVisual, UnitsMeshParams } from '../units-visual';
 import { addCylinder } from '../../../geometry/mesh/builder/cylinder';
 import { Box } from '../../../primitive/box';
 import { NucleotideLocationIterator, markNucleotideElement, getNucleotideElementLoci } from './util/nucleotide';
-import { paramDefaultValues } from 'mol-view/parameter';
+import { paramDefaultValues } from 'mol-util/parameter';
 
 const p1 = Vec3.zero()
 const p2 = Vec3.zero()

src/mol-geo/representation/structure/visual/polymer-backbone-cylinder.ts

@@ -13,11 +13,11 @@ import { PolymerBackboneIterator } from './util/polymer';
 import { getElementLoci, markElement, StructureElementIterator } from './util/element';
 import { Vec3 } from 'mol-math/linear-algebra';
 import { UnitsMeshVisual, UnitsMeshParams } from '../units-visual';
-import { SizeTheme, SizeThemeOptions, SizeThemeName } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeOptions, SizeThemeName } from 'mol-canvas3d/theme/size';
 import { CylinderProps } from '../../../primitive/cylinder';
 import { OrderedSet } from 'mol-data/int';
 import { addCylinder } from '../../../geometry/mesh/builder/cylinder';
-import { paramDefaultValues, NumberParam, SelectParam } from 'mol-view/parameter';
+import { paramDefaultValues, NumberParam, SelectParam } from 'mol-util/parameter';
 
 export const PolymerBackboneCylinderParams = {
     sizeTheme: SelectParam<SizeThemeName>('Size Theme', '', 'uniform', SizeThemeOptions),

src/mol-geo/representation/structure/visual/polymer-direction-wedge.ts

@@ -13,9 +13,9 @@ import { PolymerTraceIterator, createCurveSegmentState, interpolateCurveSegment,
 import { Vec3, Mat4 } from 'mol-math/linear-algebra';
 import { SecondaryStructureType, isNucleic } from 'mol-model/structure/model/types';
 import { UnitsMeshVisual, UnitsMeshParams } from '../units-visual';
-import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { Wedge } from '../../../primitive/wedge';
-import { SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 const t = Mat4.identity()
 const sVec = Vec3.zero()

src/mol-geo/representation/structure/visual/polymer-gap-cylinder.ts

@@ -12,11 +12,11 @@ import { MeshBuilder } from '../../../geometry/mesh/mesh-builder';
 import { PolymerGapIterator, PolymerGapLocationIterator, markPolymerGapElement, getPolymerGapElementLoci } from './util/polymer';
 import { Vec3 } from 'mol-math/linear-algebra';
 import { UnitsMeshVisual, UnitsMeshParams } from '../units-visual';
-import { SizeTheme, SizeThemeOptions, SizeThemeName } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeOptions, SizeThemeName } from 'mol-canvas3d/theme/size';
 import { CylinderProps } from '../../../primitive/cylinder';
 import { addSphere } from '../../../geometry/mesh/builder/sphere';
 import { addFixedCountDashedCylinder } from '../../../geometry/mesh/builder/cylinder';
-import { SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 import { LinkCylinderParams } from './util/link';
 
 const segmentCount = 10

src/mol-geo/representation/structure/visual/polymer-trace-mesh.ts

@@ -12,10 +12,10 @@ import { MeshBuilder } from '../../../geometry/mesh/mesh-builder';
 import { PolymerTraceIterator, createCurveSegmentState, interpolateCurveSegment, PolymerLocationIterator, getPolymerElementLoci, markPolymerElement } from './util/polymer';
 import { SecondaryStructureType, isNucleic } from 'mol-model/structure/model/types';
 import { UnitsMeshVisual, UnitsMeshParams } from '../units-visual';
-import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { addSheet } from '../../../geometry/mesh/builder/sheet';
 import { addTube } from '../../../geometry/mesh/builder/tube';
-import { SelectParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 export const PolymerTraceMeshParams = {
     sizeTheme: SelectParam<SizeThemeName>('Size Theme', '', 'physical', SizeThemeOptions),

src/mol-geo/representation/structure/visual/util/element.ts

@@ -13,7 +13,7 @@ import { MeshBuilder } from '../../../../geometry/mesh/mesh-builder';
 import { Loci, EmptyLoci } from 'mol-model/loci';
 import { Interval, OrderedSet } from 'mol-data/int';
 import { PickingId } from '../../../../geometry/picking';
-import { SizeTheme, SizeThemeName } from 'mol-view/theme/size';
+import { SizeTheme, SizeThemeName } from 'mol-canvas3d/theme/size';
 import { LocationIterator } from '../../../../util/location-iterator';
 import { addSphere } from '../../../../geometry/mesh/builder/sphere';
 

src/mol-geo/representation/structure/visual/util/link.ts

@@ -9,12 +9,12 @@ import { RuntimeContext } from 'mol-task';
 import { Mesh } from '../../../../geometry/mesh/mesh';
 import { MeshBuilder } from '../../../../geometry/mesh/mesh-builder';
 import { LinkType } from 'mol-model/structure/model/types';
-import { SizeThemeName, SizeThemeOptions } from 'mol-view/theme/size';
+import { SizeThemeName, SizeThemeOptions } from 'mol-canvas3d/theme/size';
 import { CylinderProps } from '../../../../primitive/cylinder';
 import { LocationIterator } from '../../../../util/location-iterator';
 import { Unit, StructureElement, Structure, Link } from 'mol-model/structure';
 import { addFixedCountDashedCylinder, addCylinder, addDoubleCylinder } from '../../../../geometry/mesh/builder/cylinder';
-import { SelectParam, RangeParam, NumberParam, paramDefaultValues } from 'mol-view/parameter';
+import { SelectParam, RangeParam, NumberParam, paramDefaultValues } from 'mol-util/parameter';
 
 export const LinkCylinderParams = {
     sizeTheme: SelectParam<SizeThemeName>('Size Theme', '', 'uniform', SizeThemeOptions),

src/mol-geo/representation/volume/direct-volume.ts

@@ -12,7 +12,7 @@ import { PickingId } from '../../geometry/picking';
 import { MarkerAction } from '../../geometry/marker-data';
 import { Loci, EmptyLoci } from 'mol-model/loci';
 import { createRenderableState, updateRenderableState, Geometry } from '../../geometry/geometry';
-import { paramDefaultValues } from 'mol-view/parameter';
+import { paramDefaultValues } from 'mol-util/parameter';
 import { DirectVolume } from '../../geometry/direct-volume/direct-volume';
 import { Vec3, Mat4 } from 'mol-math/linear-algebra';
 import { Box3D } from 'mol-math/geometry';

src/mol-geo/representation/volume/index.ts

@@ -11,7 +11,7 @@ import { PickingId } from '../../geometry/picking';
 import { Loci, EmptyLoci } from 'mol-model/loci';
 import { MarkerAction } from '../../geometry/marker-data';
 import { Geometry } from '../../geometry/geometry';
-import { paramDefaultValues } from 'mol-view/parameter';
+import { paramDefaultValues } from 'mol-util/parameter';
 
 export interface VolumeVisual<P extends RepresentationProps = {}> extends Visual<VolumeData, P> { }
 

src/mol-geo/representation/volume/isosurface-mesh.ts

@@ -18,7 +18,7 @@ import { LocationIterator } from '../../util/location-iterator';
 import { NullLocation } from 'mol-model/location';
 import { createIdentityTransform } from '../../geometry/transform-data';
 import { createRenderableState, updateRenderableState } from '../../geometry/geometry';
-import { paramDefaultValues, RangeParam } from 'mol-view/parameter';
+import { paramDefaultValues, RangeParam } from 'mol-util/parameter';
 import { ValueCell } from 'mol-util';
 
 export async function createVolumeSurface(ctx: RuntimeContext, volume: VolumeData, isoValueAbsolute: number, mesh?: Mesh) {

src/mol-gl/_spec/renderer.spec.ts

@@ -6,7 +6,7 @@
 
 import { createGl } from './gl.shim';
 
-import { PerspectiveCamera } from 'mol-view/camera/perspective';
+import { PerspectiveCamera } from 'mol-canvas3d/camera/perspective';
 import { Vec3, Mat4 } from 'mol-math/linear-algebra';
 import { ValueCell } from 'mol-util';
 

src/mol-gl/renderer.ts

@@ -5,8 +5,8 @@
  */
 
 // import { Vec3, Mat4 } from 'mol-math/linear-algebra'
-import { Viewport } from 'mol-view/camera/util';
-import { Camera } from 'mol-view/camera/base';
+import { Viewport } from 'mol-canvas3d/camera/util';
+import { Camera } from 'mol-canvas3d/camera/base';
 
 import Scene from './scene';
 import { Context, createImageData } from './webgl/context';

src/mol-model/structure/structure/unit/gaussian-density.ts

@@ -5,11 +5,11 @@
  */
 
 import { Unit, StructureElement, ElementIndex } from 'mol-model/structure';
-import { SizeTheme } from 'mol-view/theme/size';
+import { SizeTheme } from 'mol-canvas3d/theme/size';
 import { GaussianDensity } from 'mol-math/geometry/gaussian-density';
 import { Task, RuntimeContext } from 'mol-task';
 import { DensityData } from 'mol-math/geometry';
-import { NumberParam, paramDefaultValues, BooleanParam, ValueParam } from 'mol-view/parameter';
+import { NumberParam, paramDefaultValues, BooleanParam, ValueParam } from 'mol-util/parameter';
 import { Context } from 'mol-gl/webgl/context';
 import { GaussianDensityTexture } from 'mol-math/geometry/gaussian-density/gpu';
 import { Texture } from 'mol-gl/webgl/texture';

src/mol-state/context/context.ts → src/mol-plugin/index.ts

@@ -4,6 +4,4 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
-export interface StateContext {
-
-}
+// TODO

src/mol-state/context.ts

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { Subject } from 'rxjs'
+import { StateObject } from './object';
+import { Transform } from './tree/transform';
+
+interface StateContext {
+    events: {
+        object: {
+            stateChanged: Subject<{ ref: Transform.Ref }>,
+            propsChanged: Subject<{ ref: Transform.Ref, newProps: unknown }>,
+            updated: Subject<{ ref: Transform.Ref }>,
+            replaced: Subject<{ ref: Transform.Ref, old?: StateObject }>,
+            created: Subject<{ ref: Transform.Ref }>,
+            removed: Subject<{ ref: Transform.Ref }>,
+        },
+        warn: Subject<string>
+    },
+    globalContext: unknown,
+    defaultObjectProps: unknown
+}
+
+namespace StateContext {
+    export function create(params: { globalContext: unknown, defaultObjectProps: unknown }): StateContext {
+        return {
+            events: {
+                object: {
+                    stateChanged: new Subject(),
+                    propsChanged: new Subject(),
+                    updated: new Subject(),
+                    replaced: new Subject(),
+                    created: new Subject(),
+                    removed: new Subject()
+                },
+                warn: new Subject()
+            },
+            globalContext: params.globalContext,
+            defaultObjectProps: params.defaultObjectProps
+        }
+    }
+}
+
+export { StateContext }

src/mol-state/event/dispatcher.ts

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-export interface EventDispatcher {
-    // TODO
-}

src/mol-state/event/event.ts

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-export interface EventDispatcher {
-    // TODO
-}

src/mol-state/index.ts

@@ -2,4 +2,12 @@
  * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
- */
+ */
+
+export * from './object'
+export * from './state'
+export * from './transformer'
+export * from './tree'
+export * from './context'
+export * from './tree/transform'
+export * from './tree/selection'

src/mol-state/object.ts

@@ -16,12 +16,6 @@ export interface StateObject<P = unknown, D = unknown> {
 }
 
 export namespace StateObject {
-    // export type TypeOf<T>
-    //     = T extends StateObject<infer X> ? [X]
-    //     : T extends [StateObject<infer X>] ? [X]
-    //     : T extends [StateObject<infer X>, StateObject<infer Y>] ? [X, Y]
-    //     : unknown[];
-
     export enum StateType {
         // The object has been successfully created
         Ok,
@@ -52,9 +46,11 @@ export namespace StateObject {
         }
     }
 
-    export interface Wrapped {
-        obj: StateObject,
+    export interface Node {
         state: StateType,
+        props: unknown,
+        errorText?: string,
+        obj?: StateObject,
         version: string
     }
 }

src/mol-state/state.ts

@@ -5,79 +5,97 @@
  */
 
 import { StateObject } from './object';
-import { TransformTree } from './tree/tree';
+import { StateTree } from './tree';
 import { Transform } from './tree/transform';
-import { Map as ImmutableMap } from 'immutable';
-// import { StateContext } from './context/context';
 import { ImmutableTree } from './util/immutable-tree';
 import { Transformer } from './transformer';
-import { Task } from 'mol-task';
+import { StateContext } from './context';
+import { UUID } from 'mol-util';
+import { RuntimeContext, Task } from 'mol-task';
 
-export interface State<ObjectProps = unknown> {
-    definition: State.Definition<ObjectProps>,
-    objects: State.Objects
+export interface State {
+    tree: StateTree,
+    objects: State.Objects,
+    context: StateContext
 }
 
 export namespace State {
-    export type ObjectProps<P> = ImmutableMap<Transform.Ref, P>
-    export type Objects = Map<Transform.Ref, StateObject.Wrapped>
+    export type Ref = Transform.Ref
+    export type Objects = Map<Ref, StateObject.Node>
 
-    export interface Definition<P = unknown> {
-        tree: TransformTree,
-        // things like object visibility
-        props: ObjectProps<P>
-    }
-
-    export function create(): State {
-        const tree = TransformTree.create();
+    export function create(params?: { globalContext?: unknown, defaultObjectProps: unknown }) {
+        const tree = StateTree.create();
         const objects: Objects = new Map();
         const root = tree.getValue(tree.rootRef)!;
+        const defaultObjectProps = (params && params.defaultObjectProps) || { }
 
-        objects.set(tree.rootRef, { obj: void 0 as any, state: StateObject.StateType.Ok, version: root.version });
+        objects.set(tree.rootRef, { obj: void 0 as any, state: StateObject.StateType.Ok, version: root.version, props: { ...defaultObjectProps } });
 
         return {
-            definition: {
-                tree,
-                props: ImmutableMap()
-            },
-            objects
+            tree,
+            objects,
+            context: StateContext.create({
+                globalContext: params && params.globalContext,
+                defaultObjectProps
+            })
         };
     }
 
-    export async function update<P>(state: State<P>, tree: TransformTree, props?: ObjectProps<P>): Promise<State<P>> {
-        const roots = findUpdateRoots(state.objects, tree);
-        const deletes = findDeletes(state.objects, tree);
+    export function update(state: State, tree: StateTree): Task<State> {
+        return Task.create('Update Tree', taskCtx => {
+            const ctx: UpdateContext = {
+                stateCtx: state.context,
+                taskCtx,
+                oldTree: state.tree,
+                tree: tree,
+                objects: state.objects
+            };
+            return _update(ctx);
+        })
+    }
+
+    async function _update(ctx: UpdateContext): Promise<State> {
+        const roots = findUpdateRoots(ctx.objects, ctx.tree);
+        const deletes = findDeletes(ctx);
         for (const d of deletes) {
-            state.objects.delete(d);
+            ctx.objects.delete(d);
+            ctx.stateCtx.events.object.removed.next({ ref: d });
         }
 
-        console.log('roots', roots);
+        initObjectState(ctx, roots);
+
         for (const root of roots) {
-            await updateSubtree(state.definition.tree, tree, state.objects, root);
+            await updateSubtree(ctx, root);
         }
 
         return {
-            definition: { tree, props: props || state.definition.props },
-            objects: state.objects
+            tree: ctx.tree,
+            objects: ctx.objects,
+            context: ctx.stateCtx
         };
     }
 
-    function findUpdateRoots(objects: Objects, tree: TransformTree) {
-        console.log(tree);
+    interface UpdateContext {
+        stateCtx: StateContext,
+        taskCtx: RuntimeContext,
+        oldTree: StateTree,
+        tree: StateTree,
+        objects: Objects
+    }
+
+    function findUpdateRoots(objects: Objects, tree: StateTree) {
         const findState = {
-            roots: [] as Transform.Ref[],
+            roots: [] as Ref[],
             objects
         };
 
         ImmutableTree.doPreOrder(tree, tree.nodes.get(tree.rootRef)!, findState, (n, _, s) => {
             if (!s.objects.has(n.ref)) {
-                console.log('missing', n.ref);
                 s.roots.push(n.ref);
                 return false;
             }
             const o = s.objects.get(n.ref)!;
             if (o.version !== n.value.version) {
-                console.log('diff version', n.ref, n.value.version, o.version);
                 s.roots.push(n.ref);
                 return false;
             }
@@ -88,66 +106,153 @@ export namespace State {
         return findState.roots;
     }
 
-    function findDeletes(objects: Objects, tree: TransformTree): Transform.Ref[] {
-        // TODO
-        return [];
+    function findDeletes(ctx: UpdateContext): Ref[] {
+        // TODO: do this in some sort of "tree order"?
+        const deletes: Ref[] = [];
+        const keys = ctx.objects.keys();
+        while (true) {
+            const key = keys.next();
+            if (key.done) break;
+            if (!ctx.tree.nodes.has(key.value)) deletes.push(key.value);
+        }
+        return deletes;
+    }
+
+    function setObjectState(ctx: UpdateContext, ref: Ref, state: StateObject.StateType, errorText?: string) {
+        let changed = false;
+        if (ctx.objects.has(ref)) {
+            const obj = ctx.objects.get(ref)!;
+            changed = obj.state !== state;
+            obj.state = state;
+            obj.errorText = errorText;
+        } else {
+            const obj = { state, version: UUID.create(), errorText, props: { ...ctx.stateCtx.defaultObjectProps } };
+            ctx.objects.set(ref, obj);
+            changed = true;
+        }
+        if (changed) ctx.stateCtx.events.object.stateChanged.next({ ref });
     }
 
-    function findParent(tree: TransformTree, objects: Objects, root: Transform.Ref, types: { type: StateObject.Type }[]): StateObject {
+    function _initVisitor(t: ImmutableTree.Node<Transform>, _: any, ctx: UpdateContext) {
+        setObjectState(ctx, t.ref, StateObject.StateType.Pending);
+    }
+    /** Return "resolve set" */
+    function initObjectState(ctx: UpdateContext, roots: Ref[]) {
+        for (const root of roots) {
+            ImmutableTree.doPreOrder(ctx.tree, ctx.tree.nodes.get(root), ctx, _initVisitor);
+        }
+    }
+
+    function doError(ctx: UpdateContext, ref: Ref, errorText: string) {
+        setObjectState(ctx, ref, StateObject.StateType.Error, errorText);
+        const wrap = ctx.objects.get(ref)!;
+        if (wrap.obj) {
+            ctx.stateCtx.events.object.removed.next({ ref });
+            wrap.obj = void 0;
+        }
+
+        const children = ctx.tree.nodes.get(ref)!.children.values();
+        while (true) {
+            const next = children.next();
+            if (next.done) return;
+            doError(ctx, next.value, 'Parent node contains error.');
+        }
+    }
+
+    function findParent(tree: StateTree, objects: Objects, root: Ref, types: { type: StateObject.Type }[]): StateObject {
         let current = tree.nodes.get(root)!;
-        console.log('finding', types.map(t => t.type.kind));
         while (true) {
             current = tree.nodes.get(current.parent)!;
-            if (current.ref === tree.rootRef) return objects.get(tree.rootRef)!.obj;
-            const obj = objects.get(current.ref)!.obj;
-            console.log('current', obj.type.kind);
-            for (const t of types) if (obj.type === t.type) return objects.get(current.ref)!.obj;
+            if (current.ref === tree.rootRef) {
+                return objects.get(tree.rootRef)!.obj!;
+            }
+            const obj = objects.get(current.ref)!.obj!;
+            for (const t of types) if (obj.type === t.type) return objects.get(current.ref)!.obj!;
         }
     }
 
-    async function updateSubtree(oldTree: TransformTree, tree: TransformTree, objects: Objects, root: Transform.Ref) {
-        await updateNode(oldTree, tree, objects, root);
-        const children = tree.nodes.get(root)!.children.values();
+    async function updateSubtree(ctx: UpdateContext, root: Ref) {
+        setObjectState(ctx, root, StateObject.StateType.Processing);
+
+        try {
+            const update = await updateNode(ctx, root);
+            setObjectState(ctx, root, StateObject.StateType.Ok);
+            if (update.action === 'created') {
+                ctx.stateCtx.events.object.created.next({ ref: root });
+            } else if (update.action === 'updated') {
+                ctx.stateCtx.events.object.updated.next({ ref: root });
+            } else if (update.action === 'replaced') {
+                ctx.stateCtx.events.object.replaced.next({ ref: root, old: update.old });
+            }
+        } catch (e) {
+            doError(ctx, root, '' + e);
+            return;
+        }
+
+        const children = ctx.tree.nodes.get(root)!.children.values();
         while (true) {
             const next = children.next();
             if (next.done) return;
-            await updateSubtree(oldTree, tree, objects, next.value);
+            await updateSubtree(ctx, next.value);
         }
     }
 
-    async function updateNode(oldTree: TransformTree, tree: TransformTree, objects: Objects, root: Transform.Ref) {
-        const transform = tree.getValue(root)!;
-        const parent = findParent(tree, objects, root, transform.transformer.definition.from);
-        console.log('parent', parent ? parent.ref : 'undefined')
-        if (!oldTree.nodes.has(transform.ref) || !objects.has(transform.ref)) {
-            console.log('creating...', transform.transformer.id, oldTree.nodes.has(transform.ref), objects.has(transform.ref));
-            const obj = await createObject(transform.transformer, parent, transform.params);
-            obj.ref = transform.ref;
-            objects.set(root, { obj, state: StateObject.StateType.Ok, version: transform.version });
+    async function updateNode(ctx: UpdateContext, currentRef: Ref) {
+        const { oldTree, tree, objects } = ctx;
+        const transform = tree.getValue(currentRef)!;
+        const parent = findParent(tree, objects, currentRef, transform.transformer.definition.from);
+        // console.log('parent', transform.transformer.id, transform.transformer.definition.from[0].type, parent ? parent.ref : 'undefined')
+        if (!oldTree.nodes.has(currentRef) || !objects.has(currentRef)) {
+            // console.log('creating...', transform.transformer.id, oldTree.nodes.has(currentRef), objects.has(currentRef));
+            const obj = await createObject(ctx, transform.transformer, parent, transform.params);
+            obj.ref = currentRef;
+            objects.set(currentRef, {
+                obj,
+                state: StateObject.StateType.Ok,
+                version: transform.version,
+                props: { ...ctx.stateCtx.defaultObjectProps, ...transform.defaultProps }
+            });
+            return { action: 'created' };
         } else {
-            console.log('updating...', transform.transformer.id);
-            const current = objects.get(transform.ref)!.obj;
-            const oldParams = oldTree.getValue(transform.ref)!.params;
-            await updateObject(transform.transformer, parent, current, oldParams, transform.params);
-            const obj = objects.get(root)!;
-            obj.version = transform.version;
+            // console.log('updating...', transform.transformer.id);
+            const current = objects.get(currentRef)!;
+            const oldParams = oldTree.getValue(currentRef)!.params;
+            switch (await updateObject(ctx, transform.transformer, parent, current.obj!, oldParams, transform.params)) {
+                case Transformer.UpdateResult.Recreate: {
+                    const obj = await createObject(ctx, transform.transformer, parent, transform.params);
+                    obj.ref = currentRef;
+                    objects.set(currentRef, {
+                        obj,
+                        state: StateObject.StateType.Ok,
+                        version: transform.version,
+                        props: { ...ctx.stateCtx.defaultObjectProps, ...current.props, ...transform.defaultProps }
+                    });
+                    return { action: 'replaced', old: current.obj! };
+                }
+                case Transformer.UpdateResult.Updated:
+                    current.version = transform.version;
+                    current.props = { ...ctx.stateCtx.defaultObjectProps, ...current.props, ...transform.defaultProps };
+                    return { action: 'updated' };
+                default:
+                    // TODO check if props need to be updated
+                    return { action: 'none' };
+            }
         }
     }
 
-    async function runTask<A>(t: A | Task<A>): Promise<A> {
-        if ((t as any).run) return await (t as Task<A>).run();
-        return t as A;
+    function runTask<T>(t: T | Task<T>, ctx: RuntimeContext) {
+        if (typeof (t as any).run === 'function') return (t as Task<T>).runInContext(ctx);
+        return t as T;
     }
 
-    function createObject(transformer: Transformer, parent: StateObject, params: any) {
-        return runTask(transformer.definition.apply(parent, params, 0 as any));
+    function createObject(ctx: UpdateContext, transformer: Transformer, a: StateObject, params: any) {
+        return runTask(transformer.definition.apply({ a, params }, ctx.stateCtx.globalContext), ctx.taskCtx);
     }
 
-    async function updateObject(transformer: Transformer, parent: StateObject, obj: StateObject, oldParams: any, params: any) {
+    async function updateObject(ctx: UpdateContext, transformer: Transformer, a: StateObject, b: StateObject, oldParams: any, newParams: any) {
         if (!transformer.definition.update) {
-            // TODO
-            throw 'nyi';
+            return Transformer.UpdateResult.Recreate;
         }
-        return transformer.definition.update!(parent, oldParams, obj, params, 0 as any);
+        return runTask(transformer.definition.update({ a, oldParams, b, newParams }, ctx.stateCtx.globalContext), ctx.taskCtx);
     }
 }

src/mol-state/transformer.ts

@@ -6,11 +6,11 @@
 
 import { Task } from 'mol-task';
 import { StateObject } from './object';
-import { TransformContext } from './tree/context';
 import { Transform } from './tree/transform';
 
 export interface Transformer<A extends StateObject = StateObject, B extends StateObject = StateObject, P = unknown> {
     apply(params?: P, props?: Partial<Transform.Props>): Transform<A, B, P>,
+    readonly namespace: string,
     readonly id: Transformer.Id,
     readonly definition: Transformer.Definition<A, B, P>
 }
@@ -21,9 +21,22 @@ export namespace Transformer {
     export type To<T extends Transformer<any, any, any>> = T extends Transformer<any, infer B, any> ? B : unknown;
     export type ControlsFor<Props> = { [P in keyof Props]?: any }
 
+    export interface ApplyParams<A extends StateObject = StateObject, P = unknown> {
+        a: A,
+        params: P
+    }
+
+    export interface UpdateParams<A extends StateObject = StateObject, B extends StateObject = StateObject, P = unknown> {
+        a: A,
+        b: B,
+        oldParams: P,
+        newParams: P
+    }
+
+    export enum UpdateResult { Unchanged, Updated, Recreate }
+
     export interface Definition<A extends StateObject = StateObject, B extends StateObject = StateObject, P = unknown> {
         readonly name: string,
-        readonly namespace?: string,
         readonly from: { type: StateObject.Type }[],
         readonly to: { type: StateObject.Type }[],
 
@@ -31,31 +44,29 @@ export namespace Transformer {
          * Apply the actual transformation. It must be pure (i.e. with no side effects).
          * Returns a task that produces the result of the result directly.
          */
-        apply(a: A, params: P, context: TransformContext): Task<B> | B,
+        apply(params: ApplyParams<A, P>, globalCtx: unknown): Task<B> | B,
 
         /**
          * Attempts to update the entity in a non-destructive way.
          * For example changing a color scheme of a visual does not require computing new geometry.
          * Return/resolve to undefined if the update is not possible.
-         *
-         * The ability to resolve the task to undefined is present for "async updates" (i.e. containing an ajax call).
          */
-        update?(a: A, oldParams: P, b: B, newParams: P, context: TransformContext): Task<B | undefined> | B | undefined,
+        update?(params: UpdateParams<A, B, P>, globalCtx: unknown): Task<UpdateResult> | UpdateResult,
 
         /** Check the parameters and return a list of errors if the are not valid. */
-        defaultParams?(a: A, context: TransformContext): P,
+        defaultParams?(a: A, globalCtx: unknown): P,
 
         /** Specify default control descriptors for the parameters */
-        defaultControls?(a: A, context: TransformContext): Transformer.ControlsFor<P>,
+        defaultControls?(a: A, globalCtx: unknown): Transformer.ControlsFor<P>,
 
         /** Check the parameters and return a list of errors if the are not valid. */
-        validateParams?(a: A, params: P, context: TransformContext): string[] | undefined,
+        validateParams?(a: A, params: P, globalCtx: unknown): string[] | undefined,
 
         /** Optional custom parameter equality. Use deep structural equal by default. */
         areParamsEqual?(oldParams: P, newParams: P): boolean,
 
         /** Test if the transform can be applied to a given node */
-        isApplicable?(a: A, context: TransformContext): boolean,
+        isApplicable?(a: A, globalCtx: unknown): boolean,
 
         /** By default, returns true */
         isSerializable?(params: P): { isSerializable: true } | { isSerializable: false; reason: string },
@@ -66,12 +77,6 @@ export namespace Transformer {
 
     const registry = new Map<Id, Transformer>();
 
-    function typeToString(a: { type: StateObject.Type }[]) {
-        if (!a.length) return '()';
-        if (a.length === 1) return a[0].type.kind;
-        return `(${a.map(t => t.type.kind).join(' | ')})`;
-    }
-
     export function get(id: string): Transformer {
         const t = registry.get(id as Id);
         if (!t) {
@@ -81,8 +86,8 @@ export namespace Transformer {
     }
 
     export function create<A extends StateObject, B extends StateObject, P>(namespace: string, definition: Definition<A, B, P>) {
-        const { from, to, name } = definition;
-        const id = `${namespace}.${name} :: ${typeToString(from)} -> ${typeToString(to)}` as Id;
+        const { name } = definition;
+        const id = `${namespace}.${name}` as Id;
 
         if (registry.has(id)) {
             throw new Error(`A transform with id '${name}' is already registered. Please pick a unique identifier for your transforms and/or register them only once. This is to ensure that transforms can be serialized and replayed.`);
@@ -90,6 +95,7 @@ export namespace Transformer {
 
         const t: Transformer<A, B, P> = {
             apply(params, props) { return Transform.create<A, B, P>(t as any, params, props); },
+            namespace,
             id,
             definition
         };

src/mol-state/transformer/controller.ts

@@ -1,7 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-// TODO: relactive transformer params controller

src/mol-state/transformer/manager.ts

@@ -1,7 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-// TODO: index for registered transformers

src/mol-state/tree.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ */
+
+import { Transform } from './tree/transform';
+import { ImmutableTree } from './util/immutable-tree';
+import { Transformer } from './transformer';
+import { StateObject } from './object';
+
+interface StateTree extends ImmutableTree<Transform> { }
+
+namespace StateTree {
+    export interface Transient extends ImmutableTree.Transient<Transform> { }
+
+    function _getRef(t: Transform) { return t.ref; }
+
+    export function create() {
+        return ImmutableTree.create<Transform>(Transform.createRoot('<:root:>'), _getRef);
+    }
+
+    export function updateParams<T extends Transformer = Transformer>(tree: StateTree, ref: Transform.Ref, params: Transformer.Params<T>): StateTree {
+        const t = tree.nodes.get(ref)!.value;
+        const newTransform = Transform.updateParams(t, params);
+        const newTree = ImmutableTree.asTransient(tree);
+        newTree.setValue(ref, newTransform);
+        return newTree.asImmutable();
+    }
+
+    export function toJSON(tree: StateTree) {
+        return ImmutableTree.toJSON(tree, Transform.toJSON);
+    }
+
+    export function fromJSON(data: any): StateTree {
+        return ImmutableTree.fromJSON(data, _getRef, Transform.fromJSON);
+    }
+
+    export interface Builder {
+        getTree(): StateTree
+    }
+
+    export function build(tree: StateTree) {
+        return new Builder.Root(tree);
+    }
+
+    export namespace Builder {
+        interface State {
+            tree: StateTree.Transient
+        }
+
+        export class Root implements Builder {
+            private state: State;
+            to<A extends StateObject>(ref: Transform.Ref) { return new To<A>(this.state, ref); }
+            toRoot<A extends StateObject>() { return new To<A>(this.state, this.state.tree.rootRef as any); }
+            delete(ref: Transform.Ref) { this.state.tree.remove(ref); return this; }
+            getTree(): StateTree { return this.state.tree.asImmutable(); }
+            constructor(tree: StateTree) { this.state = { tree: ImmutableTree.asTransient(tree) } }
+        }
+
+        export class To<A extends StateObject> implements Builder {
+            apply<T extends Transformer<A, any, any>>(tr: T, params?: Transformer.Params<T>, props?: Partial<Transform.Props>): To<Transformer.To<T>> {
+                const t = tr.apply(params, props);
+                this.state.tree.add(this.ref, t);
+                return new To(this.state, t.ref);
+            }
+
+            getTree(): StateTree { return this.state.tree.asImmutable(); }
+
+            constructor(private state: State, private ref: Transform.Ref) {
+                if (!this.state.tree.nodes.has(ref)) {
+                    throw new Error(`Could not find node '${ref}'.`);
+                }
+            }
+        }
+    }
+}
+
+export { StateTree }

src/mol-state/tree/action.ts

@@ -1,7 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-// TODO: tree actions: Add, Update, Delete; action queue

src/mol-state/tree/builder.ts

@@ -1,48 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { ImmutableTree } from '../util/immutable-tree';
-import { TransformTree } from './tree';
-import { StateObject } from '../object';
-import { Transform } from './transform';
-import { Transformer } from '../transformer';
-
-export interface StateTreeBuilder {
-    getTree(): TransformTree
-}
-
-export namespace StateTreeBuilder {
-    interface State {
-        tree: TransformTree.Transient
-    }
-
-    export function create(tree: TransformTree) {
-        return new Root(tree);
-    }
-
-    export class Root implements StateTreeBuilder {
-        private state: State;
-        //to<A extends StateObject>(ref: Transform.Ref) { return new To<A>(this.state, ref); }
-        to<A extends StateObject>(ref: Transform.Ref) { return new To<A>(this.state, ref); }
-        toRoot<A extends StateObject>() { return new To<A>(this.state, this.state.tree.rootRef as any); }
-        getTree(): TransformTree { return this.state.tree.asImmutable(); }
-        constructor(tree: TransformTree) { this.state = { tree: ImmutableTree.asTransient(tree) } }
-    }
-
-    export class To<A extends StateObject> implements StateTreeBuilder {
-        apply<T extends Transformer<A, any, any>>(tr: T, params?: Transformer.Params<T>, props?: Partial<Transform.Props>): To<Transformer.To<T>> {
-            const t = tr.apply(params, props);
-            this.state.tree.add(this.ref, t);
-            return new To(this.state, t.ref);
-        }
-
-        getTree(): TransformTree { return this.state.tree.asImmutable(); }
-
-        constructor(private state: State, private ref: Transform.Ref) {
-
-        }
-    }
-}

src/mol-state/tree/context.ts

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) 2018 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { EventDispatcher } from '../event/event';
-
-export interface TransformContext {
-    /** An event dispatcher for executing child tasks. */
-    dispatcher: EventDispatcher,
-
-    globalContext: any
-    // tree: ModelTree
-}