change target props from snake_case to camelCase

CHANGELOG.md

@@ -9,7 +9,8 @@
 - Signature changes to `setFocus()`, `select()`, `clearSelection()`, and `createComponent()`
   - Effectively the overloaded methods were replaced by ones that use `Target` objects to reference residues/ranges
 - Merged `Range` into `Target`
-  - Renamed `label_seq_id` to `label_seq_range` (if referring to a range and not a single residue)
+  - 'CIF' fields are not represented as camelCase (`label_asym_id` to `labelAsymId`)
+  - 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[]`
 

src/viewer/helpers/preset.ts

@@ -177,13 +177,13 @@ export const RcsbPreset = TrajectoryHierarchyPresetProvider({
                     const colorValue = repr.value;
                     const targets = repr.targets;
                     for (const target of targets) {
-                        if (!target.label_asym_id) continue;
+                        if (!target.labelAsymId) continue;
 
-                        if (!structure.data!.inheritedPropertyData.colors[target.label_asym_id])
-                            structure.data!.inheritedPropertyData.colors[target.label_asym_id] = new Map();
-                        const residues: number[] = (target.label_seq_range) ? toRange(target.label_seq_range.beg, target.label_seq_range.end) : [];
+                        if (!structure.data!.inheritedPropertyData.colors[target.labelAsymId])
+                            structure.data!.inheritedPropertyData.colors[target.labelAsymId] = new Map();
+                        const residues: number[] = (target.labelSeqRange) ? toRange(target.labelSeqRange.beg, target.labelSeqRange.end) : [];
                         for (const num of residues) {
-                            structure.data!.inheritedPropertyData.colors[target.label_asym_id].set(num, colorValue);
+                            structure.data!.inheritedPropertyData.colors[target.labelAsymId].set(num, colorValue);
                         }
                     }
                 }
@@ -246,7 +246,7 @@ export const RcsbPreset = TrajectoryHierarchyPresetProvider({
         if ((p.kind === 'feature' || p.kind === 'feature-density') && structure?.obj) {
             let loci = targetToLoci(p.target, structure!.obj.data);
             // if target is only defined by chain: then don't force first residue
-            const chainMode = p.target.label_asym_id && !p.target.auth_seq_id && !p.target.label_seq_id && !p.target.label_comp_id;
+            const chainMode = p.target.labelAsymId && !p.target.authSeqId && !p.target.labelSeqId && !p.target.labelCompId;
             // HELP-16678: check for rare case where ligand is not present in requested assembly
             if (loci.elements.length === 0 && !!p.assemblyId) {
                 // switch to Model (a.k.a. show coordinates independent of assembly)
@@ -335,7 +335,7 @@ function determineAssemblyId(traj: any, p: MotifProps) {
     }
 
     // set of provided [struct_oper_id, label_asym_id] combinations
-    const ids = p.targets.map(t => [t.struct_oper_id || '1', t.label_asym_id!]).filter((x, i, a) => a.indexOf(x) === i);
+    const ids = p.targets.map(t => [t.structOperId || '1', t.labelAsymId!]).filter((x, i, a) => a.indexOf(x) === i);
 
     try {
         // find first assembly that contains all requested struct_oper_ids - if multiple, the first will be returned

src/viewer/helpers/selection.ts

@@ -11,20 +11,20 @@ export type Range = {
 }
 
 export type Target = {
-    readonly auth_seq_id?: number
-    // readonly auth_seq_range?: Range
-    readonly label_seq_id?: number
-    readonly label_seq_range?: Range
-    readonly label_comp_id?: string
-    // readonly auth_asym_id?: string
-    readonly label_asym_id?: string
+    readonly authSeqId?: number
+    // readonly authSeqRange?: Range
+    readonly labelSeqId?: number
+    readonly labelSeqRange?: Range
+    readonly labelCompId?: string
+    // readonly authAsymId?: string
+    readonly labelAsymId?: string
     /**
      * Mol*-internal UUID of a model.
      */
     readonly modelId?: string
     /**
-     * Mol*-internal representation, like 'ASM_2'. Enumerated in the order of appearance in the source file. Specify the
-     * assemblyId when using this selector.
+     * Mol*-internal representation, like 'ASM_2'. Enumerated in the order of appearance in the source file. If
+     * possible, specify the assemblyId when using this selector.
      */
     readonly operatorName?: string
     /**
@@ -32,18 +32,18 @@ export type Target = {
      * combination thereof. Specify the assemblyId when using this selector. Order matters, use order as specified in
      * the source CIF file.
      */
-    readonly struct_oper_id?: string
+    readonly structOperId?: string
 }
 
 export type SelectBase = {
     readonly modelId: string
-    readonly label_asym_id: string
+    readonly labelAsymId: string
 }
 export type SelectSingle = {
-    readonly label_seq_id: number
+    readonly labelSeqId: number
 } & SelectBase;
 export type SelectRange = {
-    readonly label_seq_range: Range
+    readonly labelSeqRange: Range
 } & SelectBase;
 export type SelectTarget = SelectSingle | SelectRange;
 
@@ -58,7 +58,7 @@ export type SelectionExpression = {
 
 /**
  * This serves as adapter between the strucmotif-/BioJava-approach to identify transformed chains and the Mol* way.
- * Looks for 'struct_oper_id', converts it to an 'operatorName', and removes the original value. This will
+ * Looks for 'structOperId', converts it to an 'operatorName', and removes the original value. This will
  * override pre-existing 'operatorName' values.
  * @param targets collection to process
  * @param structure parent structure
@@ -66,9 +66,9 @@ export type SelectionExpression = {
  */
 export function normalizeTargets(targets: Target[], structure: Structure, operatorName: string = 'ASM_1'): Target[] {
     return targets.map(t => {
-        if (t.struct_oper_id) {
-            const { struct_oper_id, ...others } = t;
-            const oper = toOperatorName(structure, struct_oper_id);
+        if (t.structOperId) {
+            const { structOperId, ...others } = t;
+            const oper = toOperatorName(structure, structOperId);
             return { ...others, operatorName: oper };
         }
         return t.operatorName ? t : { ...t, operatorName };
@@ -103,11 +103,11 @@ function toOperatorName(structure: Structure, expression: string): string {
  */
 export function createSelectionExpressions(labelBase: string, selection?: Target | Target[]): SelectionExpression[] {
     if (selection) {
-        if ('label_asym_id' in selection && 'label_seq_range' in selection) {
+        if ('labelAsymId' in selection && 'labelSeqRange' in selection) {
             const target = selection as Target;
-            const residues: number[] = (target.label_seq_range) ? toRange(target.label_seq_range!.beg, target.label_seq_range!.end) : [];
-            const test = rangeToTest(target.label_asym_id!, residues);
-            const label = labelFromProps(labelBase, target.label_asym_id, residues);
+            const residues: number[] = (target.labelSeqRange) ? toRange(target.labelSeqRange!.beg, target.labelSeqRange!.end) : [];
+            const test = rangeToTest(target.labelAsymId!, residues);
+            const label = labelFromProps(labelBase, target.labelAsymId, residues);
             return [{
                 expression: MS.struct.generator.atomGroups(test),
                 label: `${label}`,
@@ -174,8 +174,8 @@ export const toRange = (start: number, end?: number) => {
     return [...Array(e - b + 1)].map((_, i) => b + i);
 };
 
-const labelFromProps = (entryId: string, label_asym_id?: string, range?: number[]) => {
-    return entryId + (label_asym_id ? `.${label_asym_id}` : '') +
+const labelFromProps = (entryId: string, labelAsymId?: string, range?: number[]) => {
+    return entryId + (labelAsymId ? `.${labelAsymId}` : '') +
         (range && range.length > 0 ? `:${range[0]}` : '') +
         (range && range.length > 1 ? `-${range[range.length - 1]}` : '');
 };
@@ -208,15 +208,15 @@ function targetToExpression(target: Target): Expression {
     const chainTests: Expression[] = [];
     const tests: { 'residue-test': Expression, 'chain-test': Expression } = Object.create(null);
 
-    if (target.auth_seq_id) {
-        residueTests.push(MS.core.rel.eq([target.auth_seq_id, MS.ammp('auth_seq_id')]));
-    } else if (target.label_seq_id) {
-        residueTests.push(MS.core.rel.eq([target.label_seq_id, MS.ammp('label_seq_id')]));
-    }else if(target.label_seq_range){
-        residueTests.push(MS.core.rel.inRange([MS.ammp('label_seq_id'), target.label_seq_range.beg, target.label_seq_range.end ?? target.label_seq_range.beg]));
+    if (target.authSeqId) {
+        residueTests.push(MS.core.rel.eq([target.authSeqId, MS.ammp('auth_seq_id')]));
+    } else if (target.labelSeqId) {
+        residueTests.push(MS.core.rel.eq([target.labelSeqId, MS.ammp('label_seq_id')]));
+    }else if(target.labelSeqRange){
+        residueTests.push(MS.core.rel.inRange([MS.ammp('label_seq_id'), target.labelSeqRange.beg, target.labelSeqRange.end ?? target.labelSeqRange.beg]));
     }
-    if (target.label_comp_id) {
-        residueTests.push(MS.core.rel.eq([target.label_comp_id, MS.ammp('label_comp_id')]));
+    if (target.labelCompId) {
+        residueTests.push(MS.core.rel.eq([target.labelCompId, MS.ammp('label_comp_id')]));
     }
     if (residueTests.length === 1) {
         tests['residue-test'] = residueTests[0];
@@ -224,8 +224,8 @@ function targetToExpression(target: Target): Expression {
         tests['residue-test'] = MS.core.logic.and(residueTests);
     }
 
-    if (target.label_asym_id) {
-        chainTests.push(MS.core.rel.eq([target.label_asym_id, MS.ammp('label_asym_id')]));
+    if (target.labelAsymId) {
+        chainTests.push(MS.core.rel.eq([target.labelAsymId, MS.ammp('label_asym_id')]));
     }
     if (target.operatorName) {
         chainTests.push(MS.core.rel.eq([target.operatorName, MS.acp('operatorName')]));

src/viewer/helpers/superpose/flexible-structure.ts

@@ -32,22 +32,22 @@ const FlexibleStructureFromModel = PluginStateTransform.BuiltIn({
             const selectChains: string[] = [];
             const selectBlocks: Structure[][] = [];
             for (const target of targets) {
-                if (!target.label_asym_id) continue;
+                if (!target.labelAsymId) continue;
 
-                if (!selectChains.includes(target.label_asym_id)) {
-                    selectChains.push(target.label_asym_id);
+                if (!selectChains.includes(target.labelAsymId)) {
+                    selectChains.push(target.labelAsymId);
                     selectBlocks.push([]);
                 }
-                const residues: number[] = (target.label_seq_range) ? toRange(target.label_seq_range.beg, target.label_seq_range.end) : [];
-                const test = rangeToTest(target.label_asym_id, residues);
+                const residues: number[] = (target.labelSeqRange) ? toRange(target.labelSeqRange.beg, target.labelSeqRange.end) : [];
+                const test = rangeToTest(target.labelAsymId, residues);
                 const expression = MS.struct.generator.atomGroups(test);
                 const { selection: sele } = StructureQueryHelper.createAndRun(base.data, expression);
                 const s = StructureSelection.unionStructure(sele);
                 if (!target.matrix) {
-                    selectBlocks[selectChains.indexOf(target.label_asym_id)].push(s);
+                    selectBlocks[selectChains.indexOf(target.labelAsymId)].push(s);
                 } else {
                     const ts = Structure.transform(s, target.matrix);
-                    selectBlocks[selectChains.indexOf(target.label_asym_id)].push(ts);
+                    selectBlocks[selectChains.indexOf(target.labelAsymId)].push(ts);
                 }
             }
 

src/viewer/helpers/viewer.ts

@@ -45,7 +45,6 @@ export function getStructureRefWithModelId(structures: StructureRef[], target: {
 
 export function select(plugin: PluginContext, targets: SelectTarget | SelectTarget[], mode: 'select' | 'hover', modifier: 'add' | 'set') {
     for (const target of (Array.isArray(targets) ? targets : [targets])) {
-        // TODO are there performance implications when a large collection of residues is selected? - could move modelId out of 'target'
         const data = getStructureWithModelId(plugin.managers.structure.hierarchy.current.structures, target);
         if (!data) return;
 
@@ -80,13 +79,12 @@ export function clearSelection(plugin: PluginContext, mode: 'select' | 'hover',
 
 export async function createComponent(plugin: PluginContext, componentLabel: string, targets: SelectBase | SelectTarget | SelectTarget[], representationType: StructureRepresentationRegistry.BuiltIn) {
     for (const target of (Array.isArray(targets) ? targets : [targets])) {
-        // TODO are there performance implications when a large collection of residues is selected? - could move modelId out of 'target'
         const structureRef = getStructureRefWithModelId(plugin.managers.structure.hierarchy.current.structures, target);
         if (!structureRef) throw 'createComponent error: model not found';
 
         const residues = toResidues(target);
         const sel = StructureSelectionQuery('innerQuery_' + Math.random().toString(36).substr(2),
-            MS.struct.generator.atomGroups(rangeToTest(target.label_asym_id, residues)));
+            MS.struct.generator.atomGroups(rangeToTest(target.labelAsymId, residues)));
         await plugin.managers.structure.component.add({
             selection: sel,
             options: { checkExisting: false, label: componentLabel },
@@ -96,12 +94,12 @@ export async function createComponent(plugin: PluginContext, componentLabel: str
 }
 
 function toResidues(target: SelectBase | SelectTarget): number[] {
-    if ('label_seq_range' in target) {
-        return toRange(target.label_seq_range.beg, target.label_seq_range.end);
+    if ('labelSeqRange' in target) {
+        return toRange(target.labelSeqRange.beg, target.labelSeqRange.end);
     }
 
-    if ('label_seq_id' in target) {
-        return [target.label_seq_id];
+    if ('labelSeqId' in target) {
+        return [target.labelSeqId];
     }
 
     return [];