diff --git a/src/mol-plugin/ui/state-tree.tsx b/src/mol-plugin/ui/state-tree.tsx
index 019d4b78040f7a45482164f9a5354ef40eed3398..43e582f3465216ef36c52b1e7b1c2fc33fc9ba9b 100644
--- a/src/mol-plugin/ui/state-tree.tsx
+++ b/src/mol-plugin/ui/state-tree.tsx
@@ -34,7 +34,7 @@ export class StateTreeNode extends PluginComponent<{ nodeRef: string, state: Sta
}
render() {
- const n = this.props.state.tree.nodes.get(this.props.nodeRef)!;
+ const n = this.props.state.tree.transforms.get(this.props.nodeRef)!;
const cell = this.props.state.cells.get(this.props.nodeRef)!;
const remove = <>[<a href='#' onClick={e => {
diff --git a/src/mol-state/state.ts b/src/mol-state/state.ts
index 5ed8cb8d64051300620a506edf32d21a30638480..1162726a5ecfea11462359839a981c6e9329ea50 100644
--- a/src/mol-state/state.ts
+++ b/src/mol-state/state.ts
@@ -265,7 +265,7 @@ function findUpdateRootsVisitor(n: Transform, _: any, s: { roots: Ref[], cells:
type FindDeletesCtx = { newTree: StateTree, cells: State.Cells, deletes: Ref[] }
function _visitCheckDelete(n: Transform, _: any, ctx: FindDeletesCtx) {
- if (!ctx.newTree.nodes.has(n.ref) && ctx.cells.has(n.ref)) ctx.deletes.push(n.ref);
+ if (!ctx.newTree.transforms.has(n.ref) && ctx.cells.has(n.ref)) ctx.deletes.push(n.ref);
}
function findDeletes(ctx: UpdateContext): Ref[] {
const deleteCtx: FindDeletesCtx = { newTree: ctx.tree, cells: ctx.cells, deletes: [] };
@@ -288,7 +288,7 @@ function initCellStatusVisitor(t: Transform, _: any, ctx: UpdateContext) {
function initCellStatus(ctx: UpdateContext, roots: Ref[]) {
for (const root of roots) {
- StateTree.doPreOrder(ctx.tree, ctx.tree.nodes.get(root), ctx, initCellStatusVisitor);
+ StateTree.doPreOrder(ctx.tree, ctx.tree.transforms.get(root), ctx, initCellStatusVisitor);
}
}
@@ -314,7 +314,7 @@ function initCellsVisitor(transform: Transform, _: any, ctx: UpdateContext) {
function initCells(ctx: UpdateContext, roots: Ref[]) {
for (const root of roots) {
- StateTree.doPreOrder(ctx.tree, ctx.tree.nodes.get(root), ctx, initCellsVisitor);
+ StateTree.doPreOrder(ctx.tree, ctx.tree.transforms.get(root), ctx, initCellsVisitor);
}
}
@@ -326,7 +326,7 @@ function findNewCurrent(ctx: UpdateContext, start: Ref, deletes: Ref[]) {
function _findNewCurrent(tree: StateTree, ref: Ref, deletes: Set<Ref>): Ref {
if (ref === Transform.RootRef) return ref;
- const node = tree.nodes.get(ref)!;
+ const node = tree.transforms.get(ref)!;
const siblings = tree.children.get(node.parent)!.values();
let prevCandidate: Ref | undefined = void 0, seenRef = false;
@@ -337,7 +337,7 @@ function _findNewCurrent(tree: StateTree, ref: Ref, deletes: Set<Ref>): Ref {
if (deletes.has(s.value)) continue;
- const t = tree.nodes.get(s.value);
+ const t = tree.transforms.get(s.value);
if (t.props && t.props.isGhost) continue;
if (s.value === ref) {
seenRef = true;
@@ -397,7 +397,7 @@ async function updateSubtree(ctx: UpdateContext, root: Ref) {
if (update.action === 'created') {
ctx.parent.events.object.created.next({ state: ctx.parent, ref: root, obj: update.obj! });
if (!ctx.hadError) {
- const transform = ctx.tree.nodes.get(root);
+ const transform = ctx.tree.transforms.get(root);
if (!transform.props || !transform.props.isGhost) ctx.newCurrent = root;
}
} else if (update.action === 'updated') {
@@ -436,14 +436,14 @@ async function updateNode(ctx: UpdateContext, currentRef: Ref): Promise<UpdateNo
const parent = parentCell.obj!;
current.sourceRef = parentCell.transform.ref;
- if (!oldTree.nodes.has(currentRef)) {
+ if (!oldTree.transforms.has(currentRef)) {
const obj = await createObject(ctx, currentRef, transform.transformer, parent, transform.params);
current.obj = obj;
current.version = transform.version;
return { action: 'created', obj };
} else {
- const oldParams = oldTree.nodes.get(currentRef)!.params;
+ const oldParams = oldTree.transforms.get(currentRef)!.params;
const updateKind = !!current.obj
? await updateObject(ctx, currentRef, transform.transformer, parent, current.obj!, oldParams, transform.params)
diff --git a/src/mol-state/state/selection.ts b/src/mol-state/state/selection.ts
index 7d0caa949a409281859b85076ecee3674be9c5b6..039f80d4c63f70c43c3438b5d5f99a438736a036 100644
--- a/src/mol-state/state/selection.ts
+++ b/src/mol-state/state/selection.ts
@@ -169,7 +169,7 @@ namespace StateSelection {
export function subtree(b: Selector) {
return flatMap(b, (n, s) => {
const nodes = [] as string[];
- StateTree.doPreOrder(s.tree, s.tree.nodes.get(n.transform.ref), nodes, (x, _, ctx) => { ctx.push(x.ref) });
+ StateTree.doPreOrder(s.tree, s.tree.transforms.get(n.transform.ref), nodes, (x, _, ctx) => { ctx.push(x.ref) });
return nodes.map(x => s.cells.get(x)!);
});
}
@@ -190,12 +190,12 @@ namespace StateSelection {
export function ancestorOfType(b: Selector, types: StateObject.Ctor[]) { return unique(mapEntity(b, (n, s) => findAncestorOfType(s.tree, s.cells, n.transform.ref, types))); }
registerModifier('parent', parent);
- export function parent(b: Selector) { return unique(mapEntity(b, (n, s) => s.cells.get(s.tree.nodes.get(n.transform.ref)!.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 {
- let current = tree.nodes.get(root)!, len = types.length;
+ let current = tree.transforms.get(root)!, len = types.length;
while (true) {
- current = tree.nodes.get(current.parent)!;
+ current = tree.transforms.get(current.parent)!;
const cell = cells.get(current.ref)!;
if (!cell.obj) return void 0;
const obj = cell.obj;
diff --git a/src/mol-state/tree/builder.ts b/src/mol-state/tree/builder.ts
index 56f33a18ec8e53b42abeddeb011e64391883ffda..b602b90d1275104c55b4b6153129878a8947bcdc 100644
--- a/src/mol-state/tree/builder.ts
+++ b/src/mol-state/tree/builder.ts
@@ -64,7 +64,7 @@ namespace StateTreeBuilder {
update<T extends Transformer<A, any, any>>(paramsOrTransformer: T, provider?: (old: Transformer.Params<T>) => Transformer.Params<T>) {
let params: any;
if (provider) {
- const old = this.state.tree.nodes.get(this.ref)!;
+ const old = this.state.tree.transforms.get(this.ref)!;
params = provider(old.params as any);
} else {
params = paramsOrTransformer;
@@ -85,7 +85,7 @@ namespace StateTreeBuilder {
getTree(): StateTree { return this.state.tree.asImmutable(); }
constructor(private state: State, private ref: Transform.Ref, private root: Root) {
- if (!this.state.tree.nodes.has(ref)) {
+ if (!this.state.tree.transforms.has(ref)) {
throw new Error(`Could not find node '${ref}'.`);
}
}
diff --git a/src/mol-state/tree/immutable.ts b/src/mol-state/tree/immutable.ts
index e43db831679d7b2f4047a4c3e8cfe4f4231d39f9..824836a7a03cc0aa2f85214e8102ead323c307f4 100644
--- a/src/mol-state/tree/immutable.ts
+++ b/src/mol-state/tree/immutable.ts
@@ -17,7 +17,7 @@ export { StateTree }
*/
interface StateTree {
readonly root: Transform,
- readonly nodes: StateTree.Nodes,
+ readonly transforms: StateTree.Nodes,
readonly children: StateTree.Children,
asTransient(): TransientTree,
build(): StateTreeBuilder.Root
@@ -40,12 +40,11 @@ namespace StateTree {
get(ref: Ref): T
}
- export type Node = Transform
- export type Nodes = _Map<Transform>
- export type Children = _Map<ChildSet>
+ export interface Nodes extends _Map<Transform> {}
+ export interface Children extends _Map<ChildSet> { }
class Impl implements StateTree {
- get root() { return this.nodes.get(Transform.RootRef)! }
+ get root() { return this.transforms.get(Transform.RootRef)! }
asTransient(): TransientTree {
return new TransientTree(this);
@@ -55,7 +54,7 @@ namespace StateTree {
return new StateTreeBuilder.Root(this);
}
- constructor(public nodes: StateTree.Nodes, public children: Children) {
+ constructor(public transforms: StateTree.Nodes, public children: Children) {
}
}
@@ -71,10 +70,10 @@ namespace StateTree {
return new Impl(nodes, children);
}
- type VisitorCtx = { tree: StateTree, state: any, f: (node: Node, tree: StateTree, state: any) => boolean | undefined | void };
+ type VisitorCtx = { tree: StateTree, state: any, f: (node: Transform, tree: StateTree, state: any) => boolean | undefined | void };
- function _postOrderFunc(this: VisitorCtx, c: Ref | undefined) { _doPostOrder(this, this.tree.nodes.get(c!)!); }
- function _doPostOrder(ctx: VisitorCtx, root: Node) {
+ function _postOrderFunc(this: VisitorCtx, c: Ref | undefined) { _doPostOrder(this, this.tree.transforms.get(c!)!); }
+ function _doPostOrder(ctx: VisitorCtx, root: Transform) {
const children = ctx.tree.children.get(root.ref);
if (children && children.size) {
children.forEach(_postOrderFunc, ctx);
@@ -85,14 +84,14 @@ namespace StateTree {
/**
* Visit all nodes in a subtree in "post order", meaning leafs get visited first.
*/
- export function doPostOrder<S>(tree: StateTree, root: Node, state: S, f: (node: Node, tree: StateTree, state: S) => boolean | undefined | void): S {
+ export function doPostOrder<S>(tree: StateTree, root: Transform, state: S, f: (node: Transform, 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.nodes.get(c!)!); }
- function _doPreOrder(ctx: VisitorCtx, root: Node) {
+ function _preOrderFunc(this: VisitorCtx, c: Ref | undefined) { _doPreOrder(this, this.tree.transforms.get(c!)!); }
+ function _doPreOrder(ctx: VisitorCtx, root: Transform) {
const ret = ctx.f(root, ctx.tree, ctx.state);
if (typeof ret === 'boolean' && !ret) return;
const children = ctx.tree.children.get(root.ref);
@@ -105,24 +104,24 @@ 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: Node, state: S, f: (node: Node, tree: StateTree, state: S) => boolean | undefined | void): S {
+ export function doPreOrder<S>(tree: StateTree, root: Transform, state: S, f: (node: Transform, tree: StateTree, state: S) => boolean | undefined | void): S {
const ctx: VisitorCtx = { tree, state, f };
_doPreOrder(ctx, root);
return ctx.state;
}
- function _subtree(n: Node, _: any, subtree: Node[]) { subtree.push(n); }
+ function _subtree(n: Transform, _: any, subtree: Transform[]) { subtree.push(n); }
/**
* Get all nodes in a subtree, leafs come first.
*/
- export function subtreePostOrder<T>(tree: StateTree, root: Node) {
- return doPostOrder<Node[]>(tree, root, [], _subtree);
+ export function subtreePostOrder<T>(tree: StateTree, root: Transform) {
+ return doPostOrder<Transform[]>(tree, root, [], _subtree);
}
// function _visitChildToJson(this: Ref[], ref: Ref) { this.push(ref); }
// interface ToJsonCtx { nodes: Transform.Serialized[] }
- function _visitNodeToJson(node: Node, tree: StateTree, ctx: Transform.Serialized[]) {
+ function _visitNodeToJson(node: Transform, tree: StateTree, ctx: Transform.Serialized[]) {
// const children: Ref[] = [];
// tree.children.get(node.ref).forEach(_visitChildToJson as any, children);
ctx.push(Transform.toJSON(node));
@@ -140,7 +139,7 @@ namespace StateTree {
}
export function fromJSON<T>(data: Serialized): StateTree {
- const nodes = ImmutableMap<Ref, Node>().asMutable();
+ const nodes = ImmutableMap<Ref, Transform>().asMutable();
const children = ImmutableMap<Ref, OrderedSet<Ref>>().asMutable();
for (const s of data.nodes) {
diff --git a/src/mol-state/tree/transient.ts b/src/mol-state/tree/transient.ts
index a944fe8aaae8ce8e318bbf3205c20132752552b0..9bb54678bd431555ccd9d13d2a3171c603ae55a5 100644
--- a/src/mol-state/tree/transient.ts
+++ b/src/mol-state/tree/transient.ts
@@ -15,7 +15,7 @@ import { UUID } from 'mol-util';
export { TransientTree }
class TransientTree implements StateTree {
- nodes = this.tree.nodes as ImmutableMap<Transform.Ref, Transform>;
+ transforms = this.tree.transforms as ImmutableMap<Transform.Ref, Transform>;
children = this.tree.children as ImmutableMap<Transform.Ref, OrderedSet<Transform.Ref>>;
private changedNodes = false;
@@ -29,7 +29,7 @@ class TransientTree implements StateTree {
return this._childMutations;
}
- get root() { return this.nodes.get(Transform.RootRef)! }
+ get root() { return this.transforms.get(Transform.RootRef)! }
build(): StateTreeBuilder.Root {
return new StateTreeBuilder.Root(this);
@@ -86,8 +86,8 @@ class TransientTree implements StateTree {
add(transform: Transform) {
const ref = transform.ref;
- if (this.nodes.has(transform.ref)) {
- const node = this.nodes.get(transform.ref);
+ if (this.transforms.has(transform.ref)) {
+ const node = this.transforms.get(transform.ref);
if (node.parent !== transform.parent) alreadyPresent(transform.ref);
}
@@ -108,18 +108,18 @@ class TransientTree implements StateTree {
if (!this.changedNodes) {
this.changedNodes = true;
- this.nodes = this.nodes.asMutable();
+ this.transforms = this.transforms.asMutable();
}
- this.nodes.set(ref, transform);
+ this.transforms.set(ref, transform);
return this;
}
/** Calls Transform.definition.params.areEqual if available, otherwise uses shallowEqual to check if the params changed */
setParams(ref: Transform.Ref, params: unknown) {
- ensurePresent(this.nodes, ref);
+ ensurePresent(this.transforms, ref);
- const transform = this.nodes.get(ref)!;
+ const transform = this.transforms.get(ref)!;
const def = transform.transformer.definition;
if (def.params && def.params.areEqual) {
if (def.params.areEqual(transform.params, params)) return false;
@@ -141,7 +141,7 @@ class TransientTree implements StateTree {
}
setCellState(ref: Transform.Ref, state: Partial<StateObjectCell.State>) {
- ensurePresent(this.nodes, ref);
+ ensurePresent(this.transforms, ref);
if (this._transformMutations && this._transformMutations.has(ref)) {
const transform = this._transformMutations.get(ref)!;
@@ -149,7 +149,7 @@ class TransientTree implements StateTree {
(transform.cellState as StateObjectCell.State) = { ...old, ...state };
return transform;
} else {
- const transform = this.nodes.get(ref);
+ const transform = this.transforms.get(ref);
const newT = Transform.withCellState(transform, state);
this.set(newT);
return newT;
@@ -157,11 +157,11 @@ class TransientTree implements StateTree {
}
private set(transform: Transform) {
- ensurePresent(this.nodes, transform.ref);
+ ensurePresent(this.transforms, transform.ref);
if (!this.changedNodes) {
this.changedNodes = true;
- this.nodes = this.nodes.asMutable();
+ this.transforms = this.transforms.asMutable();
}
if (!this._transformMutations) {
@@ -169,12 +169,12 @@ class TransientTree implements StateTree {
}
this._transformMutations.set(transform.ref, transform);
- this.nodes.set(transform.ref, transform);
+ this.transforms.set(transform.ref, transform);
return this;
}
remove(ref: Transform.Ref): Transform[] {
- const node = this.nodes.get(ref);
+ const node = this.transforms.get(ref);
if (!node) return [];
const st = StateTree.subtreePostOrder(this, node);
@@ -189,11 +189,11 @@ class TransientTree implements StateTree {
if (!this.changedNodes) {
this.changedNodes = true;
- this.nodes = this.nodes.asMutable();
+ this.transforms = this.transforms.asMutable();
}
for (const n of st) {
- this.nodes.delete(n.ref);
+ this.transforms.delete(n.ref);
this.children.delete(n.ref);
if (this._childMutations) this._childMutations.delete(n.ref);
}
@@ -205,7 +205,7 @@ class TransientTree implements StateTree {
if (!this.changedNodes && !this.changedChildren && !this._childMutations) return this.tree;
if (this._childMutations) this._childMutations.forEach(fixChildMutations, this.children);
return StateTree.create(
- this.changedNodes ? this.nodes.asImmutable() : this.nodes,
+ this.changedNodes ? this.transforms.asImmutable() : this.transforms,
this.changedChildren ? this.children.asImmutable() : this.children);
}