Optional trajectory preset provider

CHANGELOG.md

@@ -13,6 +13,9 @@
   - Renamed `label_seq_id` to `labelSeqRange` (if referring to a range and not a single residue)
 - `ColorProp` and `PropsetProps` now use `Target`
   - `positions` and `selection` props renamed to `targets` of type `Target[]`
+- Changed loading methods signature 
+  - Added optional configuration parameter `config?: {props?: PresetProps; matrix?: Mat4; reprProvider?: TrajectoryHierarchyPresetProvider, params?: P}`
+  - The loading configuration includes an optional trajectory preset provider `TrajectoryHierarchyPresetProvider` 
 
 ## [1.7.2] - 2021-07-05
 ### Bug fixes

package-lock.json

@@ -1,6 +1,6 @@
 {
     "name": "@rcsb/rcsb-molstar",
-    "version": "2.0.0-dev.2",
+    "version": "2.0.0-dev.3",
     "lockfileVersion": 1,
     "requires": true,
     "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rcsb/rcsb-molstar",
-    "version": "2.0.0-dev.2",
+    "version": "2.0.0-dev.3",
     "description": "RCSB PDB apps and props based on Mol*.",
     "homepage": "https://github.com/rcsb/rcsb-molstar#readme",
     "repository": {

src/viewer/helpers/model.ts

@@ -11,41 +11,46 @@ import { Asset } from 'molstar/lib/mol-util/assets';
 import { Mat4 } from 'molstar/lib/mol-math/linear-algebra';
 import { StateTransforms } from 'molstar/lib/mol-plugin-state/transforms';
 import { BuiltInTrajectoryFormat } from 'molstar/lib/mol-plugin-state/formats/trajectory';
+import {TrajectoryHierarchyPresetProvider} from 'molstar/lib/mol-plugin-state/builder/structure/hierarchy-preset';
 
 export class ModelLoader {
-    async load(load: LoadParams, props?: PresetProps, matrix?: Mat4) {
+    async load<P>(load: LoadParams, props?: PresetProps, matrix?: Mat4, reprProvider?: TrajectoryHierarchyPresetProvider, params?: P) {
         const { fileOrUrl, format, isBinary } = load;
 
         const data = fileOrUrl instanceof File
             ? (await this.plugin.builders.data.readFile({ file: Asset.File(fileOrUrl), isBinary })).data
             : await this.plugin.builders.data.download({ url: fileOrUrl, isBinary });
-        await this.handleTrajectory(data, format, props, matrix);
+        await this.handleTrajectory<P>(data, format, props, matrix, reprProvider, params);
     }
 
-    async parse(parse: ParseParams, props?: PresetProps & { dataLabel?: string }, matrix?: Mat4) {
+    async parse<P>(parse: ParseParams, props?: PresetProps & { dataLabel?: string }, matrix?: Mat4, reprProvider?: TrajectoryHierarchyPresetProvider, params?: P) {
         const { data, format } = parse;
         const _data = await this.plugin.builders.data.rawData({ data, label: props?.dataLabel });
-        await this.handleTrajectory(_data, format, props, matrix);
+        await this.handleTrajectory(_data, format, props, matrix, reprProvider, params);
     }
 
-    async handleTrajectory(data: any, format: BuiltInTrajectoryFormat, props?: PresetProps, matrix?: Mat4) {
+    private async handleTrajectory<P>(data: any, format: BuiltInTrajectoryFormat, props?: PresetProps, matrix?: Mat4, reprProvider?: TrajectoryHierarchyPresetProvider, params?: P) {
         const trajectory = await this.plugin.builders.structure.parseTrajectory(data, format);
-
-        const selector = await this.plugin.builders.structure.hierarchy.applyPreset(trajectory, RcsbPreset, {
-            preset: props || { kind: 'standard', assemblyId: '' }
-        });
-
-        if (matrix && selector?.structureProperties) {
-            const params = {
-                transform: {
-                    name: 'matrix' as const,
-                    params: { data: matrix, transpose: false }
-                }
-            };
-            const b = this.plugin.state.data.build().to(selector.structureProperties)
-                .insert(StateTransforms.Model.TransformStructureConformation, params);
-            await this.plugin.runTask(this.plugin.state.data.updateTree(b));
+        if(reprProvider){
+            await this.plugin.builders.structure.hierarchy.applyPreset(trajectory, reprProvider, {...params});
+        }else{
+            const selector = await this.plugin.builders.structure.hierarchy.applyPreset(trajectory, RcsbPreset, {
+                preset: props || { kind: 'standard', assemblyId: '' }
+            });
+
+            if (matrix && selector?.structureProperties) {
+                const params = {
+                    transform: {
+                        name: 'matrix' as const,
+                        params: { data: matrix, transpose: false }
+                    }
+                };
+                const b = this.plugin.state.data.build().to(selector.structureProperties)
+                    .insert(StateTransforms.Model.TransformStructureConformation, params);
+                await this.plugin.runTask(this.plugin.state.data.updateTree(b));
+            }
         }
+
     }
 
     constructor(private plugin: PluginContext) {

src/viewer/index.ts

@@ -37,6 +37,7 @@ import { PluginUIContext } from 'molstar/lib/mol-plugin-ui/context';
 import { ANVILMembraneOrientation, MembraneOrientationPreset } from 'molstar/lib/extensions/anvil/behavior';
 import { MembraneOrientationRepresentationProvider } from 'molstar/lib/extensions/anvil/representation';
 import {PluginContext} from 'molstar/lib/mol-plugin/context';
+import {TrajectoryHierarchyPresetProvider} from 'molstar/lib/mol-plugin-state/builder/structure/hierarchy-preset';
 
 /** package version, filled in at bundle build time */
 declare const __RCSB_MOLSTAR_VERSION__: string;
@@ -222,11 +223,11 @@ export class Viewer {
         return PluginCommands.State.RemoveObject(this._plugin, { state, ref: state.tree.root.ref });
     }
 
-    async loadPdbId(pdbId: string, props?: PresetProps, matrix?: Mat4) {
+    async loadPdbId<P>(pdbId: string, config?: {props?: PresetProps; matrix?: Mat4; reprProvider?: TrajectoryHierarchyPresetProvider, params?: P}) {
         for (const provider of this.modelUrlProviders) {
             try {
                 const p = provider(pdbId);
-                await this.customState.modelLoader.load({ fileOrUrl: p.url, format: p.format, isBinary: p.isBinary }, props, matrix);
+                await this.customState.modelLoader.load({ fileOrUrl: p.url, format: p.format, isBinary: p.isBinary }, config?.props, config?.matrix, config?.reprProvider, config?.params);
                 break;
             } catch (e) {
                 console.warn(`loading '${pdbId}' failed with '${e}', trying next model-loader-provider`);
@@ -234,23 +235,23 @@ export class Viewer {
         }
     }
 
-    async loadPdbIds(args: { pdbId: string, props?: PresetProps, matrix?: Mat4 }[]) {
-        for (const { pdbId, props, matrix } of args) {
-            await this.loadPdbId(pdbId, props, matrix);
+    async loadPdbIds<P>(args: { pdbId: string, config?: {props?: PresetProps; matrix?: Mat4; reprProvider?: TrajectoryHierarchyPresetProvider, params?: P} }[]) {
+        for (const { pdbId, config } of args) {
+            await this.loadPdbId(pdbId, config);
         }
         this.resetCamera(0);
     }
 
-    loadStructureFromUrl(url: string, format: BuiltInTrajectoryFormat, isBinary: boolean, props?: PresetProps, matrix?: Mat4) {
-        return this.customState.modelLoader.load({ fileOrUrl: url, format, isBinary }, props, matrix);
+    loadStructureFromUrl<P>(url: string, format: BuiltInTrajectoryFormat, isBinary: boolean, config?: {props?: PresetProps; matrix?: Mat4; reprProvider?: TrajectoryHierarchyPresetProvider, params?: P}) {
+        return this.customState.modelLoader.load({ fileOrUrl: url, format, isBinary }, config?.props, config?.matrix, config?.reprProvider, config?.params);
     }
 
     loadSnapshotFromUrl(url: string, type: PluginState.SnapshotType) {
         return PluginCommands.State.Snapshots.OpenUrl(this._plugin, { url, type });
     }
 
-    loadStructureFromData(data: string | number[], format: BuiltInTrajectoryFormat, isBinary: boolean, props?: PresetProps & { dataLabel?: string }, matrix?: Mat4) {
-        return this.customState.modelLoader.parse({ data, format, isBinary }, props, matrix);
+    loadStructureFromData<P>(data: string | number[], format: BuiltInTrajectoryFormat, isBinary: boolean, config?: {props?: PresetProps & { dataLabel?: string }; matrix?: Mat4; reprProvider?: TrajectoryHierarchyPresetProvider, params?: P}) {
+        return this.customState.modelLoader.parse({ data, format, isBinary }, config?.props, config?.matrix, config?.reprProvider, config?.params);
     }
 
     handleResize() {