mol-plugin: code cleanup and refactoring

src/mol-plugin-state/actions/data-format.ts

@@ -4,17 +4,16 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
+import msgpackDecode from '../../mol-io/common/msgpack/decode';
 import { PluginContext } from '../../mol-plugin/context';
-import { State, StateBuilder, StateAction } from '../../mol-state';
+import { State, StateAction, StateObjectRef } from '../../mol-state';
 import { Task } from '../../mol-task';
 import { FileInfo, getFileInfo } from '../../mol-util/file-info';
-import { PluginStateObject } from '../objects';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
-import { Ccp4Provider, Dsn6Provider, DscifProvider } from './volume';
-import { StateTransforms } from '../transforms';
-import { MmcifProvider, PdbProvider, GroProvider, Provider3dg, DcdProvider, PsfProvider } from './structure';
-import msgpackDecode from '../../mol-io/common/msgpack/decode'
+import { PluginStateObject } from '../objects';
 import { PlyProvider } from './shape';
+import { DcdProvider, GroProvider, MmcifProvider, PdbProvider, Provider3dg, PsfProvider } from './structure';
+import { Ccp4Provider, DscifProvider, Dsn6Provider } from './volume';
 
 export class DataFormatRegistry<D extends PluginStateObject.Data.Binary | PluginStateObject.Data.String> {
     private _list: { name: string, provider: DataFormatProvider<D> }[] = []
@@ -114,7 +113,7 @@ export interface DataFormatProvider<D extends PluginStateObject.Data.Binary | Pl
     stringExtensions: string[]
     binaryExtensions: string[]
     isApplicable(info: FileInfo, data: string | Uint8Array): boolean
-    getDefaultBuilder(ctx: PluginContext, data: StateBuilder.To<D>, options: DataFormatBuilderOptions, state?: State): Task<void>
+    getDefaultBuilder(ctx: PluginContext, data: StateObjectRef<D>, options: DataFormatBuilderOptions, state: State): Task<void>
 }
 
 //
@@ -130,24 +129,27 @@ export const OpenFiles = StateAction.build({
             visuals: PD.Boolean(true, { description: 'Add default visuals' }),
         }
     }
-})(({ params, state }, ctx: PluginContext) => Task.create('Open Files', async taskCtx => {
-    for (let i = 0, il = params.files.length; i < il; ++i) {
-        try {
-            const file = params.files[i]
-            const info = getFileInfo(file)
-            const isBinary = ctx.dataFormat.registry.binaryExtensions.has(info.ext)
-            const data = state.build().toRoot().apply(StateTransforms.Data.ReadFile, { file, isBinary });
-            const dataStateObject = await state.updateTree(data).runInContext(taskCtx);
-            const provider = params.format === 'auto'
-                ? ctx.dataFormat.registry.auto(info, dataStateObject)
-                : ctx.dataFormat.registry.get(params.format)
-            const b = state.build().to(data.ref);
-            // need to await so that the enclosing Task finishes after the update is done.
-            await provider.getDefaultBuilder(ctx, b, { visuals: params.visuals }, state).runInContext(taskCtx)
-        } catch (e) {
-            ctx.log.error(e)
+})(({ params, state }, plugin: PluginContext) => Task.create('Open Files', async taskCtx => {
+    await state.transaction(async () => {
+        for (let i = 0, il = params.files.length; i < il; ++i) {
+            try {
+                const file = params.files[i]
+                const info = getFileInfo(file)
+                const isBinary = plugin.dataFormat.registry.binaryExtensions.has(info.ext)
+                const { data } = await plugin.builders.data.readFile({ file, isBinary });
+                //const data = state.build().toRoot().apply(StateTransforms.Data.ReadFile, { file, isBinary });
+                // const dataStateObject = await state.updateTree(data).runInContext(taskCtx);
+                const provider = params.format === 'auto'
+                    ? plugin.dataFormat.registry.auto(info, data.cell?.obj!)
+                    : plugin.dataFormat.registry.get(params.format)
+                
+                // need to await so that the enclosing Task finishes after the update is done.
+                await provider.getDefaultBuilder(plugin, data, { visuals: params.visuals }, state).runInContext(taskCtx)
+            } catch (e) {
+                plugin.log.error(e)
+            }
         }
-    }
+    }).runInContext(taskCtx);
 }));
 
 //

src/mol-plugin-state/actions/shape.ts

@@ -8,7 +8,6 @@ import { PluginContext } from '../../mol-plugin/context';
 import { State, StateBuilder } from '../../mol-state';
 import { Task } from '../../mol-task';
 import { FileInfo } from '../../mol-util/file-info';
-import { PluginStateObject } from '../objects';
 import { StateTransforms } from '../transforms';
 import { DataFormatProvider, DataFormatBuilderOptions } from './data-format';
 
@@ -20,9 +19,10 @@ export const PlyProvider: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: string) => {
         return info.ext === 'ply'
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.String>, options: DataFormatBuilderOptions, state: State) => {
+    getDefaultBuilder: (ctx: PluginContext, data, options: DataFormatBuilderOptions, state: State) => {
         return Task.create('PLY default builder', async taskCtx => {
-            let tree: StateBuilder.To<any> = data.apply(StateTransforms.Data.ParsePly)
+            let tree: StateBuilder.To<any> = state.build().to(data)
+                .apply(StateTransforms.Data.ParsePly)
                 .apply(StateTransforms.Model.ShapeFromPly)
             if (options.visuals) {
                 tree = tree.apply(StateTransforms.Representation.ShapeRepresentation3D)

src/mol-plugin-state/actions/structure.ts

@@ -5,23 +5,23 @@
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
 
+import { Loci } from '../../mol-model/loci';
+import { StructureElement } from '../../mol-model/structure';
 import { PluginContext } from '../../mol-plugin/context';
-import { StateAction, StateBuilder, StateSelection, StateTransformer, State } from '../../mol-state';
+import { StateAction, StateBuilder, StateSelection, StateTransformer } from '../../mol-state';
+import { Task } from '../../mol-task';
+import { UUID } from '../../mol-util';
+import { FileInfo } from '../../mol-util/file-info';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
+import { RootStructureDefinition } from '../helpers/root-structure';
 import { PluginStateObject } from '../objects';
 import { StateTransforms } from '../transforms';
 import { Download, ParsePsf } from '../transforms/data';
-import { CustomModelProperties, CustomStructureProperties, CoordinatesFromDcd, TrajectoryFromModelAndCoordinates, TopologyFromPsf } from '../transforms/model';
-import { DataFormatProvider, guessCifVariant, DataFormatBuilderOptions } from './data-format';
-import { FileInfo } from '../../mol-util/file-info';
-import { Task } from '../../mol-task';
-import { StructureElement } from '../../mol-model/structure';
-import { createDefaultStructureComplex } from '../../mol-plugin/util/structure-complex-helper';
-import { RootStructureDefinition } from '../helpers/root-structure';
-import { UUID } from '../../mol-util';
-import { Loci } from '../../mol-model/loci';
+import { CoordinatesFromDcd, CustomModelProperties, CustomStructureProperties, TopologyFromPsf, TrajectoryFromModelAndCoordinates } from '../transforms/model';
+import { DataFormatProvider, guessCifVariant } from './data-format';
+import { TrajectoryFormat } from '../builder/structure';
 
-export const MmcifProvider: DataFormatProvider<any> = {
+export const MmcifProvider: DataFormatProvider<PluginStateObject.Data.String | PluginStateObject.Data.Binary> = {
     label: 'mmCIF',
     description: 'mmCIF',
     stringExtensions: ['cif', 'mmcif', 'mcif'],
@@ -32,10 +32,12 @@ export const MmcifProvider: DataFormatProvider<any> = {
         if (info.ext === 'cif' || info.ext === 'bcif') return guessCifVariant(info, data) !== 'dscif'
         return false
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary | PluginStateObject.Data.String>, options: DataFormatBuilderOptions, state: State) => {
+    getDefaultBuilder: (ctx: PluginContext, data, options) => {
         return Task.create('mmCIF default builder', async taskCtx => {
-            const traj = createModelTree(data, 'cif');
-            await state.updateTree(options.visuals ? createStructureAndVisuals(ctx, traj, false) : traj).runInContext(taskCtx)
+            const { structure } = await ctx.builders.structure.parseStructure({ data, dataFormat: 'cif' });
+            if (options.visuals) {
+                await ctx.builders.representation.structurePreset(structure, 'auto');
+            }
         })
     }
 }
@@ -48,10 +50,12 @@ export const PdbProvider: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: string) => {
         return info.ext === 'pdb' || info.ext === 'ent'
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.String>, options: DataFormatBuilderOptions, state: State) => {
-        return Task.create('PDB default builder', async taskCtx => {
-            const traj = createModelTree(data, 'pdb');
-            await state.updateTree(options.visuals ? createStructureAndVisuals(ctx, traj, false) : traj).runInContext(taskCtx)
+    getDefaultBuilder: (ctx: PluginContext, data, options) => {
+        return Task.create('PDB default builder', async () => {
+            const { structure } = await ctx.builders.structure.parseStructure({ data, dataFormat: 'cif' });
+            if (options.visuals) {
+                await ctx.builders.representation.structurePreset(structure, 'auto');
+            }
         })
     }
 }
@@ -64,10 +68,12 @@ export const GroProvider: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: string) => {
         return info.ext === 'gro'
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.String>, options: DataFormatBuilderOptions, state: State) => {
-        return Task.create('GRO default builder', async taskCtx => {
-            const traj = createModelTree(data, 'gro');
-            await state.updateTree(options.visuals ? createStructureAndVisuals(ctx, traj, false) : traj).runInContext(taskCtx)
+    getDefaultBuilder: (ctx: PluginContext, data, options) => {
+        return Task.create('GRO default builder', async () => {
+            const { structure } = await ctx.builders.structure.parseStructure({ data, dataFormat: 'gro' });
+            if (options.visuals) {
+                await ctx.builders.representation.structurePreset(structure, 'auto');
+            }
         })
     }
 }
@@ -80,10 +86,12 @@ export const Provider3dg: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: string) => {
         return info.ext === '3dg'
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.String>, options: DataFormatBuilderOptions, state: State) => {
-        return Task.create('3DG default builder', async taskCtx => {
-            const traj = createModelTree(data, '3dg');
-            await state.updateTree(options.visuals ? createStructureAndVisuals(ctx, traj, false) : traj).runInContext(taskCtx)
+    getDefaultBuilder: (ctx: PluginContext, data, options) => {
+        return Task.create('3DG default builder', async () => {
+            const { structure } = await ctx.builders.structure.parseStructure({ data, dataFormat: '3dg' });
+            if (options.visuals) {
+                await ctx.builders.representation.structurePreset(structure, 'auto');
+            }
         })
     }
 }
@@ -96,9 +104,10 @@ export const PsfProvider: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: string) => {
         return info.ext === 'psf'
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.String>, options: DataFormatBuilderOptions, state: State) => {
+    getDefaultBuilder: (ctx: PluginContext, data, options, state) => {
         return Task.create('PSF default builder', async taskCtx => {
-            await state.updateTree(data.apply(ParsePsf, {}, { state: { isGhost: true } }).apply(TopologyFromPsf)).runInContext(taskCtx)
+            const build = state.build().to(data).apply(ParsePsf, {}, { state: { isGhost: true } }).apply(TopologyFromPsf)
+            await state.updateTree(build).runInContext(taskCtx)
         })
     }
 }
@@ -111,15 +120,14 @@ export const DcdProvider: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: string) => {
         return info.ext === 'dcd'
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary>, options: DataFormatBuilderOptions, state: State) => {
+    getDefaultBuilder: (ctx: PluginContext, data, options, state) => {
         return Task.create('DCD default builder', async taskCtx => {
-            await state.updateTree(data.apply(CoordinatesFromDcd)).runInContext(taskCtx)
+            const build = state.build().to(data).apply(CoordinatesFromDcd);
+            await state.updateTree(build).runInContext(taskCtx)
         })
     }
 }
 
-type StructureFormat = 'pdb' | 'cif' | 'gro' | '3dg'
-
 //
 
 const DownloadModelRepresentationOptions = PD.Group({
@@ -181,7 +189,7 @@ const DownloadStructure = StateAction.build({
 
     const src = params.source;
     let downloadParams: StateTransformer.Params<Download>[];
-    let supportProps = false, asTrajectory = false, format: StructureFormat = 'cif';
+    let supportProps = false, asTrajectory = false, format: TrajectoryFormat = 'cif';
 
     switch (src.name) {
         case 'url':
@@ -268,7 +276,7 @@ function getDownloadParams(src: string, url: (id: string) => string, label: (id:
     return ret;
 }
 
-export function createModelTree(b: StateBuilder.To<PluginStateObject.Data.Binary | PluginStateObject.Data.String>, format: StructureFormat = 'cif') {
+export function createModelTree(b: StateBuilder.To<PluginStateObject.Data.Binary | PluginStateObject.Data.String>, format: TrajectoryFormat = 'cif') {
     let parsed: StateBuilder.To<PluginStateObject.Molecule.Trajectory>
     switch (format) {
         case 'cif':
@@ -291,20 +299,6 @@ export function createModelTree(b: StateBuilder.To<PluginStateObject.Data.Binary
     return parsed.apply(StateTransforms.Model.ModelFromTrajectory, { modelIndex: 0 });
 }
 
-function createStructure(b: StateBuilder.To<PluginStateObject.Molecule.Model>, supportProps: boolean, params?: RootStructureDefinition.Params) {
-    let root = b;
-    if (supportProps) {
-        root = root.apply(StateTransforms.Model.CustomModelProperties);
-    }
-    return root.apply(StateTransforms.Model.StructureFromModel, { type: params || { name: 'assembly', params: { } } });
-}
-
-function createStructureAndVisuals(ctx: PluginContext, b: StateBuilder.To<PluginStateObject.Molecule.Model>, supportProps: boolean, params?: RootStructureDefinition.Params) {
-    const structure = createStructure(b, supportProps, params);
-    createDefaultStructureComplex(ctx, structure);
-    return b;
-}
-
 export const Create3DRepresentationPreset = StateAction.build({
     display: { name: '3D Representation Preset', description: 'Create one of preset 3D representations.' },
     from: PluginStateObject.Molecule.Structure,
@@ -433,13 +427,18 @@ export const AddTrajectory = StateAction.build({
             coordinates: PD.Select(coordOptions.length ? coordOptions[0][0] : '', coordOptions)
         }
     }
-})(({ ref, params, state }, ctx: PluginContext) => {
-    const dependsOn = [params.model, params.coordinates];
-    const root = state.build().toRoot()
-        .apply(TrajectoryFromModelAndCoordinates, {
-            modelRef: params.model,
-            coordinatesRef: params.coordinates
-        }, { dependsOn })
-        .apply(StateTransforms.Model.ModelFromTrajectory, { modelIndex: 0 })
-    return state.updateTree(createStructureAndVisuals(ctx, root, false));
-});
+})(({ params, state }, ctx: PluginContext) => Task.create('Add Trajectory', taskCtx => {
+    return state.transaction(async () => {
+        const dependsOn = [params.model, params.coordinates];
+        const model = state.build().toRoot()
+            .apply(TrajectoryFromModelAndCoordinates, {
+                modelRef: params.model,
+                coordinatesRef: params.coordinates
+            }, { dependsOn })
+            .apply(StateTransforms.Model.ModelFromTrajectory, { modelIndex: 0 });
+
+        await state.updateTree(model).runInContext(taskCtx);
+        const structure = await ctx.builders.structure.createStructure(model.selector);
+        await ctx.builders.representation.structurePreset(structure, 'auto');
+    }).runInContext(taskCtx)
+}));

src/mol-plugin-state/actions/volume.ts

@@ -26,9 +26,10 @@ export const Ccp4Provider: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: Uint8Array) => {
         return info.ext === 'ccp4' || info.ext === 'mrc' || info.ext === 'map'
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary>, options: DataFormatBuilderOptions, state: State) => {
+    getDefaultBuilder: (ctx: PluginContext, data, options: DataFormatBuilderOptions, state: State) => {
         return Task.create('CCP4/MRC/BRIX default builder', async taskCtx => {
-            let tree: StateBuilder.To<any> = data.apply(StateTransforms.Data.ParseCcp4, {}, { state: { isGhost: true } })
+            let tree: StateBuilder.To<any> = state.build().to(data)
+                .apply(StateTransforms.Data.ParseCcp4, {}, { state: { isGhost: true } })
                 .apply(StateTransforms.Volume.VolumeFromCcp4)
             if (options.visuals) {
                 tree = tree.apply(StateTransforms.Representation.VolumeRepresentation3D)
@@ -46,9 +47,10 @@ export const Dsn6Provider: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: Uint8Array) => {
         return info.ext === 'dsn6' || info.ext === 'brix'
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary>, options: DataFormatBuilderOptions, state: State) => {
+    getDefaultBuilder: (ctx: PluginContext, data, options: DataFormatBuilderOptions, state: State) => {
         return Task.create('DSN6/BRIX default builder', async taskCtx => {
-            let tree: StateBuilder.To<any> = data.apply(StateTransforms.Data.ParseDsn6, {}, { state: { isGhost: true } })
+            let tree: StateBuilder.To<any> = state.build().to(data)
+                .apply(StateTransforms.Data.ParseDsn6, {}, { state: { isGhost: true } })
                 .apply(StateTransforms.Volume.VolumeFromDsn6)
             if (options.visuals) {
                 tree = tree.apply(StateTransforms.Representation.VolumeRepresentation3D)
@@ -66,9 +68,9 @@ export const DscifProvider: DataFormatProvider<any> = {
     isApplicable: (info: FileInfo, data: Uint8Array | string) => {
         return guessCifVariant(info, data) === 'dscif' ? true : false
     },
-    getDefaultBuilder: (ctx: PluginContext, data: StateBuilder.To<PluginStateObject.Data.Binary | PluginStateObject.Data.String>, options: DataFormatBuilderOptions, state: State) => {
+    getDefaultBuilder: (ctx: PluginContext, data, options: DataFormatBuilderOptions, state: State) => {
         return Task.create('DensityServer CIF default builder', async taskCtx => {
-            const cifBuilder = data.apply(StateTransforms.Data.ParseCif)
+            const cifBuilder = state.build().to(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
@@ -185,13 +187,13 @@ const DownloadDensity = StateAction.build({
         default: throw new Error(`${(src as any).name} not supported.`);
     }
 
-    const data = state.build().toRoot().apply(StateTransforms.Data.Download, downloadParams);
-    const dataStateObject = await state.updateTree(data).runInContext(taskCtx);
+    const data = await ctx.builders.data.download(downloadParams);
+    //const dataStateObject = await state.updateTree(data).runInContext(taskCtx);
 
     switch (src.name) {
         case 'url':
             downloadParams = src.params;
-            provider = src.params.format === 'auto' ? ctx.dataFormat.registry.auto(getFileInfo(downloadParams.url), dataStateObject) : ctx.dataFormat.registry.get(src.params.format)
+            provider = src.params.format === 'auto' ? ctx.dataFormat.registry.auto(getFileInfo(downloadParams.url), data.cell?.obj!) : ctx.dataFormat.registry.get(src.params.format)
             break;
         case 'pdbe':
             provider = ctx.dataFormat.registry.get('ccp4')
@@ -206,6 +208,5 @@ const DownloadDensity = StateAction.build({
         default: throw new Error(`${(src as any).name} not supported.`);
     }
 
-    const b = state.build().to(data.ref);
-    await provider.getDefaultBuilder(ctx, b, { visuals: true }, state).runInContext(taskCtx)
+    await provider.getDefaultBuilder(ctx, data, { visuals: true }, state).runInContext(taskCtx)
 }));

src/mol-plugin-state/builder/structure.ts

@@ -11,7 +11,7 @@ import { StateTransforms } from '../transforms';
 import { RootStructureDefinition } from '../helpers/root-structure';
 import { StructureComponentParams } from '../helpers/structure-component';
 
-type TrajectoryFormat = 'pdb' | 'cif' | 'gro' | '3dg'
+export type TrajectoryFormat = 'pdb' | 'cif' | 'gro' | '3dg'
 
 export enum StructureBuilderTags {
     Trajectory = 'trajectory',

src/mol-plugin-state/builder/structure/preset.ts

@@ -7,7 +7,7 @@
 
 import { StateTransforms } from '../../transforms';
 import { StructureRepresentation3DHelpers } from '../../transforms/representation';
-import { StructureSelectionQueries as Q } from '../../../mol-plugin/util/structure-selection-query';
+import { StructureSelectionQueries as Q } from '../../helpers/structure-selection-query';
 import { BuiltInStructureRepresentations } from '../../../mol-repr/structure/registry';
 import { StructureRepresentationProvider, RepresentationProviderTags } from './provider';
 import { StateObjectRef } from '../../../mol-state';

src/mol-plugin-state/helpers/structure-component.ts

@@ -10,7 +10,7 @@ import { MolScriptBuilder } from '../../mol-script/language/builder';
 import { StructureElement, Structure, StructureSelection as Sel, StructureQuery, Queries, QueryContext } from '../../mol-model/structure';
 import { StructureQueryHelper } from './structure-query';
 import { PluginStateObject as SO } from '../objects';
-import { StructureSelectionQueries } from '../../mol-plugin/util/structure-selection-query';
+import { StructureSelectionQueries } from './structure-selection-query';
 import { StateTransformer, StateObject } from '../../mol-state';
 import { Script } from '../../mol-script/script';
 

src/mol-plugin/util/structure-selection-query.ts → src/mol-plugin-state/helpers/structure-selection-query.ts

@@ -10,8 +10,8 @@ import { AccessibleSurfaceAreaProvider, AccessibleSurfaceAreaSymbols } from '../
 import { ValidationReport, ValidationReportProvider } from '../../mol-model-props/rcsb/validation-report';
 import { QueryContext, Structure, StructureQuery, StructureSelection } from '../../mol-model/structure';
 import { BondType, NucleicBackboneAtoms, ProteinBackboneAtoms, SecondaryStructureType } from '../../mol-model/structure/model/types';
-import { PluginStateObject } from '../../mol-plugin-state/objects';
-import { StateTransforms } from '../../mol-plugin-state/transforms';
+import { PluginStateObject } from '../objects';
+import { StateTransforms } from '../transforms';
 import { MolScriptBuilder as MS } from '../../mol-script/language/builder';
 import Expression from '../../mol-script/language/expression';
 import { compile } from '../../mol-script/runtime/query/compiler';
@@ -19,7 +19,7 @@ import { StateBuilder } from '../../mol-state';
 import { RuntimeContext } from '../../mol-task';
 import { SetUtils } from '../../mol-util/set';
 import { stringToWords } from '../../mol-util/string';
-import { PluginContext } from '../context';
+import { PluginContext } from '../../mol-plugin/context';
 
 export enum StructureSelectionCategory {
     Type = 'Type',

src/mol-plugin-state/manager/structure/selection.ts

@@ -18,7 +18,7 @@ import { arrayRemoveAtInPlace } from '../../../mol-util/array';
 import { EmptyLoci, Loci } from '../../../mol-model/loci';
 import { StateObject, StateSelection } from '../../../mol-state';
 import { PluginStateObject } from '../../objects';
-import { StructureSelectionQuery } from '../../../mol-plugin/util/structure-selection-query';
+import { StructureSelectionQuery } from '../../helpers/structure-selection-query';
 import { Task } from '../../../mol-task';
 
 interface StructureSelectionManagerState {

src/mol-plugin-state/transforms/model.ts

@@ -24,7 +24,7 @@ import { SymmetryOperator } from '../../mol-math/geometry';
 import { Script } from '../../mol-script/script';
 import { parse3DG } from '../../mol-io/reader/3dg/parser';
 import { trajectoryFrom3DG } from '../../mol-model-formats/structure/3dg';
-import { StructureSelectionQueries } from '../../mol-plugin/util/structure-selection-query';
+import { StructureSelectionQueries } from '../helpers/structure-selection-query';
 import { StructureQueryHelper } from '../helpers/structure-query';
 import { RootStructureDefinition } from '../helpers/root-structure';
 import { parseDcd } from '../../mol-io/reader/dcd/parser';

src/mol-plugin-state/transforms/representation.ts

@@ -29,7 +29,7 @@ import { Overpaint } from '../../mol-theme/overpaint';
 import { Transparency } from '../../mol-theme/transparency';
 import { BaseGeometry } from '../../mol-geo/geometry/base';
 import { Script } from '../../mol-script/script';
-import { getUnitcellRepresentation, UnitcellParams } from '../../mol-plugin/util/model-unitcell';
+import { getUnitcellRepresentation, UnitcellParams } from '../helpers/model-unitcell';
 import { DistanceParams, DistanceRepresentation } from '../../mol-repr/shape/loci/distance';
 import { getDistanceDataFromStructureSelections, getLabelDataFromStructureSelections, getOrientationDataFromStructureSelections, getAngleDataFromStructureSelections, getDihedralDataFromStructureSelections } from './helpers';
 import { LabelParams, LabelRepresentation } from '../../mol-repr/shape/loci/label';

src/mol-plugin-ui/structure/selection.tsx

@@ -7,7 +7,7 @@
 
 import * as React from 'react';
 import { CollapsableControls, CollapsableState } from '../base';
-import { StructureSelectionQuery, StructureSelectionQueryList } from '../../mol-plugin/util/structure-selection-query';
+import { StructureSelectionQuery, StructureSelectionQueryList } from '../../mol-plugin-state/helpers/structure-selection-query';
 import { PluginCommands } from '../../mol-plugin/commands';
 import { ParamDefinition as PD } from '../../mol-util/param-definition';
 import { Interactivity } from '../../mol-plugin/util/interactivity';

src/mol-plugin/util/structure-complex-helper.ts

@@ -1,43 +0,0 @@
-/**
- * Copyright (c) 2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
- *
- * @author David Sehnal <david.sehnal@gmail.com>
- */
-
-import { PluginContext } from '../context';
-import { StateBuilder } from '../../mol-state';
-import { PluginStateObject } from '../../mol-plugin-state/objects';
-import { StateTransforms } from '../../mol-plugin-state/transforms';
-import { StructureRepresentation3DHelpers } from '../../mol-plugin-state/transforms/representation';
-import { StructureComplexElementTypes } from '../../mol-plugin-state/transforms/model';
-
-export function createDefaultStructureComplex(
-    ctx: PluginContext, root: StateBuilder.To<PluginStateObject.Molecule.Structure>
-) {
-    root.apply(StateTransforms.Model.StructureComplexElement, { type: 'polymer' }, { tags: StructureComplexElementTypes['polymer'] })
-        .apply(StateTransforms.Representation.StructureRepresentation3D,
-            StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'cartoon'));
-
-    root.apply(StateTransforms.Model.StructureComplexElement, { type: 'ligand' }, { tags: StructureComplexElementTypes.ligand })
-        .apply(StateTransforms.Representation.StructureRepresentation3D,
-            StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'ball-and-stick'));
-
-    root.apply(StateTransforms.Model.StructureComplexElement, { type: 'non-standard' }, { tags: StructureComplexElementTypes['non-standard'] })
-        .apply(StateTransforms.Representation.StructureRepresentation3D,
-            StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'ball-and-stick', void 0, 'polymer-id'));
-
-    const branched = root.apply(StateTransforms.Model.StructureComplexElement, { type: 'branched' }, { tags: StructureComplexElementTypes.branched })
-
-    branched.apply(StateTransforms.Representation.StructureRepresentation3D,
-        StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'ball-and-stick', { alpha: 0.15 }));
-    branched.apply(StateTransforms.Representation.StructureRepresentation3D,
-        StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'carbohydrate'));
-
-    root.apply(StateTransforms.Model.StructureComplexElement, { type: 'water' }, { tags: StructureComplexElementTypes.water })
-        .apply(StateTransforms.Representation.StructureRepresentation3D,
-            StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'ball-and-stick', { alpha: 0.51 }));
-
-    root.apply(StateTransforms.Model.StructureComplexElement, { type: 'coarse' }, { tags: StructureComplexElementTypes.coarse })
-        .apply(StateTransforms.Representation.StructureRepresentation3D,
-            StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'spacefill', {}, 'polymer-id'));
-}