@datagrok/sequence-translator 1.5.0 → 1.5.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "author": {
     "name": "Leonid Stolbov",
     "email": "lstolbov@datagrok.ai"

package/src/package.ts

@@ -301,6 +301,9 @@ export async function ptEnumeratorChemApp(): Promise<void> {
 //input: column col
 //input: string separator
 export function applyNotationProviderForCyclized(col: DG.Column<string>, separator: string) {
+  col.setTag('aligned', 'SEQ');
+  col.setTag('alphabet', 'UN');
+  col.setTag('.alphabetIsMultichar', 'true');
   col.meta.units = NOTATION.CUSTOM;
   col.tags[PolyToolTags.dataRole] = 'template';
   col.temp[SeqTemps.notationProvider] = new CyclizedNotationProvider(separator, _package.helmHelper);

package/src/polytool/conversion/pt-misc.ts

@@ -179,10 +179,20 @@ export async function getOverriddenLibrary(rules: Rules): Promise<IMonomerLibBas
   const rdkit = await getRdKitModule();
   const argLib: { [symbol: string]: Monomer } = {};
 
+  let names: string [] = [];
+  let monomers: Monomer [] = [];
+
   for (let i = 0; i < rules.reactionRules.length; i++) {
-    const [names, monomers] = getNewMonomers(rdkit, systemMonomerLib, rules.reactionRules[i]);
-    for (let j = 0; j < names.length; j ++)
-      argLib[names[j]] = monomers[j];
+    try {
+      [names, monomers] = getNewMonomers(rdkit, systemMonomerLib, rules.reactionRules[i]);
+    } catch (e: any) {
+      names = [];
+      monomers = [];
+      console.error(e);
+    } finally {
+      for (let j = 0; j < names.length; j ++)
+        argLib[names[j]] = monomers[j];
+    }
   }
 
   const overrideMonomerLibData: MonomerLibData = {[PolymerTypes.PEPTIDE]: argLib};

package/src/polytool/conversion/pt-rules.ts

@@ -31,7 +31,9 @@ export class RuleInputs extends ActiveFiles {
     const editIcon = ui.icons.edit(async () => {
       const rulesManager = await RulesManager.getInstance(available);
       //await rulesManager.show();
-      grok.shell.addView(await rulesManager.getView());
+      // close the dialogs, its easier if we just close it from active dialogs with filtering
+      DG.Dialog.getOpenDialogs()?.filter((d) => d.root.contains(editIcon)).forEach((d) => d.close());
+      await rulesManager.getAndAddView();
     }, 'Edit rules');
 
     res.addOptions(editIcon);

package/src/polytool/conversion/rule-manager.ts

@@ -11,14 +11,15 @@ export class RulesManager {
   linkRuleDataFrame: DG.DataFrame;
   synthRuleDataFrame: DG.DataFrame;
   fileName: string;
-  v: DG.View | null = null;
+  private v: DG.ViewBase | null = null;
 
   homoDimerInput: DG.InputBase;
   heteroDimerInput: DG.InputBase;
 
   currentTab = '';
 
-  private static instance: RulesManager;
+  // every rule set will have its editor instance
+  private static instances: Record<string, RulesManager> = {};
 
   protected constructor(rules: Rules, fileName: string) {
     this.rules = rules;
@@ -34,21 +35,43 @@ export class RulesManager {
     );
   }
 
-  async getView(): Promise<DG.ViewBase> {
+  async getAndAddView(): Promise<DG.ViewBase> {
+    if (this.v) {
+      try {
+        //find active view; name is unique due to file names in name
+        const activeView = Array.from(grok.shell.views).find((v) => v.name === this.v!.name);
+        if (!activeView) {
+          this.v.detach();
+          this.v.close();
+          throw new Error('View is closed, making it null in catch statement');
+        }
+        // switch to existing view
+        grok.shell.v = activeView;
+      } catch (_) {
+        //here we only come if some error is caused due to double detaching, so no handling needed
+        this.v = null;
+      }
+    }
+
     if (!this.v) {
       this.v = DG.View.create();
+      this.v.name = `Manage Polytool Rules - ${this.fileName}`;
       this.v.append(await this.getForm());
+      this.v = grok.shell.addView(this.v);
+      grok.shell.v = this.v!; // just in any case, to make sure it switches
+      return this.v;
     }
 
     return this.v;
   }
 
   public static async getInstance(name: string): Promise<RulesManager> {
-    if (!this.instance) {
+    // every rull will have its own instance
+    if (!this.instances[name]) {
       const rules = await getRules([name]);
-      this.instance = new RulesManager(rules, name);
+      this.instances[name] = new RulesManager(rules, name);
     }
-    return this.instance;
+    return this.instances[name]!;
   }
 
   save(): void {
@@ -94,8 +117,8 @@ export class RulesManager {
     const initCol = DG.Column.fromStrings('monomers', seqs);
     const helmCol = DG.Column.fromStrings('helm', helms);
 
-    initCol.semType = DG.SEMTYPE.MACROMOLECULE;
     applyNotationProviderForCyclized(initCol, '-');
+    initCol.semType = DG.SEMTYPE.MACROMOLECULE;
 
     helmCol.semType = DG.SEMTYPE.MACROMOLECULE;
     helmCol.meta.units = NOTATION.HELM;
@@ -112,7 +135,7 @@ export class RulesManager {
       const code = this.rules.reactionRules[i].code;
       const [firstMonomers, secondMonomers] = getMonomerPairs(this.rules.reactionRules[i]);
       for (let j = 0; j < firstMonomers.length; j++) {
-        const seq = `${firstMonomers[j]}(${code})-A-A-A-A-${secondMonomers[j]}(${code})-A`;
+        const seq = `${firstMonomers[j]}(${code})-A-A-A-A-${secondMonomers[j]}(${code})`;
         seqs.push(seq);
       }
     }