@datagrok/sequence-translator 1.10.8 → 1.10.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/sequence-translator",
   "friendlyName": "Sequence Translator",
-  "version": "1.10.8",
+  "version": "1.10.9",
   "author": {
     "name": "Davit Rizhinashvili",
     "email": "drizhinashvili@datagrok.ai"
@@ -22,7 +22,7 @@
     }
   ],
   "dependencies": {
-    "@datagrok-libraries/bio": "^5.61.6",
+    "@datagrok-libraries/bio": "^5.62.0",
     "@datagrok-libraries/chem-meta": "^1.2.8",
     "@datagrok-libraries/tutorials": "^1.6.1",
     "@datagrok-libraries/utils": "^4.6.5",

package/src/demo/demo-st-ui.ts

@@ -2,7 +2,6 @@ import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
-import {delay} from '@datagrok-libraries/test/src/test';
 import {PackageFunctions} from '../package';
 import {tryCatch} from '../apps/common/model/helpers';
 
@@ -23,7 +22,7 @@ export async function demoOligoPatternUI() {
 export async function demoOligoStructureUI() {
   await tryCatch(async () => {
     async function setInputValue(idx: number, sequence: string): Promise<void> {
-      await delay(500);
+      await DG.delay(500);
       const textInputs: NodeListOf<HTMLTextAreaElement> = document.querySelectorAll('.st-colored-text-input > textarea');
       const textarea = textInputs[idx];
       textarea.value = sequence;

package/src/polytool/const.ts

@@ -45,5 +45,4 @@ export const PT_ENUM_TYPE_TOOLTIPS: Record<string, string> = {
   'single': 'Each position is enumerated independently. Total results = sum of monomers across all positions.',
   'parallel': 'The i-th result uses the i-th monomer from every position (zip). All positions must have the same number of monomers. Total results = number of monomers per position.',
   'matrix': 'Cartesian product of all positions. Total results = product of monomer counts across all positions.',
-  'library': 'Substitutes all monomers from a selected library at a single position.',
 };

package/src/polytool/pt-enumerate-seq-dialog.ts

@@ -22,7 +22,6 @@ import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
 import {SeqTemps} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
 
 import {PolyToolEnumeratorParams, PolyToolEnumeratorType, PolyToolEnumeratorTypes} from './types';
-import {getLibrariesList, LIB_PATH} from './utils';
 import {doPolyToolEnumerateHelm, PT_HELM_EXAMPLE} from './pt-enumeration-helm';
 import {PolyToolPlaceholdersInput} from './pt-placeholders-input';
 import {showMonomerSelectionDialog} from './pt-monomer-selection-dialog';
@@ -47,7 +46,7 @@ import {INotationProvider, NotationProviderBase} from '@datagrok-libraries/bio/s
  *
  * Provides the UI for enumerating macromolecule variants. The user selects positions
  * on a HELM molecule and specifies substitute monomers at each position. Supports
- * multiple enumeration strategies (Single, Parallel, Matrix, Library) and optional
+ * multiple enumeration strategies (Single, Parallel, Matrix) and optional
  * downstream processing (atomic-level conversion, chirality, rules).
  *
  * Architecture:
@@ -67,7 +66,6 @@ type PolyToolEnumerateInputs = {
   generateHelm: DG.InputBase<boolean>;
   chiralityEngine: DG.InputBase<boolean>;
   highlightMonomers: DG.InputBase<boolean>;
-  library: DG.InputBase<string>;
   rules: { header: HTMLElement, form: HTMLDivElement },
 };
 
@@ -84,7 +82,6 @@ type PolyToolEnumerateHelmSerialized = {
   chiralityEngine: boolean;
   highlightMonomers: boolean;
   rules: string[],
-  library: string;
 };
 
 /** Entry point: creates, sizes, and shows the enumeration dialog. */
@@ -163,7 +160,6 @@ async function getPolyToolEnumerateDialog(
   const logPrefix = `ST: PT: HelmDialog()`;
   let inputs: PolyToolEnumerateInputs;
   const subs: Unsubscribable[] = [];
-  // Track previous enumeration type to clean up state when switching to/from Library mode
   let prevEnumerationType: PolyToolEnumeratorType = PolyToolEnumeratorTypes.Single;
   const destroy = () => {
     for (const sub of subs) sub.unsubscribe();
@@ -176,7 +172,7 @@ async function getPolyToolEnumerateDialog(
     const seqHelper = await getSeqHelper();
     const emptyDf: DG.DataFrame = DG.DataFrame.fromColumns([]);
 
-    const [_libList, helmHelper] = await Promise.all([getLibrariesList(), getHelmHelper()]);
+    const helmHelper = await getHelmHelper();
     const monomerLibFuncs = helmHelper.buildMonomersFuncsFromLib(monomerLib);
 
     // Resolves the source macromolecule from the given cell or falls back to a default example.
@@ -310,7 +306,6 @@ async function getPolyToolEnumerateDialog(
           },
           nullable: true,
         }),
-      library: ui.input.choice('Monomer Library', {items: _libList, value: _libList[0], nullable: true}) as DG.InputBase<string>,
     };
     // #### Inputs END
 
@@ -321,7 +316,6 @@ async function getPolyToolEnumerateDialog(
     };
     updateEnumTypeTooltip();
 
-    inputs.library.root.style.setProperty('display', 'none');
     inputs.trivialNameCol.addOptions(trivialNameSampleDiv);
 
     // Wire up monomer cell double-click to open selection dialog
@@ -332,7 +326,7 @@ async function getPolyToolEnumerateDialog(
       const atom = mol.atoms[position];
       const helmType: HelmType = atom.biotype()!;
       const polymerType = helmTypeToPolymerType(helmType);
-      return showMonomerSelectionDialog(monomerLib, polymerType, currentMonomers);
+      return showMonomerSelectionDialog(monomerLib, polymerType, currentMonomers, libHelper);
     };
 
     // Wire up breadth monomer cell double-click to open selection dialog
@@ -345,7 +339,7 @@ async function getPolyToolEnumerateDialog(
       const atom = mol.atoms[start];
       const helmType: HelmType = atom.biotype()!;
       const polymerType = helmTypeToPolymerType(helmType);
-      return showMonomerSelectionDialog(monomerLib, polymerType, currentMonomers);
+      return showMonomerSelectionDialog(monomerLib, polymerType, currentMonomers, libHelper);
     };
 
     // === VALIDATORS ===
@@ -356,20 +350,6 @@ async function getPolyToolEnumerateDialog(
       const errors: string[] = [];
       setTimeout(() => { updateWarnings(); }, 100);
       try {
-        // for library, ony one placeholder is allowed
-        if (inputs.enumeratorType.value === PolyToolEnumeratorTypes.Library) {
-          const pcs = inputs.placeholders.placeholdersValue;
-          if (pcs.length > 1)
-            placeholdersValidity = 'Only one placeholder is allowed for Library mode';
-          if (pcs.length === 1) {
-            if (pcs[0].position == null)
-              placeholdersValidity = 'Position is required for Library mode';
-            if (pcs[0].position > inputs.macromolecule.molValue.atoms.length)
-              placeholdersValidity = `There is no monomer at position ${pcs[0].position + 1}.`;
-          }
-          return placeholdersValidity;
-        }
-
         // Parallel mode: all placeholders must have the same monomer count
         if (inputs.enumeratorType.value === PolyToolEnumeratorTypes.Parallel) {
           const pcs = inputs.placeholders.placeholdersValue;
@@ -480,32 +460,7 @@ async function getPolyToolEnumerateDialog(
     //   return placeholdersValidity;
     // });
 
-    inputs.library.addValidator((_value) => {
-      if (inputs.enumeratorType.value === PolyToolEnumeratorTypes.Library && !inputs.library.value)
-        return 'Monomer Library is required for this enumerator type';
-      return null;
-    });
-
-    inputs.library.onChanged.subscribe(() => {
-      if (inputs.enumeratorType.value === PolyToolEnumeratorTypes.Library)
-        inputs.placeholders.setMonomersValue(0, inputs.library.value ?? '');
-    });
-
     inputs.enumeratorType.onChanged.subscribe((_) => {
-      const isLibraryModeChosen = inputs.enumeratorType.value === PolyToolEnumeratorTypes.Library;
-      inputs.library.root.style.setProperty('display', isLibraryModeChosen ? 'flex' : 'none');
-      try {
-        if ((prevEnumerationType !== PolyToolEnumeratorTypes.Library && isLibraryModeChosen) || (prevEnumerationType === PolyToolEnumeratorTypes.Library && !isLibraryModeChosen)) {
-          const prevSinglePosition = inputs.placeholders.placeholdersValue.length === 1 ? inputs.placeholders.placeholdersValue[0].position : null;
-          // clear the placeHolders input and helm inputs if switching happened to/from Library mode
-          inputs.placeholders.clearInput();
-          inputs.placeholdersBreadth.clearInput();
-          if (isLibraryModeChosen && prevSinglePosition != null)
-            inputs.placeholders.addPosition(prevSinglePosition, inputs.library.value ?? '');
-        }
-      } catch (err: any) {
-        defaultErrorHandler(err, false);
-      }
       prevEnumerationType = inputs.enumeratorType.value;
       updateEnumTypeTooltip();
       // Re-validate placeholders (Parallel mode has different constraints than Single/Matrix)
@@ -550,13 +505,7 @@ async function getPolyToolEnumerateDialog(
         const clickedAtom = helmHelper.getHoveredAtom(argsX, argsY, mol, inputs.macromolecule.root.clientHeight);
         if (clickedAtom) {
           const clickedAtomContIdx = clickedAtom._parent.atoms.indexOf(clickedAtom);
-          const clickedAtomContIdxStr = String(clickedAtomContIdx + 1);
-          let monomerValue = '';
-          if (inputs.enumeratorType.value === PolyToolEnumeratorTypes.Library) {
-            inputs.placeholders.clearInput();
-            monomerValue = inputs.library.value ?? '';
-          }
-          inputs.placeholders.addPosition(clickedAtomContIdx, monomerValue);
+          inputs.placeholders.addPosition(clickedAtomContIdx, '');
         }
       } catch (err: any) {
         defaultErrorHandler(err);
@@ -660,23 +609,10 @@ async function getPolyToolEnumerateDialog(
     updateViewRules();
 
     // === EXECUTION (OK button handler) ===
-    // Pre-flight validates inputs, resolves Library mode, builds params, and runs enumeration.
+    // Pre-flight validates inputs, builds params, and runs enumeration.
     const exec = async (): Promise<void> => {
       try {
         const srcHelm = inputs.macromolecule.stringValue;
-        const helmSelections = wu.enumerate<HelmAtom>(inputs.macromolecule.molValue.atoms)
-          .filter(([a, aI]) => a.highlighted)
-          .map(([a, aI]) => a).toArray();
-        if (inputs.enumeratorType.value === PolyToolEnumeratorTypes.Library) {
-          if (helmSelections.length === 0) {
-            grok.shell.warning('PolyTool: position for enumeration was not selected');
-            return;
-          }
-          if (!inputs.library.value) {
-            grok.shell.warning('PolyTool: No monomer library was selected');
-            return;
-          }
-        }
         if (srcHelm === undefined || srcHelm === '') {
           grok.shell.warning('PolyTool: no molecule was provided');
         } else {
@@ -689,28 +625,7 @@ async function getPolyToolEnumerateDialog(
           await getHelmHelper(); // initializes JSDraw and org
 
           const placeHoldersValue = inputs.placeholders.placeholdersValue;
-          // Library mode: load all monomers from the selected library and convert to Single mode
-          let enumerationType = inputs.enumeratorType.value;
-          if (enumerationType === PolyToolEnumeratorTypes.Library) {
-            if (placeHoldersValue.length !== 1) {
-              grok.shell.warning('Only one placeholder is allowed for Library mode');
-              return;
-            }
-            if (!placeHoldersValue[0].monomers || !_libList.includes(placeHoldersValue[0].monomers[0])) {
-              grok.shell.warning('Valid Monomer Library is required for this enumerator type');
-              return;
-            }
-            const monLibName = placeHoldersValue[0].monomers[0];
-            const monLib = await libHelper.readSingleLibraryByName(monLibName);
-            if (!monLib) {
-              grok.shell.warning(`Monomer Library '${monLibName}' was not found`);
-              return;
-            }
-            const polymerType = helmTypeToPolymerType(helmSelections[0].biotype() ?? 'HELM_AA');
-            const peptideMonomers = monLib.getMonomerSymbolsByType(polymerType);
-            placeHoldersValue[0].monomers = peptideMonomers;
-            enumerationType = PolyToolEnumeratorTypes.Single;
-          }
+          const enumerationType = inputs.enumeratorType.value;
 
           if (enumerationType === PolyToolEnumeratorTypes.Parallel) {
             const nonEmpty = placeHoldersValue.filter((ph) => ph.monomers.length > 0);
@@ -762,7 +677,7 @@ async function getPolyToolEnumerateDialog(
       .add(ui.divH([
         ui.divV([
           inputs.placeholders.root,
-          inputs.enumeratorType.root, inputs.library.root],
+          inputs.enumeratorType.root],
         {style: {width: '50%'}}
         ),
         ui.divV([
@@ -810,7 +725,6 @@ async function getPolyToolEnumerateDialog(
           chiralityEngine: inputs.chiralityEngine.value,
           highlightMonomers: inputs.highlightMonomers.value,
           rules: ruleFileList,
-          library: inputs.library.value,
         };
       },
       /* applyInput */ (x: PolyToolEnumerateHelmSerialized): void => {
@@ -825,7 +739,6 @@ async function getPolyToolEnumerateDialog(
         inputs.chiralityEngine.value = x.chiralityEngine ?? false;
         inputs.highlightMonomers.value = x.highlightMonomers ?? false;
         ruleInputs.setActive(x.rules);
-        inputs.library.value = x.library;
         setTimeout(() => {
           inputs.placeholders.invalidateGrid();
           inputs.placeholdersBreadth.invalidateGrid();

package/src/polytool/pt-monomer-selection-dialog.ts

@@ -3,17 +3,19 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {HelmType, PolymerType} from '@datagrok-libraries/bio/src/helm/types';
-import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/monomer-library';
+import {IMonomerLib, IMonomerLibHelper, Monomer} from '@datagrok-libraries/bio/src/types/monomer-library';
 import {polymerTypeToHelmType} from '@datagrok-libraries/bio/src/utils/macromolecule/utils';
 
 import {parseMonomerSymbolList} from './pt-placeholders-input';
 
 const MAX_SUGGESTIONS = 20;
 
-/** Shows a dialog for selecting monomers with autocomplete and tag-based display.
- * @returns comma-separated monomer symbols, or null if cancelled */
+/** Shows a dialog for selecting monomers with autocomplete, tag-based display,
+ * and bulk-add from monomer libraries or collections.
+ * @returns monomer symbols array, or null if cancelled */
 export async function showMonomerSelectionDialog(
   monomerLib: IMonomerLib, polymerType: PolymerType, presetMonomers?: string[],
+  libHelper?: IMonomerLibHelper,
 ): Promise<string[] | null> {
   return new Promise<string[] | null>((resolve) => {
     const helmType: HelmType = polymerTypeToHelmType(polymerType);
@@ -21,11 +23,19 @@ export async function showMonomerSelectionDialog(
 
     const selectedMonomers: string[] = presetMonomers ? [...presetMonomers] : [];
 
-    const tagsHost = ui.div([], {style: {display: 'flex', flexWrap: 'wrap', gap: '4px', marginTop: '8px', maxWidth: '400px'}});
-    const input = ui.input.string('Monomers', {value: ''});
+    // --- Tags display (selected monomers) ---
+    const tagsHost = ui.div([], {style: {display: 'flex', flexWrap: 'wrap', gap: '4px', marginTop: '4px', maxHeight: '150px', overflowY: 'auto'}});
+    const countLabel = ui.divText('', {style: {fontSize: '11px', color: 'var(--grey-4)', marginTop: '4px'}});
+
+    function updateCountLabel(): void {
+      countLabel.textContent = selectedMonomers.length > 0 ? `${selectedMonomers.length} monomer(s) selected` : '';
+    }
+
+    // --- Autocomplete input ---
+    const input = ui.input.string('Search', {value: ''});
     const inputEl = input.input as HTMLInputElement;
     inputEl.setAttribute('autocomplete', 'off');
-    inputEl.placeholder = 'Type to search...';
+    inputEl.placeholder = 'Type to search monomers...';
 
     let currentMenu: DG.Menu | null = null;
     let menuItems: HTMLElement[] = [];
@@ -39,6 +49,7 @@ export async function showMonomerSelectionDialog(
           if (idx >= 0) {
             selectedMonomers.splice(idx, 1);
             renderTags();
+            updateCountLabel();
           }
         });
         removeBtn.style.marginLeft = '4px';
@@ -53,7 +64,7 @@ export async function showMonomerSelectionDialog(
           },
         });
         // Tooltip on hover
-        tag.addEventListener('mouseenter', (e) => {
+        tag.addEventListener('mouseenter', () => {
           const tooltip = monomerLib.getTooltip(helmType, symbol);
           ui.tooltip.show(tooltip, tag.getBoundingClientRect().left, tag.getBoundingClientRect().bottom + 16);
         });
@@ -61,6 +72,7 @@ export async function showMonomerSelectionDialog(
 
         tagsHost.appendChild(tag);
       }
+      updateCountLabel();
     }
 
     function addMonomer(symbol: string): void {
@@ -73,6 +85,18 @@ export async function showMonomerSelectionDialog(
       inputEl.focus();
     }
 
+    function addMonomers(symbols: string[]): void {
+      let added = false;
+      for (const symbol of symbols) {
+        if (!selectedMonomers.includes(symbol)) {
+          selectedMonomers.push(symbol);
+          added = true;
+        }
+      }
+      if (added)
+        renderTags();
+    }
+
     function hideMenu(): void {
       if (currentMenu) {
         currentMenu.hide();
@@ -222,14 +246,105 @@ export async function showMonomerSelectionDialog(
       }
     });
 
+    // --- Bulk add: from monomer library ---
+    const librarySection = ui.div([], {style: {marginTop: '8px'}});
+    if (libHelper) {
+      const libraryInput = ui.input.choice('Add from library', {items: [] as string[], nullable: true}) as DG.ChoiceInput<string>;
+      const libraryStatus = ui.divText('', {style: {fontSize: '11px', color: 'var(--green-2)', marginLeft: '8px', minHeight: '16px'}});
+
+      // Load library names asynchronously
+      libHelper.getAvaliableLibraryNames().then((libNames) => {
+        libraryInput.items = libNames;
+      });
+
+      libraryInput.onChanged.subscribe(async () => {
+        const libName = libraryInput.value;
+        if (!libName)
+          return;
+
+        libraryStatus.textContent = 'Loading...';
+        try {
+          const lib = await libHelper.readSingleLibraryByName(libName);
+          if (lib) {
+            const symbols = lib.getMonomerSymbolsByType(polymerType);
+            const before = selectedMonomers.length;
+            addMonomers(symbols);
+            const added = selectedMonomers.length - before;
+            libraryStatus.textContent = `Added ${added} monomer(s) from "${libName}"`;
+          } else {
+            libraryStatus.textContent = `Library "${libName}" not found`;
+          }
+        } catch (err: any) {
+          libraryStatus.textContent = `Error loading library`;
+        }
+        // Clear the selector after use
+        libraryInput.value = null as any;
+        setTimeout(() => { libraryStatus.textContent = ''; }, 4000);
+      });
+
+      librarySection.appendChild(ui.divV([libraryInput.root, libraryStatus]));
+    }
+
+    // --- Bulk add: from monomer collection ---
+    const collectionSection = ui.div([], {style: {marginTop: '4px'}});
+    if (libHelper) {
+      const collectionInput = ui.input.choice('Add from collection', {items: [] as string[], nullable: true}) as DG.ChoiceInput<string>;
+      const collectionStatus = ui.divText('', {style: {fontSize: '11px', color: 'var(--green-2)', marginLeft: '8px', minHeight: '16px'}});
+
+      // Load collection names asynchronously
+      libHelper.listMonomerCollections().then((collectionNames) => {
+        collectionInput.items = collectionNames;
+      });
+
+      collectionInput.onChanged.subscribe(async () => {
+        const collectionName = collectionInput.value;
+        if (!collectionName)
+          return;
+
+        collectionStatus.textContent = 'Loading...';
+        try {
+          const collection = await libHelper.readMonomerCollection(collectionName);
+          const symbols = collection.monomerSymbols ?? [];
+          const before = selectedMonomers.length;
+          addMonomers(symbols);
+          const added = selectedMonomers.length - before;
+          const displayName = collectionName.replace(/\.json$/, '');
+          collectionStatus.textContent = `Added ${added} monomer(s) from "${displayName}"`;
+        } catch (err: any) {
+          collectionStatus.textContent = `Error loading collection`;
+        }
+        // Clear the selector after use
+        collectionInput.value = null as any;
+        setTimeout(() => { collectionStatus.textContent = ''; }, 4000);
+      });
+
+      collectionSection.appendChild(ui.divV([collectionInput.root, collectionStatus]));
+    }
+
+    // --- Clear all button ---
+    const clearBtn = ui.button('Clear all', () => {
+      selectedMonomers.length = 0;
+      renderTags();
+    });
+    clearBtn.style.fontSize = '11px';
+    clearBtn.style.marginTop = '4px';
+
     renderTags();
 
-    const dlg = ui.dialog({title: 'Select Monomers', showFooter: true})
-      .add(ui.div([input.root, tagsHost], {style: {minWidth: '350px', minHeight: '200px'}}))
+    // --- Dialog layout ---
+    const contentDiv = ui.div([
+      input.root,
+      librarySection,
+      collectionSection,
+      ui.divH([countLabel, clearBtn], {style: {justifyContent: 'space-between', alignItems: 'center'}}),
+      tagsHost,
+    ], {style: {minWidth: '400px', minHeight: '250px'}});
+
+    const _dlg = ui.dialog({title: 'Select Monomers', showFooter: true})
+      .add(contentDiv)
       .onOK(() => { resolve(selectedMonomers); })
       .onCancel(() => { resolve(null); })
       .show({resizable: true});
-    // dlg.root.addEventListener('close', () => { hideMenu(); });
 
     inputEl.focus();
     setTimeout(() => { showSuggestions(); }, 0);

package/src/polytool/types.ts

@@ -8,7 +8,6 @@ export enum PolyToolEnumeratorTypes {
   Single = 'single',
   Parallel = 'parallel',
   Matrix = 'matrix',
-  Library = 'library',
 }
 
 export type PolyToolEnumeratorType = typeof PolyToolEnumeratorTypes[keyof typeof PolyToolEnumeratorTypes];