@datagrok/sequence-translator 1.10.13 → 1.10.15

package/src/polytool/pt-dialog.ts

@@ -19,12 +19,10 @@ import {doPolyToolConvert} from './conversion/pt-conversion';
 import {getOverriddenLibrary} from './conversion/pt-synthetic';
 import {defaultErrorHandler} from '../utils/err-info';
 import {getLibrariesList} from './utils';
-import {getEnumerationChem, PT_CHEM_EXAMPLE} from './pt-enumeration-chem';
-
 import {
-  PT_ERROR_DATAFRAME, PT_UI_ADD_HELM, PT_UI_DIALOG_CONVERSION, PT_UI_DIALOG_ENUMERATION,
+  PT_ERROR_DATAFRAME, PT_UI_ADD_HELM, PT_UI_DIALOG_CONVERSION,
   PT_UI_GET_HELM, PT_UI_LINEARIZE, PT_UI_LINEARIZE_TT,
-  PT_UI_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY
+  PT_UI_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY,
 } from './const';
 
 import {_package} from '../package';
@@ -50,21 +48,6 @@ type PolyToolConvertSerialized = {
   rules: string[];
 };
 
-type PolyToolEnumerateChemSerialized = {
-  mol: string;
-  screenLibrary: string | null;
-}
-
-export async function polyToolEnumerateChemUI(cell?: DG.Cell): Promise<void> {
-  await _package.initPromise;
-  try {
-    const dialog = await getPolyToolEnumerationChemDialog(cell);
-    dialog.show({resizable: true});
-  } catch (_err: any) {
-    grok.shell.warning('To run PolyTool Enumeration, sketch the molecule and specify the R group to vary');
-  }
-}
-
 export async function polyToolConvertUI(): Promise<void> {
   await _package.initPromise;
   let dialog: DG.Dialog | null = null;
@@ -178,111 +161,6 @@ export async function getPolyToolConvertDialog(srcCol?: DG.Column): Promise<DG.D
   }
 }
 
-async function getPolyToolEnumerationChemDialog(cell?: DG.Cell): Promise<DG.Dialog> {
-  const subs: Unsubscribable[] = [];
-  const destroy = () => {
-    for (const sub of subs) sub.unsubscribe();
-  };
-  try {
-    const [libList, helmHelper] = await Promise.all([
-      getLibrariesList(), getHelmHelper()]);
-
-    const molStr = (cell && cell.rowIndex >= 0) ? cell.value : PT_CHEM_EXAMPLE;//cell ? cell.value : PT_CHEM_EXAMPLE;
-    let molfileValue: string = await (async (): Promise<string> => {
-      if (DG.chem.isMolBlock(molStr)) return molStr;
-      return (await grok.functions.call('Chem:convertMolNotation', {
-        molecule: molStr,
-        sourceNotation: cell?.column.getTag(DG.TAGS.UNITS) ?? DG.chem.Notation.Unknown,
-        targetNotation: DG.chem.Notation.MolBlock,
-      }));
-    })();
-
-    const molInput = new DG.chem.Sketcher(DG.chem.SKETCHER_MODE.EXTERNAL);
-    molInput.syncCurrentObject = false;
-    // sketcher.setMolFile(col.tags[ALIGN_BY_SCAFFOLD_TAG]);
-    molInput.onChanged.subscribe((_: any) => {
-      molfileValue = molInput.getMolFile();
-    });
-    molInput.root.classList.add('ui-input-editor');
-    molInput.root.style.marginTop = '3px';
-    molInput.setMolFile(molfileValue);
-
-    //const helmInput = helmHelper.createHelmInput('Macromolecule', {value: helmValue});
-    const screenLibraryInput = ui.input.choice('Library to use', {
-      value: libList.length ? libList[0] : null,
-      items: libList,
-      nullable: false,
-      onValueChanged: () => {
-        dialog.getButton('OK').disabled = screenLibraryInput.value === null;
-      }
-    });
-
-    molInput.root.setAttribute('style', `min-width:250px!important;`);
-    molInput.root.setAttribute('style', `max-width:250px!important;`);
-    screenLibraryInput.input.setAttribute('style', `min-width:250px!important;`);
-
-    const div = ui.div([
-      molInput.root,
-      screenLibraryInput.root
-    ]);
-
-    subs.push(grok.events.onCurrentCellChanged.subscribe(() => {
-      const cell = grok.shell.tv.dataFrame.currentCell;
-
-      if (cell.column.semType === DG.SEMTYPE.MOLECULE)
-        molInput.setValue(cell.value);
-    }));
-
-    const exec = async (): Promise<void> => {
-      try {
-        const molString = molInput.getMolFile();
-
-        if (molString === undefined || molString === '') {
-          grok.shell.warning('PolyTool: no molecule was provided');
-        } else if (!molString.includes('R#')) {
-          grok.shell.warning('PolyTool: no R group was provided');
-        } else {
-          const molecules = await getEnumerationChem(molString, screenLibraryInput.value!);
-          const molCol = DG.Column.fromStrings('Enumerated', molecules);
-          const df = DG.DataFrame.fromColumns([molCol]);
-          grok.shell.addTableView(df);
-        }
-      } catch (err: any) {
-        defaultErrorHandler(err);
-      }
-    };
-
-    // Displays the molecule from a current cell (monitors changes)
-    const dialog = ui.dialog(PT_UI_DIALOG_ENUMERATION)
-      .add(div)
-      .onOK(() => {
-        exec().finally(() => { destroy(); });
-      })
-      .onCancel(() => {
-        destroy();
-      });
-    subs.push(dialog.onClose.subscribe(() => {
-      destroy();
-    }));
-    dialog.history(
-      /* getInput */ (): PolyToolEnumerateChemSerialized => {
-        return {
-          mol: molInput.getMolFile(),
-          screenLibrary: screenLibraryInput.value,
-        };
-      },
-      /* applyInput */ (x: PolyToolEnumerateChemSerialized): void => {
-        molInput.setMolFile(x.mol);
-        screenLibraryInput.value = x.screenLibrary;
-      });
-    dialog.getButton('OK').disabled = screenLibraryInput.value === null;
-    return dialog;
-  } catch (err: any) {
-    destroy();
-    throw err;
-  }
-}
-
 /** Returns Helm and molfile columns.  */
 export async function polyToolConvert(seqCol: DG.Column<string>,
   generateHelm: boolean, linearize: boolean, chiralityEngine: boolean, highlight: boolean, ruleFiles: string[]
@@ -352,7 +230,8 @@ function buildCyclizedMonomerHoverLink(
 
     const alphabet = seqSH.alphabet as ALPHABET;
     const polymerType = alphabet == ALPHABET.RNA || alphabet == ALPHABET.DNA ? PolymerTypes.RNA : PolymerTypes.PEPTIDE;
-    const monomersDict = getMonomersDictFromLib([seqMList], polymerType, alphabet, monomerLib, rdKitModule);
+    const monomersDict = getMonomersDictFromLib([seqMList], [undefined], polymerType,
+      alphabet, monomerLib, rdKitModule);
     // Call seq-to-molfile worker core directly
     const molWM = monomerSeqToMolfile(seqMList, monomersDict, alphabet, polymerType);
     return molWM.monomers;

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

@@ -26,7 +26,7 @@ import {PolyToolPlaceholdersInput} from './pt-placeholders-input';
 import {showMonomerSelectionDialog} from '@datagrok-libraries/bio/src/utils/monomer-selection-dialog';
 import {defaultErrorHandler} from '../utils/err-info';
 import {PolyToolPlaceholdersBreadthInput} from './pt-placeholders-breadth-input';
-import {PT_ENUM_TYPE_TOOLTIPS, PT_UI_DIALOG_ENUMERATION, PT_UI_GET_HELM, PT_UI_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY} from './const';
+import {PT_ENUM_TYPE_TOOLTIPS, PT_HELM_UI_DIALOG_ENUMERATION, PT_UI_GET_HELM, PT_UI_HIGHLIGHT_MONOMERS, PT_UI_RULES_USED, PT_UI_USE_CHIRALITY} from './const';
 import {PolyToolDataRole, PolyToolTags} from '../consts';
 import {RuleInputs, RULES_PATH, RULES_STORAGE_NAME} from './conversion/pt-rules';
 import {Chain} from './conversion/pt-chain';
@@ -668,7 +668,7 @@ async function getPolyToolEnumerateDialog(
           if (Object.keys(inputs.placeholders.placeholdersValue).length === 0 &&
             Object.keys(inputs.placeholdersBreadth.placeholdersBreadthValue).length === 0
           ) {
-            grok.shell.warning(`${PT_UI_DIALOG_ENUMERATION}: placeholders are empty`);
+            grok.shell.warning(`${PT_HELM_UI_DIALOG_ENUMERATION}: placeholders are empty`);
             return;
           }
           await getHelmHelper(); // initializes JSDraw and org
@@ -727,7 +727,7 @@ async function getPolyToolEnumerateDialog(
 
     // === DIALOG CONSTRUCTION AND LAYOUT ===
     // Layout: macromolecule editor on top, two-column (placeholders | breadth), two-column (options | rules)
-    const dialog = ui.dialog({title: PT_UI_DIALOG_ENUMERATION, showFooter: true})
+    const dialog = ui.dialog({title: PT_HELM_UI_DIALOG_ENUMERATION, showFooter: true})
       .add(inputs.macromolecule.root)
       .add(ui.divH([
         ui.divV([

package/src/tests/oligo-renderer-tests.ts

@@ -0,0 +1,299 @@
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+
+import {parseHelmDuplex, looksLikeHelm} from '../oligo-renderer/helm-parser';
+import {computeLayout, hitTest, drawDuplex} from '../oligo-renderer/canvas-renderer';
+import {
+  resolveSugar, resolvePhosphate, resolveConjugate,
+  hashColor, SUGAR_MODS, PHOSPHATE_MODS, CONJUGATE_MODS,
+} from '../oligo-renderer/types';
+
+// HELMCore canonical: lowercase backbone (`r`, `m`, `d`, `lna`, `fl2r`, `p`, `sp`).
+// Single-char sugars/phosphates are unbracketed; multi-char must be bracketed.
+const SAMPLE_DUPLEX =
+  'RNA1{m(G)[sp].m(A)[sp].[fl2r](C)p.[fl2r](U)p.r(G)p.r(A)p.r(A)p.r(U)p.r(A)p.r(U)p.r(A)p.r(A)p.r(A)p.' +
+  'r(C)p.r(U)p.r(U)p.m(G)p.m(U)[sp].m(G)[sp].[L3]}|' +
+  'RNA2{[fl2r](C)[sp].m(A)[sp].m(A)p.m(G)p.r(U)p.r(U)p.r(U)p.r(A)p.r(U)p.r(A)p.r(U)p.r(U)p.r(C)p.' +
+  'r(A)p.r(U)p.m(C)p.m(A)[sp].m(G)[sp].r(U)}$$$$';
+
+const SAMPLE_SS = 'RNA1{[lna](C)[sp].[lna](A)[sp].[lna](G)[sp].d(T)[sp].d(C)[sp].d(A)[sp]}$$$$';
+
+// Legacy / Pistoia-style symbols that should still render via the alias map.
+const LEGACY_DUPLEX =
+  'RNA1{[mR](G)[sP].[mR](A)[sP].[fR](C)P.R(U)P}|RNA2{[mR](C)[sP].R(A)P.R(U)P.R(G)P}$$$$';
+
+category('OligoRenderer: parser', () => {
+  test('looksLikeHelm — positive', async () => {
+    expect(looksLikeHelm(SAMPLE_DUPLEX), true);
+    expect(looksLikeHelm('RNA1{R(A)P}'), true);
+    expect(looksLikeHelm('PEPTIDE1{A.C.G}'), true);
+  });
+
+  test('looksLikeHelm — negative', async () => {
+    expect(looksLikeHelm(''), false);
+    expect(looksLikeHelm('AUCGUACGUAGCUAGCAU'), false);
+    expect(looksLikeHelm('Af Cf Gf Uf'), false);
+  });
+
+  test('parses two-strand duplex', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    expect(m.sense.type, 'RNA');
+    expect(m.sense.monomers.length, 20); // 19 nucleotides + L3 conjugate
+    expect(m.antisense !== null, true);
+    expect(m.antisense!.monomers.length, 19);
+  });
+
+  test('parses single-strand', async () => {
+    const m = parseHelmDuplex(SAMPLE_SS);
+    expect(m.sense.monomers.length, 6);
+    expect(m.antisense, null);
+    // First nucleotide has LNA sugar, base C, PS phosphate
+    const first = m.sense.monomers[0];
+    expect(first.kind, 'nucleotide');
+    if (first.kind === 'nucleotide') {
+      expect(first.sugar, 'lna');
+      expect(first.base, 'C');
+      expect(first.phosphate, 'sp');
+    }
+  });
+
+  test('single-char unbracketed deoxyribose `d` parses correctly', async () => {
+    // Regression: previously `dR(T)` was emitted (invalid HELM); the parser
+    // would split `d` as the sugar and choke on the rest. With canonical `d(T)`,
+    // sugar=d, base=T, phosphate empty.
+    const m = parseHelmDuplex('RNA1{d(T)p.d(C)p.d(G)}$$$$');
+    expect(m.sense.monomers.length, 3);
+    const first = m.sense.monomers[0];
+    if (first.kind === 'nucleotide') {
+      expect(first.sugar, 'd');
+      expect(first.base, 'T');
+      expect(first.phosphate, 'p');
+    }
+  });
+
+  test('parses bracketed conjugate', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    const last = m.sense.monomers[m.sense.monomers.length - 1];
+    expect(last.kind, 'conjugate');
+    if (last.kind === 'conjugate') expect(last.symbol, 'L3');
+  });
+
+  test('handles empty / malformed without throwing', async () => {
+    const m1 = parseHelmDuplex('');
+    expect(m1.sense.monomers.length, 0);
+    expect(m1.antisense, null);
+    const m2 = parseHelmDuplex('not a helm string');
+    expect(m2.sense.monomers.length, 0);
+  });
+
+  test('passes through unknown sugar/phosphate symbols', async () => {
+    const helm = 'RNA1{[xr](A)[zp].[yr](C)p}$$$$';
+    const m = parseHelmDuplex(helm);
+    const m0 = m.sense.monomers[0];
+    if (m0.kind === 'nucleotide') {
+      expect(m0.sugar, 'xr');
+      expect(m0.phosphate, 'zp');
+    }
+  });
+});
+
+category('OligoRenderer: modification dictionary', () => {
+  test('resolves HELMCore canonical sugars', async () => {
+    expect(resolveSugar('m', 'A').meta.short, '2\'-OMe');
+    expect(resolveSugar('fl2r', 'C').meta.short, '2\'-F');
+    expect(resolveSugar('lna', 'G').meta.short, 'LNA');
+    expect(resolveSugar('moe', 'A').meta.short, '2\'-MOE');
+  });
+
+  test('aliases legacy uppercase symbols to canonical', async () => {
+    // `mR` (legacy) and `m` (canonical) must resolve identically
+    expect(resolveSugar('mR', 'A').meta.name, resolveSugar('m', 'A').meta.name);
+    expect(resolveSugar('fR', 'C').meta.name, resolveSugar('fl2r', 'C').meta.name);
+    expect(resolveSugar('LR', 'G').meta.name, resolveSugar('lna', 'G').meta.name);
+    expect(resolveSugar('dR', 'T').meta.name, resolveSugar('d', 'T').meta.name);
+  });
+
+  test('uses base-canonical color for unmodified ribose', async () => {
+    const a = resolveSugar('r', 'A');
+    const c = resolveSugar('r', 'C');
+    expect(a.color !== c.color, true,
+      `Unmodified A and C must use distinct canonical colors, got ${a.color} for both`);
+  });
+
+  test('falls back to hash color for unknown sugar', async () => {
+    const x = resolveSugar('zzz', 'A');
+    expect(x.color.startsWith('hsl('), true);
+    expect(x.meta.name, 'zzz');
+  });
+
+  test('hashColor is deterministic', async () => {
+    expect(hashColor('foo'), hashColor('foo'));
+    expect(hashColor('foo') !== hashColor('bar'), true);
+  });
+
+  test('PS phosphate (canonical and legacy) resolve to same color', async () => {
+    expect(resolvePhosphate('sp').color, PHOSPHATE_MODS['sp'].color);
+    expect(resolvePhosphate('sP').color, PHOSPHATE_MODS['sp'].color);
+  });
+
+  test('GalNAc / L3 / Chol resolve as conjugates', async () => {
+    expect(resolveConjugate('GalNAc').meta.category, 'conjugate');
+    expect(resolveConjugate('L3').meta.category, 'conjugate');
+    expect(resolveConjugate('Chol').meta.color, CONJUGATE_MODS['Chol'].color);
+  });
+});
+
+category('OligoRenderer: layout', () => {
+  test('comfortable cell — chips fit width and height', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    const layout = computeLayout(500, 70, m);
+    expect(layout.textOnlyFallback, false);
+    expect(layout.chipW > 5, true, 'chip width should be larger than minimum');
+    expect(layout.chipW <= 17, true, 'chip width should respect max (17)');
+    expect(layout.antiY > layout.senseY, true);
+    expect(layout.senseChips.length > 0, true);
+    expect(layout.antiChips.length > 0, true);
+  });
+
+  test('compact cell — both strands still fit in 28px row', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    const layout = computeLayout(300, 28, m);
+    expect(layout.antiY > 0, true);
+    expect(layout.chipH * 2 + layout.strandGap <= 28, true,
+      'two strands must fit within 28px row');
+  });
+
+  test('very narrow cell triggers text-only fallback', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    const layout = computeLayout(60, 30, m);
+    expect(layout.textOnlyFallback, true);
+    expect(layout.senseChips.length, 0);
+  });
+
+  test('aspect ratio is preserved across sizes', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    for (const [w, h] of [[300, 50], [500, 70], [800, 90]]) {
+      const layout = computeLayout(w, h, m);
+      const ratio = layout.chipH / layout.chipW;
+      // ASPECT_H_OVER_W = 1.25 in canvas-renderer.ts
+      expect(Math.abs(ratio - 1.25) < 0.01, true,
+        `aspect ratio drifted at ${w}x${h}: got ${ratio.toFixed(3)}`);
+    }
+  });
+
+  test('single-strand layout', async () => {
+    const m = parseHelmDuplex(SAMPLE_SS);
+    const layout = computeLayout(400, 50, m);
+    expect(layout.antiY, -1);
+    expect(layout.antiChips.length, 0);
+  });
+
+  test('antisense reversed by default for pair-alignment', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    const layout = computeLayout(800, 70, m);
+    expect(layout.antiReversed, true);
+    // First antisense chip in display = last antisense monomer in data
+    const antiLast = m.antisense!.monomers[m.antisense!.monomers.length - 1];
+    expect(layout.antiChips[0].monomer === antiLast, true);
+  });
+
+  test('pairAlign: false leaves antisense in data order', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    const layout = computeLayout(800, 70, m, {pairAlign: false});
+    expect(layout.antiReversed, false);
+    expect(layout.antiChips[0].monomer === m.antisense!.monomers[0], true);
+  });
+
+  test('conjugate occupies a wider position; following chip does not overlap', async () => {
+    // KRAS-like duplex with [L3] conjugate at sense 3'
+    const helm = 'RNA1{m(G)p.m(A)p.m(C)p.[L3]}|RNA2{m(C)p.m(A)p.m(A)p.r(G)}$$$$';
+    const m = parseHelmDuplex(helm);
+    const layout = computeLayout(600, 70, m);
+    const conj = layout.senseChips[3];
+    expect(conj.monomer.kind, 'conjugate');
+    expect(conj.w >= layout.chipW, true, 'conjugate must be at least chip-wide');
+  });
+});
+
+category('OligoRenderer: hit testing', () => {
+  test('hits each chip via stored positions', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    const layout = computeLayout(800, 70, m);
+
+    const first = layout.senseChips[0];
+    const hit = hitTest(first.x + first.w / 2, layout.senseY + layout.chipH / 2, m, layout);
+    expect(hit !== null, true);
+    expect(hit!.strand, 'sense');
+    expect(hit!.position, 0);
+
+    // Gap immediately after first chip should miss (unless it's a PS link)
+    const prev = m.sense.monomers[0];
+    const isPS = prev.kind === 'nucleotide' && (prev as any).phosphate === 'sp';
+    const gapX = first.x + first.w + layout.chipGap * 0.1;
+    const miss = hitTest(gapX, layout.senseY + layout.chipH / 2, m, layout);
+    if (isPS) {
+      // Should hit the PS linkage marker
+      expect(miss !== null, true);
+      expect(miss!.linkage !== undefined, true);
+    } else {
+      expect(miss, null);
+    }
+  });
+
+  test('antisense hit returns original position despite reversed display', async () => {
+    const m = parseHelmDuplex(SAMPLE_DUPLEX);
+    const layout = computeLayout(800, 70, m);
+    // Click on the leftmost antisense chip in display — that's the LAST monomer in data
+    const leftmost = layout.antiChips[0];
+    const hit = hitTest(leftmost.x + leftmost.w / 2, layout.antiY + layout.chipH / 2, m, layout);
+    expect(hit !== null, true);
+    expect(hit!.strand, 'antisense');
+    expect(hit!.position, m.antisense!.monomers.length - 1,
+      'leftmost AS chip in pair-aligned display = last monomer in data');
+  });
+
+  test('hovering between two chips with PS linkage returns the linkage', async () => {
+    // Force a PS linkage between position 0 and 1
+    const helm = 'RNA1{m(G)[sp].m(A)p.m(C)p}$$$$';
+    const m = parseHelmDuplex(helm);
+    const layout = computeLayout(600, 70, m);
+    const c0 = layout.senseChips[0];
+    const c1 = layout.senseChips[1];
+    const midX = (c0.x + c0.w + c1.x) / 2;
+    const hit = hitTest(midX, layout.senseY + layout.chipH / 2, m, layout);
+    expect(hit !== null, true);
+    expect(hit!.linkage !== undefined, true);
+    expect(hit!.linkage!.phosphateSymbol, 'sp');
+  });
+});
+
+category('OligoRenderer: drawing smoke', () => {
+  test('draws without error on offscreen canvas', async () => {
+    const canvas = document.createElement('canvas');
+    canvas.width = 500; canvas.height = 70;
+    const g = canvas.getContext('2d')!;
+    const model = parseHelmDuplex(SAMPLE_DUPLEX);
+    const layout = drawDuplex(g, 0, 0, 500, 70, model);
+    expect(layout.textOnlyFallback, false);
+  });
+
+  test('handles unknown modifications without throwing', async () => {
+    const helm = 'RNA1{[xr](A)[zp].[yr](C)p}$$$$';
+    const canvas = document.createElement('canvas');
+    canvas.width = 200; canvas.height = 50;
+    const g = canvas.getContext('2d')!;
+    const model = parseHelmDuplex(helm);
+    drawDuplex(g, 0, 0, 200, 50, model);
+    // Verifying no throw is the assertion.
+    expect(true, true);
+  });
+
+  test('renders legacy uppercase symbols via alias map', async () => {
+    const canvas = document.createElement('canvas');
+    canvas.width = 400; canvas.height = 50;
+    const g = canvas.getContext('2d')!;
+    const model = parseHelmDuplex(LEGACY_DUPLEX);
+    drawDuplex(g, 0, 0, 400, 50, model);
+    expect(model.sense.monomers.length, 4);
+    expect(model.antisense !== null, true);
+  });
+});