diff --git a/src/apps/basic-wrapper/index.ts b/src/apps/basic-wrapper/index.ts
index 8635c265cfd7892a9d851b4ba3d9928724cac056..ec4ed52e3ce2bc31bfb56da127e952ca6000f459 100644
--- a/src/apps/basic-wrapper/index.ts
+++ b/src/apps/basic-wrapper/index.ts
@@ -11,9 +11,9 @@ import { PluginCommands } from 'mol-plugin/command';
import { StateTransforms } from 'mol-plugin/state/transforms';
import { StructureRepresentation3DHelpers } from 'mol-plugin/state/transforms/representation';
import { Color } from 'mol-util/color';
-import { StateTreeBuilder } from 'mol-state/tree/builder';
import { PluginStateObject as PSO } from 'mol-plugin/state/objects';
import { AnimateModelIndex } from 'mol-plugin/state/animation/built-in';
+import { StateBuilder } from 'mol-state';
require('mol-plugin/skin/light.scss')
type SupportedFormats = 'cif' | 'pdb'
@@ -32,11 +32,11 @@ class BasicWrapper {
});
}
- private download(b: StateTreeBuilder.To<PSO.Root>, url: string) {
+ private download(b: StateBuilder.To<PSO.Root>, url: string) {
return b.apply(StateTransforms.Data.Download, { url, isBinary: false })
}
- private parse(b: StateTreeBuilder.To<PSO.Data.Binary | PSO.Data.String>, format: SupportedFormats, assemblyId: string) {
+ private parse(b: StateBuilder.To<PSO.Data.Binary | PSO.Data.String>, format: SupportedFormats, assemblyId: string) {
const parsed = format === 'cif'
? b.apply(StateTransforms.Data.ParseCif).apply(StateTransforms.Model.TrajectoryFromMmCif)
: b.apply(StateTransforms.Model.TrajectoryFromPDB);
@@ -46,7 +46,7 @@ class BasicWrapper {
.apply(StateTransforms.Model.StructureAssemblyFromModel, { id: assemblyId || 'deposited' }, { ref: 'asm' });
}
- private visual(visualRoot: StateTreeBuilder.To<PSO.Molecule.Structure>) {
+ private visual(visualRoot: StateBuilder.To<PSO.Molecule.Structure>) {
visualRoot.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-sequence' })
.apply(StateTransforms.Representation.StructureRepresentation3D,
StructureRepresentation3DHelpers.getDefaultParamsStatic(this.plugin, 'cartoon'));
@@ -74,7 +74,7 @@ class BasicWrapper {
if (state.select('asm').length > 0) loadType = 'update';
}
- let tree: StateTreeBuilder.Root;
+ let tree: StateBuilder.Root;
if (loadType === 'full') {
await PluginCommands.State.RemoveObject.dispatch(this.plugin, { state, ref: state.tree.root.ref });
tree = state.build();
diff --git a/src/apps/state-docs/index.ts b/src/apps/state-docs/index.ts
index b9db93eb963b47defc3f5ba6c4ad9d3835f4af48..1cd02da05e62fae0441d5f98c27f2bdf887a8bab 100644
--- a/src/apps/state-docs/index.ts
+++ b/src/apps/state-docs/index.ts
@@ -5,7 +5,7 @@
*/
import * as _ from 'mol-plugin/state/transforms'
-import { Transformer, StateObject } from 'mol-state';
+import { StateTransformer, StateObject } from 'mol-state';
import { StringBuilder } from 'mol-util';
import * as fs from 'fs';
import { paramsToMd } from './pd-to-md';
@@ -28,7 +28,7 @@ function typeToString(o: StateObject.Ctor[]) {
return o.map(o => o.name).join(' | ');
}
-function writeTransformer(t: Transformer) {
+function writeTransformer(t: StateTransformer) {
StringBuilder.write(builder, `## <a name="${t.id.replace('.', '-')}"></a>${t.id} :: ${typeToString(t.definition.from)} -> ${typeToString(t.definition.to)}`);
StringBuilder.newline(builder);
if (t.definition.display.description) {
@@ -52,7 +52,7 @@ function writeTransformer(t: Transformer) {
StringBuilder.newline(builder);
}
-const transformers = Transformer.getAll();
+const transformers = StateTransformer.getAll();
StringBuilder.write(builder, '# Mol* Plugin State Transformer Reference');
StringBuilder.newline(builder);
diff --git a/src/mol-plugin/behavior/behavior.ts b/src/mol-plugin/behavior/behavior.ts
index 4d764da26697e3d69b3422a2787baabfb1e802a9..f687f69d5626ffedd65aa097db2451974ec8e644 100644
--- a/src/mol-plugin/behavior/behavior.ts
+++ b/src/mol-plugin/behavior/behavior.ts
@@ -5,7 +5,7 @@
*/
import { PluginStateTransform, PluginStateObject } from '../state/objects';
-import { Transformer, Transform } from 'mol-state';
+import { StateTransformer, StateTransform } from 'mol-state';
import { Task } from 'mol-task';
import { PluginContext } from 'mol-plugin/context';
import { PluginCommand } from '../command';
@@ -16,7 +16,7 @@ import { shallowEqual } from 'mol-util';
export { PluginBehavior }
interface PluginBehavior<P = unknown> {
- register(ref: Transform.Ref): void,
+ register(ref: StateTransform.Ref): void,
unregister(): void,
/** Update params in place. Optionally return a promise if it depends on an async action. */
@@ -32,7 +32,7 @@ namespace PluginBehavior {
export interface CreateParams<P> {
name: string,
ctor: Ctor<P>,
- canAutoUpdate?: Transformer.Definition<Root, Behavior, P>['canAutoUpdate'],
+ canAutoUpdate?: StateTransformer.Definition<Root, Behavior, P>['canAutoUpdate'],
label?: (params: P) => { label: string, description?: string },
display: {
name: string,
@@ -56,9 +56,9 @@ namespace PluginBehavior {
},
update({ b, newParams }) {
return Task.create('Update Behavior', async () => {
- if (!b.data.update) return Transformer.UpdateResult.Unchanged;
+ if (!b.data.update) return StateTransformer.UpdateResult.Unchanged;
const updated = await b.data.update(newParams);
- return updated ? Transformer.UpdateResult.Updated : Transformer.UpdateResult.Unchanged;
+ return updated ? StateTransformer.UpdateResult.Updated : StateTransformer.UpdateResult.Unchanged;
})
},
canAutoUpdate: params.canAutoUpdate
diff --git a/src/mol-plugin/behavior/dynamic/animation.ts b/src/mol-plugin/behavior/dynamic/animation.ts
index 2b3a1cee14b172862acd3a79390ce0b660ef8c41..cdff329ad41bace7b6f717c0b5b34129846a4ef9 100644
--- a/src/mol-plugin/behavior/dynamic/animation.ts
+++ b/src/mol-plugin/behavior/dynamic/animation.ts
@@ -10,8 +10,7 @@ import { ParamDefinition as PD } from 'mol-util/param-definition'
import { degToRad } from 'mol-math/misc';
import { Mat4, Vec3 } from 'mol-math/linear-algebra';
import { PluginStateObject as SO, PluginStateObject } from '../../state/objects';
-import { StateSelection } from 'mol-state/state/selection';
-import { StateObjectCell, State } from 'mol-state';
+import { StateObjectCell, State, StateSelection } from 'mol-state';
import { StructureUnitTransforms } from 'mol-model/structure/structure/util/unit-transforms';
import { UUID } from 'mol-util';
diff --git a/src/mol-plugin/behavior/dynamic/labels.ts b/src/mol-plugin/behavior/dynamic/labels.ts
index 7b8ccd1ba92cb413457de3fe1e6ae15b85944084..42966e07ced097c087db3b72e62f1aebda93018e 100644
--- a/src/mol-plugin/behavior/dynamic/labels.ts
+++ b/src/mol-plugin/behavior/dynamic/labels.ts
@@ -9,8 +9,7 @@ import { PluginBehavior } from '../behavior';
import { ParamDefinition as PD } from 'mol-util/param-definition'
import { Mat4, Vec3 } from 'mol-math/linear-algebra';
import { PluginStateObject as SO, PluginStateObject } from '../../state/objects';
-import { StateSelection } from 'mol-state/state/selection';
-import { StateObjectCell, State } from 'mol-state';
+import { StateObjectCell, State, StateSelection } from 'mol-state';
import { RuntimeContext } from 'mol-task';
import { Shape } from 'mol-model/shape';
import { Text } from 'mol-geo/geometry/text/text';
diff --git a/src/mol-plugin/behavior/dynamic/representation.ts b/src/mol-plugin/behavior/dynamic/representation.ts
index b604e2142b3b7a1adacd02cf67cd9e8e2a529742..b5bcf3251c9d25b0e3836755aa70f95fe3077787 100644
--- a/src/mol-plugin/behavior/dynamic/representation.ts
+++ b/src/mol-plugin/behavior/dynamic/representation.ts
@@ -10,8 +10,7 @@ import { EmptyLoci, Loci } from 'mol-model/loci';
import { StructureUnitTransforms } from 'mol-model/structure/structure/util/unit-transforms';
import { PluginContext } from 'mol-plugin/context';
import { PluginStateObject } from 'mol-plugin/state/objects';
-import { StateObjectTracker } from 'mol-state';
-import { StateSelection } from 'mol-state/state/selection';
+import { StateObjectTracker, StateSelection } from 'mol-state';
import { labelFirst } from 'mol-theme/label';
import { ParamDefinition as PD } from 'mol-util/param-definition';
import { PluginBehavior } from '../behavior';
diff --git a/src/mol-plugin/behavior/static/state.ts b/src/mol-plugin/behavior/static/state.ts
index 74424b9d615f8e31c7a024c893258a09e3be287c..3275404c6908cac51f2df2b1060eb47a41e4eae5 100644
--- a/src/mol-plugin/behavior/static/state.ts
+++ b/src/mol-plugin/behavior/static/state.ts
@@ -6,7 +6,7 @@
import { PluginCommands } from '../../command';
import { PluginContext } from '../../context';
-import { StateTree, Transform, State } from 'mol-state';
+import { StateTree, StateTransform, State } from 'mol-state';
import { PluginStateSnapshotManager } from 'mol-plugin/state/snapshots';
import { PluginStateObject as SO, PluginStateObject } from '../../state/objects';
import { EmptyLoci, EveryLoci } from 'mol-model/loci';
@@ -60,7 +60,7 @@ export function ApplyAction(ctx: PluginContext) {
export function RemoveObject(ctx: PluginContext) {
PluginCommands.State.RemoveObject.subscribe(ctx, ({ state, ref }) => {
- const tree = state.tree.build().delete(ref).getTree();
+ const tree = state.build().delete(ref).getTree();
return ctx.runTask(state.updateTree(tree));
});
}
@@ -73,11 +73,11 @@ export function ToggleVisibility(ctx: PluginContext) {
PluginCommands.State.ToggleVisibility.subscribe(ctx, ({ state, ref }) => setVisibility(state, ref, !state.cellStates.get(ref).isHidden));
}
-function setVisibility(state: State, root: Transform.Ref, value: boolean) {
+function setVisibility(state: State, root: StateTransform.Ref, value: boolean) {
StateTree.doPreOrder(state.tree, state.transforms.get(root), { state, value }, setVisibilityVisitor);
}
-function setVisibilityVisitor(t: Transform, tree: StateTree, ctx: { state: State, value: boolean }) {
+function setVisibilityVisitor(t: StateTransform, tree: StateTree, ctx: { state: State, value: boolean }) {
ctx.state.updateCellState(t.ref, { isHidden: ctx.value });
}
diff --git a/src/mol-plugin/command.ts b/src/mol-plugin/command.ts
index 5e99045b27de4231d3ba30f5d2314216221d64b9..b46600218ecf730408185890bc79c9be7a50395f 100644
--- a/src/mol-plugin/command.ts
+++ b/src/mol-plugin/command.ts
@@ -6,8 +6,7 @@
import { Camera } from 'mol-canvas3d/camera';
import { PluginCommand } from './command/base';
-import { Transform, State } from 'mol-state';
-import { StateAction } from 'mol-state/action';
+import { StateTransform, State, StateAction } from 'mol-state';
import { Canvas3DProps } from 'mol-canvas3d/canvas3d';
import { PluginLayoutStateProps } from './layout';
@@ -15,16 +14,16 @@ export * from './command/base';
export const PluginCommands = {
State: {
- SetCurrentObject: PluginCommand<{ state: State, ref: Transform.Ref }>(),
- ApplyAction: PluginCommand<{ state: State, action: StateAction.Instance, ref?: Transform.Ref }>(),
+ SetCurrentObject: PluginCommand<{ state: State, ref: StateTransform.Ref }>(),
+ ApplyAction: PluginCommand<{ state: State, action: StateAction.Instance, ref?: StateTransform.Ref }>(),
Update: PluginCommand<{ state: State, tree: State.Tree | State.Builder, doNotLogTiming?: boolean }>(),
- RemoveObject: PluginCommand<{ state: State, ref: Transform.Ref }>(),
+ RemoveObject: PluginCommand<{ state: State, ref: StateTransform.Ref }>(),
- ToggleExpanded: PluginCommand<{ state: State, ref: Transform.Ref }>({ isImmediate: true }),
- ToggleVisibility: PluginCommand<{ state: State, ref: Transform.Ref }>({ isImmediate: true }),
- Highlight: PluginCommand<{ state: State, ref: Transform.Ref }>({ isImmediate: true }),
- ClearHighlight: PluginCommand<{ state: State, ref: Transform.Ref }>({ isImmediate: true }),
+ ToggleExpanded: PluginCommand<{ state: State, ref: StateTransform.Ref }>({ isImmediate: true }),
+ ToggleVisibility: PluginCommand<{ state: State, ref: StateTransform.Ref }>({ isImmediate: true }),
+ Highlight: PluginCommand<{ state: State, ref: StateTransform.Ref }>({ isImmediate: true }),
+ ClearHighlight: PluginCommand<{ state: State, ref: StateTransform.Ref }>({ isImmediate: true }),
Snapshots: {
Add: PluginCommand<{ name?: string, description?: string }>({ isImmediate: true }),
diff --git a/src/mol-plugin/context.ts b/src/mol-plugin/context.ts
index ceace631931c4377eaea83565f5b8d95ac96d8db..e7ebde9fab4834fcd79f1a0bbee3f404cbaf7924 100644
--- a/src/mol-plugin/context.ts
+++ b/src/mol-plugin/context.ts
@@ -8,7 +8,7 @@ import { Canvas3D } from 'mol-canvas3d/canvas3d';
import { EmptyLoci, Loci } from 'mol-model/loci';
import { Representation } from 'mol-repr/representation';
import { StructureRepresentationRegistry } from 'mol-repr/structure/registry';
-import { State, Transform, Transformer } from 'mol-state';
+import { State, StateTransform, StateTransformer } from 'mol-state';
import { Task } from 'mol-task';
import { ColorTheme } from 'mol-theme/color';
import { SizeTheme } from 'mol-theme/size';
@@ -144,12 +144,12 @@ export class PluginContext {
this.disposed = true;
}
- applyTransform(state: State, a: Transform.Ref, transformer: Transformer, params: any) {
- const tree = state.tree.build().to(a).apply(transformer, params);
+ applyTransform(state: State, a: StateTransform.Ref, transformer: StateTransformer, params: any) {
+ const tree = state.build().to(a).apply(transformer, params);
return PluginCommands.State.Update.dispatch(this, { state, tree });
}
- updateTransform(state: State, a: Transform.Ref, params: any) {
+ updateTransform(state: State, a: StateTransform.Ref, params: any) {
const tree = state.build().to(a).update(params);
return PluginCommands.State.Update.dispatch(this, { state, tree });
}
@@ -164,7 +164,7 @@ export class PluginContext {
}
private async initBehaviors() {
- const tree = this.state.behaviorState.tree.build();
+ const tree = this.state.behaviorState.build();
for (const b of this.spec.behaviors) {
tree.toRoot().apply(b.transformer, b.defaultParams, { ref: b.transformer.id });
diff --git a/src/mol-plugin/spec.ts b/src/mol-plugin/spec.ts
index 4c13c42c677060a31224063e7e088687bc791683..2bfb64ecabb86f3b97d3fbdf0a748c65cd0bfa7f 100644
--- a/src/mol-plugin/spec.ts
+++ b/src/mol-plugin/spec.ts
@@ -4,8 +4,7 @@
* @author David Sehnal <david.sehnal@gmail.com>
*/
-import { StateAction } from 'mol-state/action';
-import { Transformer } from 'mol-state';
+import { StateTransformer, StateAction } from 'mol-state';
import { StateTransformParameters } from './ui/state/common';
import { PluginLayoutStateProps } from './layout';
import { PluginStateAnimation } from './state/animation/model';
@@ -16,27 +15,27 @@ interface PluginSpec {
actions: PluginSpec.Action[],
behaviors: PluginSpec.Behavior[],
animations?: PluginStateAnimation[],
- customParamEditors?: [StateAction | Transformer, StateTransformParameters.Class][],
+ customParamEditors?: [StateAction | StateTransformer, StateTransformParameters.Class][],
initialLayout?: PluginLayoutStateProps
}
namespace PluginSpec {
export interface Action {
- action: StateAction | Transformer,
+ action: StateAction | StateTransformer,
customControl?: StateTransformParameters.Class,
autoUpdate?: boolean
}
- export function Action(action: StateAction | Transformer, params?: { customControl?: StateTransformParameters.Class, autoUpdate?: boolean }): Action {
+ export function Action(action: StateAction | StateTransformer, params?: { customControl?: StateTransformParameters.Class, autoUpdate?: boolean }): Action {
return { action, customControl: params && params.customControl, autoUpdate: params && params.autoUpdate };
}
export interface Behavior {
- transformer: Transformer,
+ transformer: StateTransformer,
defaultParams?: any
}
- export function Behavior<T extends Transformer>(transformer: T, defaultParams?: Transformer.Params<T>): Behavior {
+ export function Behavior<T extends StateTransformer>(transformer: T, defaultParams?: StateTransformer.Params<T>): Behavior {
return { transformer, defaultParams };
}
}
\ No newline at end of file
diff --git a/src/mol-plugin/state/actions/basic.ts b/src/mol-plugin/state/actions/basic.ts
index 7d9524fc170895eada48affc5a30c3e99cf0174d..d1779e6614806d62aed9483b8c179fb4f1ec9b7d 100644
--- a/src/mol-plugin/state/actions/basic.ts
+++ b/src/mol-plugin/state/actions/basic.ts
@@ -6,10 +6,7 @@
*/
import { PluginContext } from 'mol-plugin/context';
-import { StateTree, Transformer, StateObject, State } from 'mol-state';
-import { StateAction } from 'mol-state/action';
-import { StateSelection } from 'mol-state/state/selection';
-import { StateTreeBuilder } from 'mol-state/tree/builder';
+import { StateTree, StateTransformer, StateObject, State, StateBuilder, StateSelection, StateAction } from 'mol-state';
import { ParamDefinition as PD } from 'mol-util/param-definition';
import { PluginStateObject } from '../objects';
import { StateTransforms } from '../transforms';
@@ -59,7 +56,7 @@ const DownloadStructure = StateAction.build({
})(({ params, state }, ctx: PluginContext) => {
const b = state.build();
const src = params.source;
- let downloadParams: Transformer.Params<Download>;
+ let downloadParams: StateTransformer.Params<Download>;
switch (src.name) {
case 'url':
@@ -93,7 +90,7 @@ export const OpenStructure = StateAction.build({
return state.updateTree(createStructureTree(ctx, traj, false));
});
-function createModelTree(b: StateTreeBuilder.To<PluginStateObject.Data.Binary | PluginStateObject.Data.String>, format: 'pdb' | 'cif' = 'cif') {
+function createModelTree(b: StateBuilder.To<PluginStateObject.Data.Binary | PluginStateObject.Data.String>, format: 'pdb' | 'cif' = 'cif') {
const parsed = format === 'cif'
? b.apply(StateTransforms.Data.ParseCif).apply(StateTransforms.Model.TrajectoryFromMmCif)
: b.apply(StateTransforms.Model.TrajectoryFromPDB);
@@ -101,7 +98,7 @@ function createModelTree(b: StateTreeBuilder.To<PluginStateObject.Data.Binary |
return parsed.apply(StateTransforms.Model.ModelFromTrajectory, { modelIndex: 0 });
}
-function createStructureTree(ctx: PluginContext, b: StateTreeBuilder.To<PluginStateObject.Molecule.Model>, supportProps: boolean): StateTree {
+function createStructureTree(ctx: PluginContext, b: StateBuilder.To<PluginStateObject.Molecule.Model>, supportProps: boolean): StateTree {
let root = b;
if (supportProps) {
root = root.apply(StateTransforms.Model.CustomModelProperties);
@@ -112,7 +109,7 @@ function createStructureTree(ctx: PluginContext, b: StateTreeBuilder.To<PluginSt
return root.getTree();
}
-function complexRepresentation(ctx: PluginContext, root: StateTreeBuilder.To<PluginStateObject.Molecule.Structure>) {
+function complexRepresentation(ctx: PluginContext, root: StateBuilder.To<PluginStateObject.Molecule.Structure>) {
root.apply(StateTransforms.Model.StructureComplexElement, { type: 'atomic-sequence' })
.apply(StateTransforms.Representation.StructureRepresentation3D,
StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'cartoon'));
@@ -223,7 +220,7 @@ interface DataFormatProvider<D extends PluginStateObject.Data.Binary | PluginSta
description: string
fileExtensions: string[]
isApplicable(info: FileInfo, data: string | Uint8Array): boolean
- getDefaultBuilder(ctx: PluginContext, data: StateTreeBuilder.To<D>, state?: State): Task<void>
+ getDefaultBuilder(ctx: PluginContext, data: StateBuilder.To<D>, state?: State): Task<void>
}
const Ccp4Provider: DataFormatProvider<any> = {
@@ -233,7 +230,7 @@ const Ccp4Provider: DataFormatProvider<any> = {
isApplicable: (info: FileInfo, data: Uint8Array) => {
return info.ext === 'ccp4' || info.ext === 'mrc' || info.ext === 'map'
},
- getDefaultBuilder: (ctx: PluginContext, data: StateTreeBuilder.To<PluginStateObject.Data.Binary>, state: State) => {
+ getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary>, state: State) => {
return Task.create('CCP4/MRC/BRIX default builder', async taskCtx => {
const tree = data.apply(StateTransforms.Data.ParseCcp4)
.apply(StateTransforms.Model.VolumeFromCcp4)
@@ -250,7 +247,7 @@ const Dsn6Provider: DataFormatProvider<any> = {
isApplicable: (info: FileInfo, data: Uint8Array) => {
return info.ext === 'dsn6' || info.ext === 'brix'
},
- getDefaultBuilder: (ctx: PluginContext, data: StateTreeBuilder.To<PluginStateObject.Data.Binary>, state: State) => {
+ getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary>, state: State) => {
return Task.create('DSN6/BRIX default builder', async taskCtx => {
const tree = data.apply(StateTransforms.Data.ParseDsn6)
.apply(StateTransforms.Model.VolumeFromDsn6)
@@ -267,13 +264,13 @@ const DscifProvider: DataFormatProvider<any> = {
isApplicable: (info: FileInfo, data: Uint8Array) => {
return info.ext === 'cif'
},
- getDefaultBuilder: (ctx: PluginContext, data: StateTreeBuilder.To<PluginStateObject.Data.Binary>, state: State) => {
+ getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary>, state: State) => {
return Task.create('DensityServer CIF default builder', async taskCtx => {
const cifBuilder = data.apply(StateTransforms.Data.ParseCif)
const cifStateObject = await state.updateTree(cifBuilder).runInContext(taskCtx)
const b = state.build().to(cifBuilder.ref);
const blocks = cifStateObject.data.blocks.slice(1); // zero block contains query meta-data
- let tree: StateTreeBuilder.To<any>
+ let tree: StateBuilder.To<any>
if (blocks.length === 1) {
tree = b
.apply(StateTransforms.Model.VolumeFromDensityServerCif, { blockHeader: blocks[0].header })
@@ -324,7 +321,7 @@ export const OpenVolume = StateAction.build({
const data = state.build().toRoot().apply(StateTransforms.Data.ReadFile, { file: params.file, isBinary: params.isBinary });
const dataStateObject = await state.updateTree(data).runInContext(taskCtx);
- // Alternative for more complex states where the builder is not a simple StateTreeBuilder.To<>:
+ // Alternative for more complex states where the builder is not a simple StateBuilder.To<>:
/*
const dataRef = dataTree.ref;
await state.updateTree(dataTree).runInContext(taskCtx);
@@ -380,7 +377,7 @@ const DownloadDensity = StateAction.build({
}
})(({ params, state }, ctx: PluginContext) => Task.create('Download Density', async taskCtx => {
const src = params.source;
- let downloadParams: Transformer.Params<Download>;
+ let downloadParams: StateTransformer.Params<Download>;
let provider: DataFormatProvider<any>
switch (src.name) {
diff --git a/src/mol-plugin/state/animation/built-in.ts b/src/mol-plugin/state/animation/built-in.ts
index d8f3b054feb017bec2c805531812832e41fe8054..2902a995bbf036a06390224cca243883791c5421 100644
--- a/src/mol-plugin/state/animation/built-in.ts
+++ b/src/mol-plugin/state/animation/built-in.ts
@@ -7,7 +7,7 @@
import { PluginStateAnimation } from './model';
import { PluginStateObject } from '../objects';
import { StateTransforms } from '../transforms';
-import { StateSelection } from 'mol-state/state/selection';
+import { StateSelection } from 'mol-state';
import { PluginCommands } from 'mol-plugin/command';
import { ParamDefinition as PD } from 'mol-util/param-definition';
diff --git a/src/mol-plugin/state/objects.ts b/src/mol-plugin/state/objects.ts
index 519ba1e03cfb9dc57bcff0a83670ea88b1a7bb54..94b9d78a6f5aa1c096c385d09010ef7e065d6b39 100644
--- a/src/mol-plugin/state/objects.ts
+++ b/src/mol-plugin/state/objects.ts
@@ -12,7 +12,7 @@ import { PluginBehavior } from 'mol-plugin/behavior/behavior';
import { Representation } from 'mol-repr/representation';
import { StructureRepresentation } from 'mol-repr/structure/representation';
import { VolumeRepresentation } from 'mol-repr/volume/representation';
-import { StateObject, Transformer } from 'mol-state';
+import { StateObject, StateTransformer } from 'mol-state';
import { Ccp4File } from 'mol-io/reader/ccp4/schema';
import { Dsn6File } from 'mol-io/reader/dsn6/schema';
@@ -77,6 +77,6 @@ export namespace PluginStateObject {
}
export namespace PluginStateTransform {
- export const CreateBuiltIn = Transformer.factory('ms-plugin');
- export const BuiltIn = Transformer.builderFactory('ms-plugin');
+ export const CreateBuiltIn = StateTransformer.factory('ms-plugin');
+ export const BuiltIn = StateTransformer.builderFactory('ms-plugin');
}
\ No newline at end of file
diff --git a/src/mol-plugin/state/transforms/data.ts b/src/mol-plugin/state/transforms/data.ts
index 59ed1b3a0d9e8e3eb3fb6fb615a4a3bfbb18b017..4733c0dc642176f04d659ee17f33235295c00533 100644
--- a/src/mol-plugin/state/transforms/data.ts
+++ b/src/mol-plugin/state/transforms/data.ts
@@ -11,7 +11,7 @@ import { Task } from 'mol-task';
import CIF from 'mol-io/reader/cif'
import { PluginContext } from 'mol-plugin/context';
import { ParamDefinition as PD } from 'mol-util/param-definition';
-import { Transformer } from 'mol-state';
+import { StateTransformer } from 'mol-state';
import { readFromFile } from 'mol-util/data-source';
import * as CCP4 from 'mol-io/reader/ccp4/parser'
import * as DSN6 from 'mol-io/reader/dsn6/parser'
@@ -38,12 +38,12 @@ const Download = PluginStateTransform.BuiltIn({
});
},
update({ oldParams, newParams, b }) {
- if (oldParams.url !== newParams.url || oldParams.isBinary !== newParams.isBinary) return Transformer.UpdateResult.Recreate;
+ if (oldParams.url !== newParams.url || oldParams.isBinary !== newParams.isBinary) return StateTransformer.UpdateResult.Recreate;
if (oldParams.label !== newParams.label) {
(b.label as string) = newParams.label || newParams.url;
- return Transformer.UpdateResult.Updated;
+ return StateTransformer.UpdateResult.Updated;
}
- return Transformer.UpdateResult.Unchanged;
+ return StateTransformer.UpdateResult.Unchanged;
}
});
@@ -71,9 +71,9 @@ const ReadFile = PluginStateTransform.BuiltIn({
update({ oldParams, newParams, b }) {
if (oldParams.label !== newParams.label) {
(b.label as string) = newParams.label || oldParams.file.name;
- return Transformer.UpdateResult.Updated;
+ return StateTransformer.UpdateResult.Updated;
}
- return Transformer.UpdateResult.Unchanged;
+ return StateTransformer.UpdateResult.Unchanged;
},
isSerializable: () => ({ isSerializable: false, reason: 'Cannot serialize user loaded files.' })
});
diff --git a/src/mol-plugin/state/transforms/representation.ts b/src/mol-plugin/state/transforms/representation.ts
index 7e0e17acdba9b3e5c75dd093b97cad7f8ec113ff..9bf811edd3bafa994bdede7ee9d635114243d867 100644
--- a/src/mol-plugin/state/transforms/representation.ts
+++ b/src/mol-plugin/state/transforms/representation.ts
@@ -5,7 +5,7 @@
* @author Alexander Rose <alexander.rose@weirdbyte.de>
*/
-import { Transformer } from 'mol-state';
+import { StateTransformer } from 'mol-state';
import { Task } from 'mol-task';
import { PluginStateTransform } from '../objects';
import { PluginStateObject as SO } from '../objects';
@@ -23,7 +23,7 @@ import { BuiltInColorThemeName, ColorTheme } from 'mol-theme/color';
import { BuiltInSizeThemeName, SizeTheme } from 'mol-theme/size';
export namespace StructureRepresentation3DHelpers {
- export function getDefaultParams(ctx: PluginContext, name: BuiltInStructureRepresentationsName, structure: Structure, structureParams?: Partial<PD.Values<StructureParams>>): Transformer.Params<StructureRepresentation3D> {
+ export function getDefaultParams(ctx: PluginContext, name: BuiltInStructureRepresentationsName, structure: Structure, structureParams?: Partial<PD.Values<StructureParams>>): StateTransformer.Params<StructureRepresentation3D> {
const type = ctx.structureRepresentation.registry.get(name);
const themeDataCtx = { structure };
@@ -37,7 +37,7 @@ export namespace StructureRepresentation3DHelpers {
})
}
- export function getDefaultParamsStatic(ctx: PluginContext, name: BuiltInStructureRepresentationsName, structureParams?: Partial<PD.Values<StructureParams>>): Transformer.Params<StructureRepresentation3D> {
+ export function getDefaultParamsStatic(ctx: PluginContext, name: BuiltInStructureRepresentationsName, structureParams?: Partial<PD.Values<StructureParams>>): StateTransformer.Params<StructureRepresentation3D> {
const type = ctx.structureRepresentation.registry.get(name);
const colorParams = ctx.structureRepresentation.themeCtx.colorThemeRegistry.get(type.defaultColorTheme).defaultValues;
const sizeParams = ctx.structureRepresentation.themeCtx.sizeThemeRegistry.get(type.defaultSizeTheme).defaultValues
@@ -114,11 +114,11 @@ const StructureRepresentation3D = PluginStateTransform.BuiltIn({
},
update({ a, b, oldParams, newParams }, plugin: PluginContext) {
return Task.create('Structure Representation', async ctx => {
- if (newParams.type.name !== oldParams.type.name) return Transformer.UpdateResult.Recreate;
+ if (newParams.type.name !== oldParams.type.name) return StateTransformer.UpdateResult.Recreate;
const props = { ...b.data.props, ...newParams.type.params }
b.data.setTheme(createTheme(plugin.structureRepresentation.themeCtx, { structure: a.data }, newParams))
await b.data.createOrUpdate(props, a.data).runInContext(ctx);
- return Transformer.UpdateResult.Updated;
+ return StateTransformer.UpdateResult.Updated;
});
}
});
@@ -142,7 +142,7 @@ const ExplodeStructureRepresentation3D = PluginStateTransform.BuiltIn({
return Task.create('Update Explosion', async () => {
const updated = await b.data.update(newParams);
b.label = `Explosion T = ${newParams.t.toFixed(2)}`;
- return updated ? Transformer.UpdateResult.Updated : Transformer.UpdateResult.Unchanged;
+ return updated ? StateTransformer.UpdateResult.Updated : StateTransformer.UpdateResult.Unchanged;
});
}
});
@@ -150,7 +150,7 @@ const ExplodeStructureRepresentation3D = PluginStateTransform.BuiltIn({
//
export namespace VolumeRepresentation3DHelpers {
- export function getDefaultParams(ctx: PluginContext, name: BuiltInVolumeRepresentationsName, volume: VolumeData, volumeParams?: Partial<PD.Values<VolumeParams>>): Transformer.Params<VolumeRepresentation3D> {
+ export function getDefaultParams(ctx: PluginContext, name: BuiltInVolumeRepresentationsName, volume: VolumeData, volumeParams?: Partial<PD.Values<VolumeParams>>): StateTransformer.Params<VolumeRepresentation3D> {
const type = ctx.volumeRepresentation.registry.get(name);
const themeDataCtx = { volume };
@@ -164,7 +164,7 @@ export namespace VolumeRepresentation3DHelpers {
})
}
- export function getDefaultParamsStatic(ctx: PluginContext, name: BuiltInVolumeRepresentationsName, volumeParams?: Partial<PD.Values<PD.Params>>, colorName?: BuiltInColorThemeName, colorParams?: Partial<ColorTheme.Props>, sizeName?: BuiltInSizeThemeName, sizeParams?: Partial<SizeTheme.Props>): Transformer.Params<VolumeRepresentation3D> {
+ export function getDefaultParamsStatic(ctx: PluginContext, name: BuiltInVolumeRepresentationsName, volumeParams?: Partial<PD.Values<PD.Params>>, colorName?: BuiltInColorThemeName, colorParams?: Partial<ColorTheme.Props>, sizeName?: BuiltInSizeThemeName, sizeParams?: Partial<SizeTheme.Props>): StateTransformer.Params<VolumeRepresentation3D> {
const type = ctx.volumeRepresentation.registry.get(name);
const colorType = ctx.volumeRepresentation.themeCtx.colorThemeRegistry.get(colorName || type.defaultColorTheme);
const sizeType = ctx.volumeRepresentation.themeCtx.sizeThemeRegistry.get(sizeName || type.defaultSizeTheme);
@@ -245,12 +245,12 @@ const VolumeRepresentation3D = PluginStateTransform.BuiltIn({
},
update({ a, b, oldParams, newParams }, plugin: PluginContext) {
return Task.create('Volume Representation', async ctx => {
- if (newParams.type.name !== oldParams.type.name) return Transformer.UpdateResult.Recreate;
+ if (newParams.type.name !== oldParams.type.name) return StateTransformer.UpdateResult.Recreate;
const props = { ...b.data.props, ...newParams.type.params }
b.data.setTheme(createTheme(plugin.volumeRepresentation.themeCtx, { volume: a.data }, newParams))
await b.data.createOrUpdate(props, a.data).runInContext(ctx);
b.description = VolumeRepresentation3DHelpers.getDescription(props)
- return Transformer.UpdateResult.Updated;
+ return StateTransformer.UpdateResult.Updated;
});
}
});
\ No newline at end of file
diff --git a/src/mol-plugin/ui/state/apply-action.tsx b/src/mol-plugin/ui/state/apply-action.tsx
index c82faeee8d7ce946b1dff0ddb087fb05382520f8..702a5cfc7025694fd89cde0304ab9c1b186cc1fe 100644
--- a/src/mol-plugin/ui/state/apply-action.tsx
+++ b/src/mol-plugin/ui/state/apply-action.tsx
@@ -6,8 +6,7 @@
import { PluginCommands } from 'mol-plugin/command';
import { PluginContext } from 'mol-plugin/context';
-import { State, Transform } from 'mol-state';
-import { StateAction } from 'mol-state/action';
+import { State, StateTransform, StateAction } from 'mol-state';
import { memoizeLatest } from 'mol-util/memoize';
import { StateTransformParameters, TransformContolBase } from './common';
import { ParamDefinition as PD } from 'mol-util/param-definition';
@@ -17,13 +16,13 @@ export { ApplyActionContol };
namespace ApplyActionContol {
export interface Props {
plugin: PluginContext,
- nodeRef: Transform.Ref,
+ nodeRef: StateTransform.Ref,
state: State,
action: StateAction
}
export interface ComponentState {
- ref: Transform.Ref,
+ ref: StateTransform.Ref,
version: string,
params: any,
error?: string,
@@ -48,7 +47,7 @@ class ApplyActionContol extends TransformContolBase<ApplyActionContol.Props, App
applyText() { return 'Apply'; }
isUpdate() { return false; }
- private _getInfo = memoizeLatest((t: Transform.Ref, v: string) => StateTransformParameters.infoFromAction(this.plugin, this.props.state, this.props.action, this.props.nodeRef));
+ private _getInfo = memoizeLatest((t: StateTransform.Ref, v: string) => StateTransformParameters.infoFromAction(this.plugin, this.props.state, this.props.action, this.props.nodeRef));
state = { ref: this.props.nodeRef, version: this.props.state.transforms.get(this.props.nodeRef).version, error: void 0, isInitial: true, params: this.getInfo().initialValues, busy: false };
diff --git a/src/mol-plugin/ui/state/common.tsx b/src/mol-plugin/ui/state/common.tsx
index b6570cbafc1cff2fbbe78c3fc2b7a3b9003a5e90..22b48453342b8f8ae75b780778284cae86d8ebc8 100644
--- a/src/mol-plugin/ui/state/common.tsx
+++ b/src/mol-plugin/ui/state/common.tsx
@@ -4,11 +4,10 @@
* @author David Sehnal <david.sehnal@gmail.com>
*/
-import { State, Transform, Transformer } from 'mol-state';
+import { State, StateTransform, StateTransformer, StateAction } from 'mol-state';
import * as React from 'react';
import { PurePluginUIComponent } from '../base';
import { ParameterControls, ParamOnChange } from '../controls/parameters';
-import { StateAction } from 'mol-state/action';
import { PluginContext } from 'mol-plugin/context';
import { ParamDefinition as PD } from 'mol-util/param-definition';
import { Subject } from 'rxjs';
@@ -61,7 +60,7 @@ namespace StateTransformParameters {
return true;
}
- export function infoFromAction(plugin: PluginContext, state: State, action: StateAction, nodeRef: Transform.Ref): Props['info'] {
+ export function infoFromAction(plugin: PluginContext, state: State, action: StateAction, nodeRef: StateTransform.Ref): Props['info'] {
const source = state.cells.get(nodeRef)!.obj!;
const params = action.definition.params ? action.definition.params(source, plugin) : { };
const initialValues = PD.getDefaultValues(params);
@@ -72,7 +71,7 @@ namespace StateTransformParameters {
};
}
- export function infoFromTransform(plugin: PluginContext, state: State, transform: Transform): Props['info'] {
+ export function infoFromTransform(plugin: PluginContext, state: State, transform: StateTransform): Props['info'] {
const cell = state.cells.get(transform.ref)!;
// const source: StateObjectCell | undefined = (cell.sourceRef && state.cells.get(cell.sourceRef)!) || void 0;
// const create = transform.transformer.definition.params;
@@ -100,7 +99,7 @@ namespace TransformContolBase {
abstract class TransformContolBase<P, S extends TransformContolBase.ControlState> extends PurePluginUIComponent<P, S> {
abstract applyAction(): Promise<void>;
abstract getInfo(): StateTransformParameters.Props['info'];
- abstract getHeader(): Transformer.Definition['display'];
+ abstract getHeader(): StateTransformer.Definition['display'];
abstract canApply(): boolean;
abstract getTransformerId(): string;
abstract canAutoApply(newParams: any): boolean;
diff --git a/src/mol-plugin/ui/state/update-transform.tsx b/src/mol-plugin/ui/state/update-transform.tsx
index ceff41e16f33a7debcd7edb87bb8693c79a58ff6..e60eae0662b930d04b7aa48b1b71d39e05a05d07 100644
--- a/src/mol-plugin/ui/state/update-transform.tsx
+++ b/src/mol-plugin/ui/state/update-transform.tsx
@@ -4,7 +4,7 @@
* @author David Sehnal <david.sehnal@gmail.com>
*/
-import { State, Transform } from 'mol-state';
+import { State, StateTransform } from 'mol-state';
import { memoizeLatest } from 'mol-util/memoize';
import { StateTransformParameters, TransformContolBase } from './common';
@@ -12,12 +12,12 @@ export { UpdateTransformContol };
namespace UpdateTransformContol {
export interface Props {
- transform: Transform,
+ transform: StateTransform,
state: State
}
export interface ComponentState {
- transform: Transform,
+ transform: StateTransform,
params: any,
error?: string,
busy: boolean,
@@ -46,7 +46,7 @@ class UpdateTransformContol extends TransformContolBase<UpdateTransformContol.Pr
return autoUpdate({ a: cell.obj!, b: parentCell.obj!, oldParams: this.getInfo().initialValues, newParams }, this.plugin);
}
- private _getInfo = memoizeLatest((t: Transform) => StateTransformParameters.infoFromTransform(this.plugin, this.props.state, this.props.transform));
+ private _getInfo = memoizeLatest((t: StateTransform) => StateTransformParameters.infoFromTransform(this.plugin, this.props.state, this.props.transform));
state: UpdateTransformContol.ComponentState = { transform: this.props.transform, error: void 0, isInitial: true, params: this.getInfo().initialValues, busy: false };
diff --git a/src/mol-state/action.ts b/src/mol-state/action.ts
index 53b41b53b66b1727944f135ebdb4baf9176350be..08de52da3adb116dde154358e8e738c871136f57 100644
--- a/src/mol-state/action.ts
+++ b/src/mol-state/action.ts
@@ -9,7 +9,7 @@ import { UUID } from 'mol-util';
import { ParamDefinition as PD } from 'mol-util/param-definition';
import { StateObject, StateObjectCell } from './object';
import { State } from './state';
-import { Transformer } from './transformer';
+import { StateTransformer } from './transformer';
export { StateAction };
@@ -63,12 +63,12 @@ namespace StateAction {
return action;
}
- export function fromTransformer<T extends Transformer>(transformer: T) {
+ export function fromTransformer<T extends StateTransformer>(transformer: T) {
const def = transformer.definition;
- return create<Transformer.From<T>, void, Transformer.Params<T>>({
+ return create<StateTransformer.From<T>, void, StateTransformer.Params<T>>({
from: def.from,
display: def.display,
- params: def.params as Transformer.Definition<Transformer.From<T>, any, Transformer.Params<T>>['params'],
+ params: def.params as StateTransformer.Definition<StateTransformer.From<T>, any, StateTransformer.Params<T>>['params'],
run({ cell, state, params }) {
const tree = state.build().to(cell.transform.ref).apply(transformer, params);
return state.updateTree(tree) as Task<void>;
diff --git a/src/mol-state/action/manager.ts b/src/mol-state/action/manager.ts
index 4e489df48ccf19d884881f97fd7152a730062276..1fb97cab32737e5a2608b8fe621ab8cfbb8e2163 100644
--- a/src/mol-state/action/manager.ts
+++ b/src/mol-state/action/manager.ts
@@ -4,9 +4,9 @@
* @author David Sehnal <david.sehnal@gmail.com>
*/
-import { StateAction } from 'mol-state/action';
+import { StateAction } from '../action';
import { StateObject } from '../object';
-import { Transformer } from 'mol-state/transformer';
+import { StateTransformer } from '../transformer';
export { StateActionManager }
@@ -14,8 +14,8 @@ class StateActionManager {
private actions: Map<StateAction['id'], StateAction> = new Map();
private fromTypeIndex = new Map<StateObject.Type, StateAction[]>();
- add(actionOrTransformer: StateAction | Transformer) {
- const action = Transformer.is(actionOrTransformer) ? actionOrTransformer.toAction() : actionOrTransformer;
+ add(actionOrTransformer: StateAction | StateTransformer) {
+ const action = StateTransformer.is(actionOrTransformer) ? actionOrTransformer.toAction() : actionOrTransformer;
if (this.actions.has(action.id)) return this;
diff --git a/src/mol-state/index.ts b/src/mol-state/index.ts
index 8ef37d2fd8463422cf850a1f5aafb69b448ac16c..5d8d630f6180271f2aa218fb35b5d4f391fdc3b9 100644
--- a/src/mol-state/index.ts
+++ b/src/mol-state/index.ts
@@ -5,7 +5,10 @@
*/
export * from './object'
+export * from './tree'
export * from './state'
+export * from './state/builder'
+export * from './state/selection'
export * from './transformer'
-export * from './tree'
-export * from './transform'
\ No newline at end of file
+export * from './transform'
+export * from './action'
\ No newline at end of file
diff --git a/src/mol-state/object.ts b/src/mol-state/object.ts
index 857d3249f5ea0cda44ad9f39f4d1cbf63e014d53..93177ad2ed4639fe005826d8647353d7eda58a10 100644
--- a/src/mol-state/object.ts
+++ b/src/mol-state/object.ts
@@ -5,10 +5,10 @@
*/
import { UUID } from 'mol-util';
-import { Transform } from './transform';
+import { StateTransform } from './transform';
import { ParamDefinition } from 'mol-util/param-definition';
import { State } from './state';
-import { StateSelection } from './state/selection';
+import { StateSelection } from 'mol-state';
export { StateObject, StateObjectCell }
@@ -54,10 +54,10 @@ namespace StateObject {
}
interface StateObjectCell<T = StateObject> {
- transform: Transform,
+ transform: StateTransform,
// Which object was used as a parent to create data in this cell
- sourceRef: Transform.Ref | undefined,
+ sourceRef: StateTransform.Ref | undefined,
status: StateObjectCell.Status,
diff --git a/src/mol-state/state.ts b/src/mol-state/state.ts
index 766daa3fb470882e8c853923eb25567fa2f9ce6f..9ac0289e5eea865653b981efc34e5e8de4fe91d8 100644
--- a/src/mol-state/state.ts
+++ b/src/mol-state/state.ts
@@ -6,12 +6,12 @@
import { StateObject, StateObjectCell } from './object';
import { StateTree } from './tree';
-import { Transform } from './transform';
-import { Transformer } from './transformer';
+import { StateTransform } from './transform';
+import { StateTransformer } from './transformer';
import { RuntimeContext, Task } from 'mol-task';
import { StateSelection } from './state/selection';
import { RxEventHelper } from 'mol-util/rx-event-helper';
-import { StateTreeBuilder } from './tree/builder';
+import { StateBuilder } from './state/builder';
import { StateAction } from './action';
import { StateActionManager } from './action/manager';
import { TransientTree } from './tree/transient';
@@ -25,7 +25,7 @@ class State {
private _tree: TransientTree = StateTree.createEmpty().asTransient();
protected errorFree = true;
- private transformCache = new Map<Transform.Ref, unknown>();
+ private transformCache = new Map<StateTransform.Ref, unknown>();
private ev = RxEventHelper.create();
@@ -34,7 +34,7 @@ class State {
cell: {
stateUpdated: this.ev<State.ObjectEvent & { cellState: StateObjectCell.State }>(),
created: this.ev<State.ObjectEvent & { cell: StateObjectCell }>(),
- removed: this.ev<State.ObjectEvent & { parent: Transform.Ref }>(),
+ removed: this.ev<State.ObjectEvent & { parent: StateTransform.Ref }>(),
},
object: {
updated: this.ev<State.ObjectEvent & { action: 'in-place' | 'recreate', obj: StateObject, oldObj?: StateObject }>(),
@@ -46,7 +46,7 @@ class State {
};
readonly behaviors = {
- currentObject: this.ev.behavior<State.ObjectEvent>({ state: this, ref: Transform.RootRef })
+ currentObject: this.ev.behavior<State.ObjectEvent>({ state: this, ref: StateTransform.RootRef })
};
readonly actions = new StateActionManager();
@@ -56,7 +56,7 @@ class State {
get cellStates() { return (this._tree as StateTree).cellStates; }
get current() { return this.behaviors.currentObject.value.ref; }
- build() { return this._tree.build(); }
+ build() { return new StateBuilder.Root(this._tree); }
readonly cells: State.Cells = new Map();
@@ -69,11 +69,11 @@ class State {
return this.updateTree(tree);
}
- setCurrent(ref: Transform.Ref) {
+ setCurrent(ref: StateTransform.Ref) {
this.behaviors.currentObject.next({ state: this, ref });
}
- updateCellState(ref: Transform.Ref, stateOrProvider: ((old: StateObjectCell.State) => Partial<StateObjectCell.State>) | Partial<StateObjectCell.State>) {
+ updateCellState(ref: StateTransform.Ref, stateOrProvider: ((old: StateObjectCell.State) => Partial<StateObjectCell.State>) | Partial<StateObjectCell.State>) {
const update = typeof stateOrProvider === 'function'
? stateOrProvider(this.tree.cellStates.get(ref))
: stateOrProvider;
@@ -109,7 +109,7 @@ class State {
* Creates a Task that applies the specified StateAction (i.e. must use run* on the result)
* If no ref is specified, apply to root.
*/
- applyAction<A extends StateAction>(action: A, params: StateAction.Params<A>, ref: Transform.Ref = Transform.RootRef): Task<void> {
+ applyAction<A extends StateAction>(action: A, params: StateAction.Params<A>, ref: StateTransform.Ref = StateTransform.RootRef): Task<void> {
return Task.create('Apply Action', ctx => {
const cell = this.cells.get(ref);
if (!cell) throw new Error(`'${ref}' does not exist.`);
@@ -122,19 +122,19 @@ class State {
/**
* Reconcialites the existing state tree with the new version.
*
- * If the tree is StateTreeBuilder.To<T>, the corresponding StateObject is returned by the task.
+ * If the tree is StateBuilder.To<T>, the corresponding StateObject is returned by the task.
* @param tree Tree instance or a tree builder instance
* @param doNotReportTiming Indicates whether to log timing of the individual transforms
*/
- updateTree<T extends StateObject>(tree: StateTree | StateTreeBuilder | StateTreeBuilder.To<T>, doNotLogTiming?: boolean): Task<T>
- updateTree(tree: StateTree | StateTreeBuilder, doNotLogTiming?: boolean): Task<void>
- updateTree(tree: StateTree | StateTreeBuilder, doNotLogTiming: boolean = false): Task<any> {
+ updateTree<T extends StateObject>(tree: StateTree | StateBuilder | StateBuilder.To<T>, doNotLogTiming?: boolean): Task<T>
+ updateTree(tree: StateTree | StateBuilder, doNotLogTiming?: boolean): Task<void>
+ updateTree(tree: StateTree | StateBuilder, doNotLogTiming: boolean = false): Task<any> {
return Task.create('Update Tree', async taskCtx => {
let updated = false;
try {
const ctx = this.updateTreeAndCreateCtx(tree, taskCtx, doNotLogTiming);
updated = await update(ctx);
- if (StateTreeBuilder.isTo(tree)) {
+ if (StateBuilder.isTo(tree)) {
const cell = this.select(tree.ref)[0];
return cell && cell.obj;
}
@@ -144,20 +144,20 @@ class State {
});
}
- private updateTreeAndCreateCtx(tree: StateTree | StateTreeBuilder, taskCtx: RuntimeContext, doNotLogTiming: boolean) {
- const _tree = (StateTreeBuilder.is(tree) ? tree.getTree() : tree).asTransient();
+ private updateTreeAndCreateCtx(tree: StateTree | StateBuilder, taskCtx: RuntimeContext, doNotLogTiming: boolean) {
+ const _tree = (StateBuilder.is(tree) ? tree.getTree() : tree).asTransient();
const oldTree = this._tree;
this._tree = _tree;
const ctx: UpdateContext = {
parent: this,
- editInfo: StateTreeBuilder.is(tree) ? tree.editInfo : void 0,
+ editInfo: StateBuilder.is(tree) ? tree.editInfo : void 0,
errorFree: this.errorFree,
taskCtx,
oldTree,
tree: _tree,
- cells: this.cells as Map<Transform.Ref, StateObjectCell>,
+ cells: this.cells as Map<StateTransform.Ref, StateObjectCell>,
transformCache: this.transformCache,
results: [],
@@ -178,7 +178,7 @@ class State {
const tree = this._tree;
const root = tree.root;
- (this.cells as Map<Transform.Ref, StateObjectCell>).set(root.ref, {
+ (this.cells as Map<StateTransform.Ref, StateObjectCell>).set(root.ref, {
transform: root,
sourceRef: void 0,
obj: rootObject,
@@ -195,10 +195,10 @@ class State {
}
namespace State {
- export type Cells = ReadonlyMap<Transform.Ref, StateObjectCell>
+ export type Cells = ReadonlyMap<StateTransform.Ref, StateObjectCell>
export type Tree = StateTree
- export type Builder = StateTreeBuilder
+ export type Builder = StateBuilder
export interface ObjectEvent {
state: State,
@@ -214,17 +214,17 @@ namespace State {
}
}
-type Ref = Transform.Ref
+type Ref = StateTransform.Ref
interface UpdateContext {
parent: State,
- editInfo: StateTreeBuilder.EditInfo | undefined
+ editInfo: StateBuilder.EditInfo | undefined
errorFree: boolean,
taskCtx: RuntimeContext,
oldTree: StateTree,
tree: TransientTree,
- cells: Map<Transform.Ref, StateObjectCell>,
+ cells: Map<StateTransform.Ref, StateObjectCell>,
transformCache: Map<Ref, unknown>,
results: UpdateNodeResult[],
@@ -241,7 +241,7 @@ async function update(ctx: UpdateContext) {
// if only a single node was added/updated, we can skip potentially expensive diffing
const fastTrack = !!(ctx.errorFree && ctx.editInfo && ctx.editInfo.count === 1 && ctx.editInfo.lastUpdate && ctx.editInfo.sourceTree === ctx.oldTree);
- let deletes: Transform.Ref[], deletedObjects: (StateObject | undefined)[] = [], roots: Transform.Ref[];
+ let deletes: StateTransform.Ref[], deletedObjects: (StateObject | undefined)[] = [], roots: StateTransform.Ref[];
if (fastTrack) {
deletes = [];
@@ -307,7 +307,7 @@ async function update(ctx: UpdateContext) {
await updateSubtree(ctx, root);
}
- let newCurrent: Transform.Ref | undefined = ctx.newCurrent;
+ let newCurrent: StateTransform.Ref | undefined = ctx.newCurrent;
// Raise object updated events
for (const update of ctx.results) {
if (update.action === 'created') {
@@ -340,13 +340,13 @@ async function update(ctx: UpdateContext) {
return deletes.length > 0 || roots.length > 0 || ctx.changed;
}
-function findUpdateRoots(cells: Map<Transform.Ref, StateObjectCell>, tree: StateTree) {
+function findUpdateRoots(cells: Map<StateTransform.Ref, StateObjectCell>, tree: StateTree) {
const findState = { roots: [] as Ref[], cells };
StateTree.doPreOrder(tree, tree.root, findState, findUpdateRootsVisitor);
return findState.roots;
}
-function findUpdateRootsVisitor(n: Transform, _: any, s: { roots: Ref[], cells: Map<Ref, StateObjectCell> }) {
+function findUpdateRootsVisitor(n: StateTransform, _: any, s: { roots: Ref[], cells: Map<Ref, StateObjectCell> }) {
const cell = s.cells.get(n.ref);
if (!cell || cell.transform.version !== n.version || cell.status === 'error') {
s.roots.push(n.ref);
@@ -358,7 +358,7 @@ function findUpdateRootsVisitor(n: Transform, _: any, s: { roots: Ref[], cells:
}
type FindDeletesCtx = { newTree: StateTree, cells: State.Cells, deletes: Ref[] }
-function checkDeleteVisitor(n: Transform, _: any, ctx: FindDeletesCtx) {
+function checkDeleteVisitor(n: StateTransform, _: any, ctx: FindDeletesCtx) {
if (!ctx.newTree.transforms.has(n.ref) && ctx.cells.has(n.ref)) ctx.deletes.push(n.ref);
}
function findDeletes(ctx: UpdateContext): Ref[] {
@@ -367,7 +367,7 @@ function findDeletes(ctx: UpdateContext): Ref[] {
return deleteCtx.deletes;
}
-function syncStatesVisitor(n: Transform, tree: StateTree, oldState: StateTree.CellStates) {
+function syncStatesVisitor(n: StateTransform, tree: StateTree, oldState: StateTree.CellStates) {
if (!oldState.has(n.ref)) return;
(tree as TransientTree).updateCellState(n.ref, oldState.get(n.ref));
}
@@ -383,7 +383,7 @@ function setCellStatus(ctx: UpdateContext, ref: Ref, status: StateObjectCell.Sta
if (changed) ctx.parent.events.cell.stateUpdated.next({ state: ctx.parent, ref, cellState: ctx.tree.cellStates.get(ref) });
}
-function initCellStatusVisitor(t: Transform, _: any, ctx: UpdateContext) {
+function initCellStatusVisitor(t: StateTransform, _: any, ctx: UpdateContext) {
ctx.cells.get(t.ref)!.transform = t;
setCellStatus(ctx, t.ref, 'pending');
}
@@ -395,7 +395,7 @@ function initCellStatus(ctx: UpdateContext, roots: Ref[]) {
}
type InitCellsCtx = { ctx: UpdateContext, added: StateObjectCell[] }
-function initCellsVisitor(transform: Transform, _: any, { ctx, added }: InitCellsCtx) {
+function initCellsVisitor(transform: StateTransform, _: any, { ctx, added }: InitCellsCtx) {
if (ctx.cells.has(transform.ref)) {
return;
}
@@ -425,7 +425,7 @@ function findNewCurrent(tree: StateTree, start: Ref, deletes: Ref[], cells: Map<
}
function _findNewCurrent(tree: StateTree, ref: Ref, deletes: Set<Ref>, cells: Map<Ref, StateObjectCell>): Ref {
- if (ref === Transform.RootRef) return ref;
+ if (ref === StateTransform.RootRef) return ref;
const node = tree.transforms.get(ref)!;
const siblings = tree.children.get(node.parent)!.values();
@@ -539,7 +539,7 @@ async function updateSubtree(ctx: UpdateContext, root: Ref) {
}
}
-function resolveParams(ctx: UpdateContext, transform: Transform, src: StateObject) {
+function resolveParams(ctx: UpdateContext, transform: StateTransform, src: StateObject) {
const prms = transform.transformer.definition.params;
const definition = prms ? prms(src, ctx.parent.globalContext) : {};
const values = transform.params ? transform.params : ParamDefinition.getDefaultValues(definition);
@@ -552,7 +552,7 @@ async function updateNode(ctx: UpdateContext, currentRef: Ref): Promise<UpdateNo
const transform = current.transform;
// special case for Root
- if (current.transform.ref === Transform.RootRef) {
+ if (current.transform.ref === StateTransform.RootRef) {
return { action: 'none' };
}
@@ -579,16 +579,16 @@ async function updateNode(ctx: UpdateContext, currentRef: Ref): Promise<UpdateNo
const updateKind = !!current.obj && current.obj !== StateObject.Null
? await updateObject(ctx, currentRef, transform.transformer, parent, current.obj!, oldParams, newParams)
- : Transformer.UpdateResult.Recreate;
+ : StateTransformer.UpdateResult.Recreate;
switch (updateKind) {
- case Transformer.UpdateResult.Recreate: {
+ case StateTransformer.UpdateResult.Recreate: {
const oldObj = current.obj;
const newObj = await createObject(ctx, currentRef, transform.transformer, parent, newParams);
current.obj = newObj;
return { ref: currentRef, action: 'replaced', oldObj, obj: newObj };
}
- case Transformer.UpdateResult.Updated:
+ case StateTransformer.UpdateResult.Updated:
return { ref: currentRef, action: 'updated', obj: current.obj! };
default:
return { action: 'none' };
@@ -601,15 +601,15 @@ function runTask<T>(t: T | Task<T>, ctx: RuntimeContext) {
return t as T;
}
-function createObject(ctx: UpdateContext, ref: Ref, transformer: Transformer, a: StateObject, params: any) {
+function createObject(ctx: UpdateContext, ref: Ref, transformer: StateTransformer, a: StateObject, params: any) {
const cache = Object.create(null);
ctx.transformCache.set(ref, cache);
return runTask(transformer.definition.apply({ a, params, cache }, ctx.parent.globalContext), ctx.taskCtx);
}
-async function updateObject(ctx: UpdateContext, ref: Ref, transformer: Transformer, a: StateObject, b: StateObject, oldParams: any, newParams: any) {
+async function updateObject(ctx: UpdateContext, ref: Ref, transformer: StateTransformer, a: StateObject, b: StateObject, oldParams: any, newParams: any) {
if (!transformer.definition.update) {
- return Transformer.UpdateResult.Recreate;
+ return StateTransformer.UpdateResult.Recreate;
}
let cache = ctx.transformCache.get(ref);
if (!cache) {
diff --git a/src/mol-state/tree/builder.ts b/src/mol-state/state/builder.ts
similarity index 56%
rename from src/mol-state/tree/builder.ts
rename to src/mol-state/state/builder.ts
index 0cd0faa0b36088c79de318bd233bdba057a07c59..57e266f55d30ba18361e2dd955137382169884ca 100644
--- a/src/mol-state/tree/builder.ts
+++ b/src/mol-state/state/builder.ts
@@ -4,24 +4,24 @@
* @author David Sehnal <david.sehnal@gmail.com>
*/
-import { StateTree } from './immutable';
-import { TransientTree } from './transient';
+import { StateTree } from '../tree/immutable';
+import { TransientTree } from '../tree/transient';
import { StateObject, StateObjectCell } from '../object';
-import { Transform } from '../transform';
-import { Transformer } from '../transformer';
+import { StateTransform } from '../transform';
+import { StateTransformer } from '../transformer';
-export { StateTreeBuilder }
+export { StateBuilder }
-interface StateTreeBuilder {
- readonly editInfo: StateTreeBuilder.EditInfo,
+interface StateBuilder {
+ readonly editInfo: StateBuilder.EditInfo,
getTree(): StateTree
}
-namespace StateTreeBuilder {
+namespace StateBuilder {
export interface EditInfo {
sourceTree: StateTree,
count: number,
- lastUpdate?: Transform.Ref
+ lastUpdate?: StateTransform.Ref
}
interface State {
@@ -29,21 +29,21 @@ namespace StateTreeBuilder {
editInfo: EditInfo
}
- export function is(obj: any): obj is StateTreeBuilder {
- return !!obj && typeof (obj as StateTreeBuilder).getTree === 'function';
+ export function is(obj: any): obj is StateBuilder {
+ return !!obj && typeof (obj as StateBuilder).getTree === 'function';
}
- export function isTo(obj: any): obj is StateTreeBuilder.To<any> {
- return !!obj && typeof (obj as StateTreeBuilder).getTree === 'function' && typeof (obj as StateTreeBuilder.To<any>).ref === 'string';
+ export function isTo(obj: any): obj is StateBuilder.To<any> {
+ return !!obj && typeof (obj as StateBuilder).getTree === 'function' && typeof (obj as StateBuilder.To<any>).ref === 'string';
}
- export class Root implements StateTreeBuilder {
+ export class Root implements StateBuilder {
private state: State;
get editInfo() { return this.state.editInfo; }
- to<A extends StateObject>(ref: Transform.Ref) { return new To<A>(this.state, ref, this); }
+ to<A extends StateObject>(ref: StateTransform.Ref) { return new To<A>(this.state, ref, this); }
toRoot<A extends StateObject>() { return new To<A>(this.state, this.state.tree.root.ref, this); }
- delete(ref: Transform.Ref) {
+ delete(ref: StateTransform.Ref) {
this.editInfo.count++;
this.state.tree.remove(ref);
return this;
@@ -52,16 +52,16 @@ namespace StateTreeBuilder {
constructor(tree: StateTree) { this.state = { tree: tree.asTransient(), editInfo: { sourceTree: tree, count: 0, lastUpdate: void 0 } } }
}
- export class To<A extends StateObject> implements StateTreeBuilder {
+ export class To<A extends StateObject> implements StateBuilder {
get editInfo() { return this.state.editInfo; }
- readonly ref: Transform.Ref;
+ readonly ref: StateTransform.Ref;
/**
* Apply the transformed to the parent node
* If no params are specified (params <- undefined), default params are lazily resolved.
*/
- apply<T extends Transformer<A, any, any>>(tr: T, params?: Transformer.Params<T>, options?: Partial<Transform.Options>, initialCellState?: Partial<StateObjectCell.State>): To<Transformer.To<T>> {
+ apply<T extends StateTransformer<A, any, any>>(tr: T, params?: StateTransformer.Params<T>, options?: Partial<StateTransform.Options>, initialCellState?: Partial<StateObjectCell.State>): To<StateTransformer.To<T>> {
const t = tr.apply(this.ref, params, options);
this.state.tree.add(t, initialCellState);
this.editInfo.count++;
@@ -69,9 +69,9 @@ namespace StateTreeBuilder {
return new To(this.state, t.ref, this.root);
}
- update<T extends Transformer<any, A, any>>(transformer: T, params: (old: Transformer.Params<T>) => Transformer.Params<T>): Root
+ update<T extends StateTransformer<any, A, any>>(transformer: T, params: (old: StateTransformer.Params<T>) => StateTransformer.Params<T>): Root
update(params: any): Root
- update<T extends Transformer<any, A, any>>(paramsOrTransformer: T, provider?: (old: Transformer.Params<T>) => Transformer.Params<T>) {
+ update<T extends StateTransformer<any, A, any>>(paramsOrTransformer: T, provider?: (old: StateTransformer.Params<T>) => StateTransformer.Params<T>) {
let params: any;
if (provider) {
const old = this.state.tree.transforms.get(this.ref)!;
@@ -88,13 +88,13 @@ namespace StateTreeBuilder {
return this.root;
}
- to<A extends StateObject>(ref: Transform.Ref) { return this.root.to<A>(ref); }
+ to<A extends StateObject>(ref: StateTransform.Ref) { return this.root.to<A>(ref); }
toRoot<A extends StateObject>() { return this.root.toRoot<A>(); }
- delete(ref: Transform.Ref) { return this.root.delete(ref); }
+ delete(ref: StateTransform.Ref) { return this.root.delete(ref); }
getTree(): StateTree { return this.state.tree.asImmutable(); }
- constructor(private state: State, ref: Transform.Ref, private root: Root) {
+ constructor(private state: State, ref: StateTransform.Ref, private root: Root) {
this.ref = ref;
if (!this.state.tree.transforms.has(ref)) {
throw new Error(`Could not find node '${ref}'.`);
diff --git a/src/mol-state/state/selection.ts b/src/mol-state/state/selection.ts
index d9aec37f87f11cff889c322832dd020e0c3b16dc..b70b4c8d19f817601030faa5d23ec96bd5c0fd10 100644
--- a/src/mol-state/state/selection.ts
+++ b/src/mol-state/state/selection.ts
@@ -7,7 +7,7 @@
import { StateObject, StateObjectCell } from '../object';
import { State } from '../state';
import { StateTree } from '../tree';
-import { Transform } from '../transform';
+import { StateTransform } from '../transform';
namespace StateSelection {
export type Selector = Query | Builder | string | StateObjectCell;
@@ -75,7 +75,7 @@ namespace StateSelection {
export namespace Generators {
export const root = build(() => (state: State) => [state.cells.get(state.tree.root.ref)!]);
- export function byRef(...refs: Transform.Ref[]) {
+ export function byRef(...refs: StateTransform.Ref[]) {
return build(() => (state: State) => {
const ret: StateObjectCell[] = [];
for (const ref of refs) {
@@ -97,7 +97,7 @@ namespace StateSelection {
});
}
- function _findRootsOfType(n: Transform, _: any, s: { type: StateObject.Type, roots: StateObjectCell[], cells: State.Cells }) {
+ function _findRootsOfType(n: StateTransform, _: any, s: { type: StateObject.Type, roots: StateObjectCell[], cells: State.Cells }) {
const cell = s.cells.get(n.ref);
if (cell && cell.obj && cell.obj.type === s.type) {
s.roots.push(cell);
@@ -196,7 +196,7 @@ namespace StateSelection {
registerModifier('parent', parent);
export function parent(b: Selector) { return unique(mapEntity(b, (n, s) => s.cells.get(s.tree.transforms.get(n.transform.ref)!.parent))); }
- export function findAncestorOfType(tree: StateTree, cells: State.Cells, root: Transform.Ref, types: StateObject.Ctor[]): StateObjectCell | undefined {
+ export function findAncestorOfType(tree: StateTree, cells: State.Cells, root: StateTransform.Ref, types: StateObject.Ctor[]): StateObjectCell | undefined {
let current = tree.transforms.get(root)!, len = types.length;
while (true) {
current = tree.transforms.get(current.parent)!;
@@ -206,13 +206,13 @@ namespace StateSelection {
for (let i = 0; i < len; i++) {
if (obj.type === types[i].type) return cells.get(current.ref);
}
- if (current.ref === Transform.RootRef) {
+ if (current.ref === StateTransform.RootRef) {
return void 0;
}
}
}
- export function findRootOfType(tree: StateTree, cells: State.Cells, root: Transform.Ref, types: StateObject.Ctor[]): StateObjectCell | undefined {
+ export function findRootOfType(tree: StateTree, cells: State.Cells, root: StateTransform.Ref, types: StateObject.Ctor[]): StateObjectCell | undefined {
let parent: StateObjectCell | undefined, _root = root;
while (true) {
const _parent = StateSelection.findAncestorOfType(tree, cells, _root, types);
diff --git a/src/mol-state/transform.ts b/src/mol-state/transform.ts
index dea70d4da12f4fa6ed617773dc26aa4bb13a331b..22794b34c2138aa0f97ef31f795c397e1ea5802f 100644
--- a/src/mol-state/transform.ts
+++ b/src/mol-state/transform.ts
@@ -5,19 +5,21 @@
*/
import { StateObject } from './object';
-import { Transformer } from './transformer';
+import { StateTransformer } from './transformer';
import { UUID } from 'mol-util';
-export interface Transform<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
+export { Transform as StateTransform }
+
+interface Transform<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
readonly parent: Transform.Ref,
- readonly transformer: Transformer<A, B, P>,
+ readonly transformer: StateTransformer<A, B, P>,
readonly props: Transform.Props,
readonly ref: Transform.Ref,
readonly params?: P,
readonly version: string
}
-export namespace Transform {
+namespace Transform {
export type Ref = string
export const RootRef = '-=root=-' as Ref;
@@ -25,7 +27,6 @@ export namespace Transform {
export interface Props {
tag?: string
isGhost?: boolean,
- isBinding?: boolean,
// determine if the corresponding cell can be deleted by the user.
isLocked?: boolean
}
@@ -35,7 +36,7 @@ export namespace Transform {
props?: Props
}
- export function create<A extends StateObject, B extends StateObject, P extends {} = {}>(parent: Ref, transformer: Transformer<A, B, P>, params?: P, options?: Options): Transform<A, B, P> {
+ export function create<A extends StateObject, B extends StateObject, P extends {} = {}>(parent: Ref, transformer: StateTransformer<A, B, P>, params?: P, options?: Options): Transform<A, B, P> {
const ref = options && options.ref ? options.ref : UUID.create22() as string as Ref;
return {
parent,
@@ -52,7 +53,7 @@ export namespace Transform {
}
export function createRoot(): Transform {
- return create(RootRef, Transformer.ROOT, {}, { ref: RootRef });
+ return create(RootRef, StateTransformer.ROOT, {}, { ref: RootRef });
}
export interface Serialized {
@@ -80,7 +81,7 @@ export namespace Transform {
}
export function fromJSON(t: Serialized): Transform {
- const transformer = Transformer.get(t.transformer);
+ const transformer = StateTransformer.get(t.transformer);
const pFromJson = transformer.definition.customSerialization
? transformer.definition.customSerialization.toJSON
: _id;
diff --git a/src/mol-state/transformer.ts b/src/mol-state/transformer.ts
index 3693eb5cae8aee0b7b20c2976c0dd9139727d7f5..b6eaa8c914016bb7ee900a552b8f38778666be46 100644
--- a/src/mol-state/transformer.ts
+++ b/src/mol-state/transformer.ts
@@ -6,20 +6,22 @@
import { Task } from 'mol-task';
import { StateObject, StateObjectCell } from './object';
-import { Transform } from './transform';
+import { StateTransform } from './transform';
import { ParamDefinition as PD } from 'mol-util/param-definition';
import { StateAction } from './action';
import { capitalize } from 'mol-util/string';
-export interface Transformer<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
- apply(parent: Transform.Ref, params?: P, props?: Partial<Transform.Options>): Transform<A, B, P>,
+export { Transformer as StateTransformer }
+
+interface Transformer<A extends StateObject = StateObject, B extends StateObject = StateObject, P extends {} = {}> {
+ apply(parent: StateTransform.Ref, params?: P, props?: Partial<StateTransform.Options>): StateTransform<A, B, P>,
toAction(): StateAction<A, void, P>,
readonly namespace: string,
readonly id: Transformer.Id,
readonly definition: Transformer.Definition<A, B, P>
}
-export namespace Transformer {
+namespace Transformer {
export type Id = string & { '@type': 'transformer-id' }
export type Params<T extends Transformer<any, any, any>> = T extends Transformer<any, any, infer P> ? P : unknown;
export type From<T extends Transformer<any, any, any>> = T extends Transformer<infer A, any, any> ? A : unknown;
@@ -131,7 +133,7 @@ export namespace Transformer {
}
const t: Transformer<A, B, P> = {
- apply(parent, params, props) { return Transform.create<A, B, P>(parent, t, params, props); },
+ apply(parent, params, props) { return StateTransform.create<A, B, P>(parent, t, params, props); },
toAction() { return StateAction.fromTransformer(t); },
namespace,
id,
diff --git a/src/mol-state/tree/immutable.ts b/src/mol-state/tree/immutable.ts
index 8d77221c278c662fd785604d64a8e3093084d3a6..8cb9ed73a89771e48c6dc88d90d4410e1cd18cfa 100644
--- a/src/mol-state/tree/immutable.ts
+++ b/src/mol-state/tree/immutable.ts
@@ -5,9 +5,8 @@
*/
import { Map as ImmutableMap, OrderedSet } from 'immutable';
-import { Transform } from '../transform';
+import { StateTransform } from '../transform';
import { TransientTree } from './transient';
-import { StateTreeBuilder } from './builder';
import { StateObjectCell } from 'mol-state/object';
export { StateTree }
@@ -17,17 +16,16 @@ export { StateTree }
* Represented as an immutable map.
*/
interface StateTree {
- readonly root: Transform,
+ readonly root: StateTransform,
readonly transforms: StateTree.Transforms,
readonly children: StateTree.Children,
readonly cellStates: StateTree.CellStates,
- asTransient(): TransientTree,
- build(): StateTreeBuilder.Root
+ asTransient(): TransientTree
}
namespace StateTree {
- type Ref = Transform.Ref
+ type Ref = StateTransform.Ref
export interface ChildSet {
readonly size: number,
@@ -43,21 +41,17 @@ namespace StateTree {
get(ref: Ref): T
}
- export interface Transforms extends _Map<Transform> {}
+ export interface Transforms extends _Map<StateTransform> {}
export interface Children extends _Map<ChildSet> { }
export interface CellStates extends _Map<StateObjectCell.State> { }
class Impl implements StateTree {
- get root() { return this.transforms.get(Transform.RootRef)! }
+ get root() { return this.transforms.get(StateTransform.RootRef)! }
asTransient(): TransientTree {
return new TransientTree(this);
}
- build(): StateTreeBuilder.Root {
- return new StateTreeBuilder.Root(this);
- }
-
constructor(public transforms: StateTree.Transforms, public children: Children, public cellStates: CellStates) {
}
}
@@ -66,7 +60,7 @@ namespace StateTree {
* Create an instance of an immutable tree.
*/
export function createEmpty(): StateTree {
- const root = Transform.createRoot();
+ const root = StateTransform.createRoot();
return create(ImmutableMap([[root.ref, root]]), ImmutableMap([[root.ref, OrderedSet()]]), ImmutableMap([[root.ref, StateObjectCell.DefaultState]]));
}
@@ -74,10 +68,10 @@ namespace StateTree {
return new Impl(nodes, children, cellStates);
}
- type VisitorCtx = { tree: StateTree, state: any, f: (node: Transform, tree: StateTree, state: any) => boolean | undefined | void };
+ type VisitorCtx = { tree: StateTree, state: any, f: (node: StateTransform, tree: StateTree, state: any) => boolean | undefined | void };
function _postOrderFunc(this: VisitorCtx, c: Ref | undefined) { _doPostOrder(this, this.tree.transforms.get(c!)!); }
- function _doPostOrder(ctx: VisitorCtx, root: Transform) {
+ function _doPostOrder(ctx: VisitorCtx, root: StateTransform) {
const children = ctx.tree.children.get(root.ref);
if (children && children.size) {
children.forEach(_postOrderFunc, ctx);
@@ -88,14 +82,14 @@ namespace StateTree {
/**
* Visit all nodes in a subtree in "post order", meaning leafs get visited first.
*/
- export function doPostOrder<S>(tree: StateTree, root: Transform, state: S, f: (node: Transform, tree: StateTree, state: S) => boolean | undefined | void): S {
+ export function doPostOrder<S>(tree: StateTree, root: StateTransform, state: S, f: (node: StateTransform, tree: StateTree, state: S) => boolean | undefined | void): S {
const ctx: VisitorCtx = { tree, state, f };
_doPostOrder(ctx, root);
return ctx.state;
}
function _preOrderFunc(this: VisitorCtx, c: Ref | undefined) { _doPreOrder(this, this.tree.transforms.get(c!)!); }
- function _doPreOrder(ctx: VisitorCtx, root: Transform) {
+ function _doPreOrder(ctx: VisitorCtx, root: StateTransform) {
const ret = ctx.f(root, ctx.tree, ctx.state);
if (typeof ret === 'boolean' && !ret) return;
const children = ctx.tree.children.get(root.ref);
@@ -108,44 +102,44 @@ namespace StateTree {
* Visit all nodes in a subtree in "pre order", meaning leafs get visited last.
* If the visitor function returns false, the visiting for that branch is interrupted.
*/
- export function doPreOrder<S>(tree: StateTree, root: Transform, state: S, f: (node: Transform, tree: StateTree, state: S) => boolean | undefined | void): S {
+ export function doPreOrder<S>(tree: StateTree, root: StateTransform, state: S, f: (node: StateTransform, tree: StateTree, state: S) => boolean | undefined | void): S {
const ctx: VisitorCtx = { tree, state, f };
_doPreOrder(ctx, root);
return ctx.state;
}
- function _subtree(n: Transform, _: any, subtree: Transform[]) { subtree.push(n); }
+ function _subtree(n: StateTransform, _: any, subtree: StateTransform[]) { subtree.push(n); }
/**
* Get all nodes in a subtree, leafs come first.
*/
- export function subtreePostOrder<T>(tree: StateTree, root: Transform) {
- return doPostOrder<Transform[]>(tree, root, [], _subtree);
+ export function subtreePostOrder(tree: StateTree, root: StateTransform) {
+ return doPostOrder<StateTransform[]>(tree, root, [], _subtree);
}
- function _visitNodeToJson(node: Transform, tree: StateTree, ctx: [Transform.Serialized, StateObjectCell.State][]) {
+ function _visitNodeToJson(node: StateTransform, tree: StateTree, ctx: [StateTransform.Serialized, StateObjectCell.State][]) {
// const children: Ref[] = [];
// tree.children.get(node.ref).forEach(_visitChildToJson as any, children);
- ctx.push([Transform.toJSON(node), tree.cellStates.get(node.ref)]);
+ ctx.push([StateTransform.toJSON(node), tree.cellStates.get(node.ref)]);
}
export interface Serialized {
/** Transforms serialized in pre-order */
- transforms: [Transform.Serialized, StateObjectCell.State][]
+ transforms: [StateTransform.Serialized, StateObjectCell.State][]
}
- export function toJSON<T>(tree: StateTree): Serialized {
- const transforms: [Transform.Serialized, StateObjectCell.State][] = [];
+ export function toJSON(tree: StateTree): Serialized {
+ const transforms: [StateTransform.Serialized, StateObjectCell.State][] = [];
doPreOrder(tree, tree.root, transforms, _visitNodeToJson);
return { transforms };
}
- export function fromJSON<T>(data: Serialized): StateTree {
- const nodes = ImmutableMap<Ref, Transform>().asMutable();
+ export function fromJSON(data: Serialized): StateTree {
+ const nodes = ImmutableMap<Ref, StateTransform>().asMutable();
const children = ImmutableMap<Ref, OrderedSet<Ref>>().asMutable();
const cellStates = ImmutableMap<Ref, StateObjectCell.State>().asMutable();
for (const t of data.transforms) {
- const transform = Transform.fromJSON(t[0]);
+ const transform = StateTransform.fromJSON(t[0]);
nodes.set(transform.ref, transform);
cellStates.set(transform.ref, t[1]);
diff --git a/src/mol-state/tree/transient.ts b/src/mol-state/tree/transient.ts
index 9646dab8f430b2322fc5e2c83138c976019b835c..66a6472937d33dd796f7b12b1dc438a81dcb0994 100644
--- a/src/mol-state/tree/transient.ts
+++ b/src/mol-state/tree/transient.ts
@@ -5,24 +5,23 @@
*/
import { Map as ImmutableMap, OrderedSet } from 'immutable';
-import { Transform } from '../transform';
+import { StateTransform } from '../transform';
import { StateTree } from './immutable';
-import { StateTreeBuilder } from './builder';
import { StateObjectCell } from 'mol-state/object';
import { shallowEqual } from 'mol-util/object';
export { TransientTree }
class TransientTree implements StateTree {
- transforms = this.tree.transforms as ImmutableMap<Transform.Ref, Transform>;
- children = this.tree.children as ImmutableMap<Transform.Ref, OrderedSet<Transform.Ref>>;
- cellStates = this.tree.cellStates as ImmutableMap<Transform.Ref, StateObjectCell.State>;
+ transforms = this.tree.transforms as ImmutableMap<StateTransform.Ref, StateTransform>;
+ children = this.tree.children as ImmutableMap<StateTransform.Ref, OrderedSet<StateTransform.Ref>>;
+ cellStates = this.tree.cellStates as ImmutableMap<StateTransform.Ref, StateObjectCell.State>;
private changedNodes = false;
private changedChildren = false;
private changedStates = false;
- private _childMutations: Map<Transform.Ref, OrderedSet<Transform.Ref>> | undefined = void 0;
+ private _childMutations: Map<StateTransform.Ref, OrderedSet<StateTransform.Ref>> | undefined = void 0;
private get childMutations() {
if (this._childMutations) return this._childMutations;
@@ -48,36 +47,32 @@ class TransientTree implements StateTree {
this.children = this.children.asMutable();
}
- get root() { return this.transforms.get(Transform.RootRef)! }
-
- build(): StateTreeBuilder.Root {
- return new StateTreeBuilder.Root(this);
- }
+ get root() { return this.transforms.get(StateTransform.RootRef)! }
asTransient() {
return this.asImmutable().asTransient();
}
- private addChild(parent: Transform.Ref, child: Transform.Ref) {
+ private addChild(parent: StateTransform.Ref, child: StateTransform.Ref) {
this.changeChildren();
if (this.childMutations.has(parent)) {
this.childMutations.get(parent)!.add(child);
} else {
- const set = (this.children.get(parent) as OrderedSet<Transform.Ref>).asMutable();
+ const set = (this.children.get(parent) as OrderedSet<StateTransform.Ref>).asMutable();
set.add(child);
this.children.set(parent, set);
this.childMutations.set(parent, set);
}
}
- private removeChild(parent: Transform.Ref, child: Transform.Ref) {
+ private removeChild(parent: StateTransform.Ref, child: StateTransform.Ref) {
this.changeChildren();
if (this.childMutations.has(parent)) {
this.childMutations.get(parent)!.remove(child);
} else {
- const set = (this.children.get(parent) as OrderedSet<Transform.Ref>).asMutable();
+ const set = (this.children.get(parent) as OrderedSet<StateTransform.Ref>).asMutable();
set.remove(child);
this.children.set(parent, set);
this.childMutations.set(parent, set);
@@ -85,17 +80,17 @@ class TransientTree implements StateTree {
}
private clearRoot() {
- const parent = Transform.RootRef;
+ const parent = StateTransform.RootRef;
if (this.children.get(parent).size === 0) return;
this.changeChildren();
- const set = OrderedSet<Transform.Ref>();
+ const set = OrderedSet<StateTransform.Ref>();
this.children.set(parent, set);
this.childMutations.set(parent, set);
}
- add(transform: Transform, initialState?: Partial<StateObjectCell.State>) {
+ add(transform: StateTransform, initialState?: Partial<StateObjectCell.State>) {
const ref = transform.ref;
if (this.transforms.has(transform.ref)) {
@@ -134,7 +129,7 @@ class TransientTree implements StateTree {
}
/** Calls Transform.definition.params.areEqual if available, otherwise uses shallowEqual to check if the params changed */
- setParams(ref: Transform.Ref, params: any) {
+ setParams(ref: StateTransform.Ref, params: any) {
ensurePresent(this.transforms, ref);
const transform = this.transforms.get(ref)!;
@@ -148,11 +143,11 @@ class TransientTree implements StateTree {
this.transforms = this.transforms.asMutable();
}
- this.transforms.set(transform.ref, Transform.withParams(transform, params));
+ this.transforms.set(transform.ref, StateTransform.withParams(transform, params));
return true;
}
- updateCellState(ref: Transform.Ref, state: Partial<StateObjectCell.State>) {
+ updateCellState(ref: StateTransform.Ref, state: Partial<StateObjectCell.State>) {
ensurePresent(this.transforms, ref);
const old = this.cellStates.get(ref);
@@ -164,12 +159,12 @@ class TransientTree implements StateTree {
return true;
}
- remove(ref: Transform.Ref): Transform[] {
+ remove(ref: StateTransform.Ref): StateTransform[] {
const node = this.transforms.get(ref);
if (!node) return [];
const st = StateTree.subtreePostOrder(this, node);
- if (ref === Transform.RootRef) {
+ if (ref === StateTransform.RootRef) {
st.pop();
if (st.length === 0) return st;
this.clearRoot();
@@ -206,17 +201,17 @@ class TransientTree implements StateTree {
}
}
-function fixChildMutations(this: ImmutableMap<Transform.Ref, OrderedSet<Transform.Ref>>, m: OrderedSet<Transform.Ref>, k: Transform.Ref) { this.set(k, m.asImmutable()); }
+function fixChildMutations(this: ImmutableMap<StateTransform.Ref, OrderedSet<StateTransform.Ref>>, m: OrderedSet<StateTransform.Ref>, k: StateTransform.Ref) { this.set(k, m.asImmutable()); }
-function alreadyPresent(ref: Transform.Ref) {
+function alreadyPresent(ref: StateTransform.Ref) {
throw new Error(`Transform '${ref}' is already present in the tree.`);
}
-function parentNotPresent(ref: Transform.Ref) {
+function parentNotPresent(ref: StateTransform.Ref) {
throw new Error(`Parent '${ref}' must be present in the tree.`);
}
-function ensurePresent(nodes: StateTree.Transforms, ref: Transform.Ref) {
+function ensurePresent(nodes: StateTree.Transforms, ref: StateTransform.Ref) {
if (!nodes.has(ref)) {
throw new Error(`Node '${ref}' is not present in the tree.`);
}