renamed StructureSelection-related transforms

src/apps/basic-wrapper/helpers.ts

@@ -33,18 +33,18 @@ export namespace StateHelper {
     };
 
     export function selectChain(b: StateBuilder.To<PSO.Molecule.Structure>, auth_asym_id: string) {
-        const query = MS.struct.generator.atomGroups({
+        const expression = MS.struct.generator.atomGroups({
             'chain-test': MS.core.rel.eq([MS.struct.atomProperty.macromolecular.auth_asym_id(), auth_asym_id])
         })
-        return b.apply(StateTransforms.Model.StructureSelection, { query, label: `Chain ${auth_asym_id}` });
+        return b.apply(StateTransforms.Model.StructureSelectionFromExpression, { expression, label: `Chain ${auth_asym_id}` });
     }
 
-    export function select(b: StateBuilder.To<PSO.Molecule.Structure>, query: Expression) {
-        return b.apply(StateTransforms.Model.StructureSelection, { query });
+    export function select(b: StateBuilder.To<PSO.Molecule.Structure>, expression: Expression) {
+        return b.apply(StateTransforms.Model.StructureSelectionFromExpression, { expression });
     }
 
     export function selectSurroundingsOfFirstResidue(b: StateBuilder.To<PSO.Molecule.Structure>, comp_id: string, radius: number) {
-        const query = MS.struct.modifier.includeSurroundings({
+        const expression = MS.struct.modifier.includeSurroundings({
             0: MS.struct.filter.first([
                 MS.struct.generator.atomGroups({
                     'residue-test': MS.core.rel.eq([MS.struct.atomProperty.macromolecular.label_comp_id(), comp_id]),
@@ -53,7 +53,7 @@ export namespace StateHelper {
             ]),
             radius
         })
-        return b.apply(StateTransforms.Model.StructureSelection, { query, label: `Surr. ${comp_id} (${radius} ang)` });
+        return b.apply(StateTransforms.Model.StructureSelectionFromExpression, { expression, label: `Surr. ${comp_id} (${radius} ang)` });
     }
 
     export function identityTransform(b: StateBuilder.To<PSO.Molecule.Structure>, m: Mat4) {
@@ -83,9 +83,9 @@ export namespace StateHelper {
         return visualRoot;
     }
 
-    export function ballsAndSticks(ctx: PluginContext, visualRoot: StateBuilder.To<PSO.Molecule.Structure>, query: Expression, coloring?: BuiltInColorThemeName) {
+    export function ballsAndSticks(ctx: PluginContext, visualRoot: StateBuilder.To<PSO.Molecule.Structure>, expression: Expression, coloring?: BuiltInColorThemeName) {
         visualRoot
-            .apply(StateTransforms.Model.StructureSelection, { query })
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression })
             .apply(StateTransforms.Representation.StructureRepresentation3D,
                 StructureRepresentation3DHelpers.getDefaultParamsStatic(ctx, 'ball-and-stick', void 0, coloring), { tags: 'het-visual' });
         return visualRoot;

src/apps/viewer/extensions/cellpack/model.ts

@@ -22,7 +22,6 @@ import { distinctColors } from '../../../../mol-util/color/distinct';
 import { ModelIndexColorThemeProvider } from '../../../../mol-theme/color/model-index';
 import { Hcl } from '../../../../mol-util/color/spaces/hcl';
 import { ParseCellPack, StructureFromCellpack, DefaultCellPackBaseUrl } from './state';
-import { formatMolScript } from '../../../../mol-script/language/expression-formatter';
 import { MolScriptBuilder as MS } from '../../../../mol-script/language/builder';
 import { getMatFromResamplePoints } from './curve';
 import { compile } from '../../../../mol-script/runtime/query/compiler';
@@ -244,10 +243,9 @@ export const LoadCellPackModel = StateAction.build({
                 ])
             })
             : MS.struct.generator.all()
-        const query = { language: 'mol-script' as const, expression: formatMolScript(expression) }
 
         tree.apply(StructureFromCellpack, p)
-            .apply(StateTransforms.Model.UserStructureSelection, { query })
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression }, { state: { isGhost: true } })
             .apply(StateTransforms.Representation.StructureRepresentation3D,
                 StructureRepresentation3DHelpers.createParams(ctx, Structure.Empty, {
                     repr: getReprParams(ctx, params.preset),

src/apps/viewer/extensions/jolecule.ts

@@ -93,32 +93,32 @@ function buildSnapshot(plugin: PluginContext, template: { tree: StateTree, struc
 
     let i = 0;
     for (const l of params.e.labels) {
-        const query = createQuery([l.i_atom]);
+        const expression = createExpression([l.i_atom]);
         const group = b.to(template.structure)
             .group(StateTransforms.Misc.CreateGroup, { label: `Label ${++i}` });
 
         group
-            .apply(StateTransforms.Model.StructureSelection, { query, label: 'Atom' })
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression, label: 'Atom' })
             .apply(StateTransforms.Representation.StructureLabels3D, {
                 target: { name: 'static-text', params: { value: l.text || '' } },
                 options: labelOptions
             });
 
         group
-            .apply(StateTransforms.Model.StructureSelection, { query: MS.struct.modifier.wholeResidues([query]), label: 'Residue' })
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression: MS.struct.modifier.wholeResidues([ expression ]), label: 'Residue' })
             .apply(StateTransforms.Representation.StructureRepresentation3D,
                 StructureRepresentation3DHelpers.getDefaultParamsStatic(plugin, 'ball-and-stick', {  }));
     }
     if (params.e.selected && params.e.selected.length > 0) {
         b.to(template.structure)
-            .apply(StateTransforms.Model.StructureSelection, { query: createQuery(params.e.selected), label: `Selected` })
+            .apply(StateTransforms.Model.StructureSelectionFromExpression, { expression: createExpression(params.e.selected), label: `Selected` })
             .apply(StateTransforms.Representation.StructureRepresentation3D,
                 StructureRepresentation3DHelpers.getDefaultParamsStatic(plugin, 'ball-and-stick'));
     }
     // TODO
     // for (const l of params.e.distances) {
     //     b.to('structure')
-    //         .apply(StateTransforms.Model.StructureSelection, { query: createQuery([l.i_atom1, l.i_atom2]), label: `Distance ${++i}` })
+    //         .apply(StateTransforms.Model.StructureSelectionFromExpression, { query: createQuery([l.i_atom1, l.i_atom2]), label: `Distance ${++i}` })
     //         .apply(StateTransforms.Representation.StructureLabels3D, {
     //             target: { name: 'static-text', params: { value: l. || '' } },
     //             options: labelOptions
@@ -159,7 +159,7 @@ function getCameraSnapshot(e: JoleculeSnapshot['camera']): Camera.Snapshot {
     return s;
 }
 
-function createQuery(atomIndices: number[]) {
+function createExpression(atomIndices: number[]) {
     if (atomIndices.length === 0) return MS.struct.generator.empty();
 
     return MS.struct.generator.atomGroups({

src/examples/proteopedia-wrapper/index.ts

@@ -359,9 +359,9 @@ class MolStarProteopediaWrapper {
 
             const group = update.to(StateElements.Assembly).group(StateTransforms.Misc.CreateGroup, { label: compId }, { ref: StateElements.HetGroupFocusGroup });
 
-            group.apply(StateTransforms.Model.StructureSelection, { label: 'Core', query: core }, { ref: StateElements.HetGroupFocus })
+            group.apply(StateTransforms.Model.StructureSelectionFromExpression, { label: 'Core', expression: core }, { ref: StateElements.HetGroupFocus })
                 .apply(StateTransforms.Representation.StructureRepresentation3D, this.createCoreVisualParams());
-            group.apply(StateTransforms.Model.StructureSelection, { label: 'Surroundings', query: surroundings })
+            group.apply(StateTransforms.Model.StructureSelectionFromExpression, { label: 'Surroundings', expression: surroundings })
                 .apply(StateTransforms.Representation.StructureRepresentation3D, this.createSurVisualParams());
             // sel.apply(StateTransforms.Representation.StructureLabels3D, {
             //     target: { name: 'residues', params: { } },

src/mol-plugin/behavior/dynamic/selection/structure-representation-interaction.ts

@@ -61,13 +61,13 @@ export class StructureRepresentationInteractionBehavior extends PluginBehavior.W
 
         // Selections
         if (!refs[Tags.ResidueSel]) {
-            refs[Tags.ResidueSel] = builder.to(refs['structure-interaction-group']).apply(StateTransforms.Model.StructureSelection,
-                { query: { } as any, label: 'Residue' }, { tags: Tags.ResidueSel }).ref;
+            refs[Tags.ResidueSel] = builder.to(refs['structure-interaction-group']).apply(StateTransforms.Model.StructureSelectionFromExpression,
+                { expression: { } as any, label: 'Residue' }, { tags: Tags.ResidueSel }).ref;
         }
 
         if (!refs[Tags.SurrSel]) {
-            refs[Tags.SurrSel] = builder.to(refs['structure-interaction-group']).apply(StateTransforms.Model.StructureSelection,
-                { query: { } as any, label: 'Surroundings' }, { tags: Tags.SurrSel }).ref;
+            refs[Tags.SurrSel] = builder.to(refs['structure-interaction-group']).apply(StateTransforms.Model.StructureSelectionFromExpression,
+                { expression: { } as any, label: 'Surroundings' }, { tags: Tags.SurrSel }).ref;
         }
 
         // Representations
@@ -91,14 +91,14 @@ export class StructureRepresentationInteractionBehavior extends PluginBehavior.W
         if (groups.length === 0) return;
 
         const update = state.build();
-        const query = MS.struct.generator.empty();
+        const expression = MS.struct.generator.empty();
         for (const g of groups) {
             // TODO: update props of the group node to ghost
 
             const res = StateSelection.findTagInSubtree(state.tree, g.transform.ref, Tags.ResidueSel);
             const surr = StateSelection.findTagInSubtree(state.tree, g.transform.ref, Tags.SurrSel);
-            if (res) update.to(res).update(StateTransforms.Model.StructureSelection, old => ({ ...old, query }));
-            if (surr) update.to(surr).update(StateTransforms.Model.StructureSelection, old => ({ ...old, query }));
+            if (res) update.to(res).update(StateTransforms.Model.StructureSelectionFromExpression, old => ({ ...old, expression }));
+            if (surr) update.to(surr).update(StateTransforms.Model.StructureSelectionFromExpression, old => ({ ...old, expression }));
         }
 
         PluginCommands.State.Update.dispatch(this.plugin, { state, tree: update, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
@@ -166,8 +166,8 @@ export class StructureRepresentationInteractionBehavior extends PluginBehavior.W
 
             const { state, builder, refs } = this.ensureShape(parent);
 
-            builder.to(refs[Tags.ResidueSel]!).update(StateTransforms.Model.StructureSelection, old => ({ ...old, query: core }));
-            builder.to(refs[Tags.SurrSel]!).update(StateTransforms.Model.StructureSelection, old => ({ ...old, query: surroundings }));
+            builder.to(refs[Tags.ResidueSel]!).update(StateTransforms.Model.StructureSelectionFromExpression, old => ({ ...old, expression: core }));
+            builder.to(refs[Tags.SurrSel]!).update(StateTransforms.Model.StructureSelectionFromExpression, old => ({ ...old, expression: surroundings }));
 
             PluginCommands.State.Update.dispatch(this.plugin, { state, tree: builder, options: { doNotLogTiming: true, doNotUpdateCurrent: true } });
         });

src/mol-plugin/index.ts

@@ -46,7 +46,7 @@ export const DefaultPluginSpec: PluginSpec = {
         PluginSpec.Action(StateTransforms.Model.StructureFromModel),
         PluginSpec.Action(StateTransforms.Model.StructureFromTrajectory),
         PluginSpec.Action(StateTransforms.Model.ModelFromTrajectory),
-        PluginSpec.Action(StateTransforms.Model.UserStructureSelection),
+        PluginSpec.Action(StateTransforms.Model.StructureSelectionFromScript),
         PluginSpec.Action(StateTransforms.Representation.StructureRepresentation3D),
         PluginSpec.Action(StateTransforms.Representation.StructureLabels3D),
         PluginSpec.Action(StateTransforms.Representation.ExplodeStructureRepresentation3D),

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

@@ -12,7 +12,7 @@ import { PluginStateObject } from '../objects';
 import { StateTransforms } from '../transforms';
 import { Download } from '../transforms/data';
 import { StructureRepresentation3DHelpers } from '../transforms/representation';
-import { CustomModelProperties, StructureSelection, CustomStructureProperties } from '../transforms/model';
+import { CustomModelProperties, StructureSelectionFromExpression, CustomStructureProperties } from '../transforms/model';
 import { DataFormatProvider, guessCifVariant, DataFormatBuilderOptions } from './data-format';
 import { FileInfo } from '../../../mol-util/file-info';
 import { Task } from '../../../mol-task';
@@ -355,7 +355,7 @@ export const StructureFromSelection = StateAction.build({
     const sel = plugin.helpers.structureSelectionManager.get(a.data);
     if (sel.kind === 'empty-loci') return Task.constant('', void 0);
 
-    const query = StructureElement.Loci.toScriptExpression(sel);
-    const root = state.build().to(ref).apply(StructureSelection, { query, label: params.label });
+    const expression = StructureElement.Loci.toScriptExpression(sel);
+    const root = state.build().to(ref).apply(StructureSelectionFromExpression, { expression, label: params.label });
     return state.updateTree(root);
 });

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

@@ -39,9 +39,9 @@ export { StructureAssemblyFromModel };
 export { StructureSymmetryFromModel };
 export { TransformStructureConformation };
 export { TransformStructureConformationByMatrix };
-export { StructureSelection };
-export { UserStructureSelection };
-export { BundleStructureSelection as LociStructureSelection };
+export { StructureSelectionFromExpression };
+export { StructureSelectionFromScript };
+export { StructureSelectionFromBundle };
 export { StructureComplexElement };
 export { CustomModelProperties };
 export { CustomStructureProperties };
@@ -346,19 +346,19 @@ const TransformStructureConformationByMatrix = PluginStateTransform.BuiltIn({
     }
 });
 
-type StructureSelection = typeof StructureSelection
-const StructureSelection = PluginStateTransform.BuiltIn({
-    name: 'structure-selection',
-    display: { name: 'Structure Selection', description: 'Create a molecular structure from the specified query expression.' },
+type StructureSelectionFromExpression = typeof StructureSelectionFromExpression
+const StructureSelectionFromExpression = PluginStateTransform.BuiltIn({
+    name: 'structure-selection-from-expression',
+    display: { name: 'Structure Selection', description: 'Create a molecular structure from the specified expression.' },
     from: SO.Molecule.Structure,
     to: SO.Molecule.Structure,
     params: {
-        query: PD.Value<Expression>(MolScriptBuilder.struct.generator.all, { isHidden: true }),
+        expression: PD.Value<Expression>(MolScriptBuilder.struct.generator.all, { isHidden: true }),
         label: PD.Optional(PD.Text('', { isHidden: true }))
     }
 })({
     apply({ a, params, cache }) {
-        const compiled = compile<Sel>(params.query);
+        const compiled = compile<Sel>(params.expression);
         (cache as { compiled: QueryFn<Sel> }).compiled = compiled;
         (cache as { source: Structure }).source = a.data;
 
@@ -369,7 +369,7 @@ const StructureSelection = PluginStateTransform.BuiltIn({
         return new SO.Molecule.Structure(s, props);
     },
     update: ({ a, b, oldParams, newParams, cache }) => {
-        if (oldParams.query !== newParams.query) return StateTransformer.UpdateResult.Recreate;
+        if (oldParams.expression !== newParams.expression) return StateTransformer.UpdateResult.Recreate;
 
         if ((cache as { source: Structure }).source === a.data) {
             return StateTransformer.UpdateResult.Unchanged;
@@ -383,19 +383,19 @@ const StructureSelection = PluginStateTransform.BuiltIn({
     }
 });
 
-type UserStructureSelection = typeof UserStructureSelection
-const UserStructureSelection = PluginStateTransform.BuiltIn({
-    name: 'user-structure-selection',
-    display: { name: 'Structure Selection', description: 'Create a molecular structure from the specified query expression string.' },
+type StructureSelectionFromScript = typeof StructureSelectionFromScript
+const StructureSelectionFromScript = PluginStateTransform.BuiltIn({
+    name: 'structure-selection-from-script',
+    display: { name: 'Structure Selection', description: 'Create a molecular structure from the specified script.' },
     from: SO.Molecule.Structure,
     to: SO.Molecule.Structure,
     params: {
-        query: PD.ScriptExpression({ language: 'mol-script', expression: '(sel.atom.atom-groups :residue-test (= atom.resname ALA))' }),
+        script: PD.ScriptExpression({ language: 'mol-script', expression: '(sel.atom.atom-groups :residue-test (= atom.resname ALA))' }),
         label: PD.Optional(PD.Text(''))
     }
 })({
     apply({ a, params, cache }) {
-        const parsed = parseMolScript(params.query.expression);
+        const parsed = parseMolScript(params.script.expression);
         if (parsed.length === 0) throw new Error('No query');
         const query = transpileMolScript(parsed[0]);
         const compiled = compile<Sel>(query);
@@ -408,7 +408,7 @@ const UserStructureSelection = PluginStateTransform.BuiltIn({
         return new SO.Molecule.Structure(s, props);
     },
     update: ({ a, b, oldParams, newParams, cache }) => {
-        if (oldParams.query.language !== newParams.query.language || oldParams.query.expression !== newParams.query.expression) {
+        if (oldParams.script.language !== newParams.script.language || oldParams.script.expression !== newParams.script.expression) {
             return StateTransformer.UpdateResult.Recreate;
         }
 
@@ -435,9 +435,9 @@ function updateStructureFromQuery(query: QueryFn<Sel>, src: Structure, obj: SO.M
     return true;
 }
 
-type BundleStructureSelection = typeof BundleStructureSelection
-const BundleStructureSelection = PluginStateTransform.BuiltIn({
-    name: 'bundle-structure-selection',
+type StructureSelectionFromBundle = typeof StructureSelectionFromBundle
+const StructureSelectionFromBundle = PluginStateTransform.BuiltIn({
+    name: 'structure-selection-from-bundle',
     display: { name: 'Structure Selection', description: 'Create a molecular structure from the specified structure-element bundle.' },
     from: SO.Molecule.Structure,
     to: SO.Molecule.Structure,

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

@@ -75,7 +75,7 @@ export class StructureRepresentationHelper {
 
             update.to(structure.transform.ref)
                 .apply(
-                    StateTransforms.Model.LociStructureSelection,
+                    StateTransforms.Model.StructureSelectionFromBundle,
                     { bundle: StructureElement.Bundle.fromLoci(combinedLoci), label: type },
                     { tags: [ RepresentationManagerTag, getRepresentationManagerTag(type) ] }
                 )