@datagrok/helm 2.13.8 → 3.0.1

package/src/helm-helper.ts

@@ -1,56 +1,76 @@
-import * as grok from 'datagrok-api/grok';
-import * as ui from 'datagrok-api/ui';
-import * as DG from 'datagrok-api/dg';
-
-import $ from 'cash-dom';
-
 /* eslint-disable max-len */
 import {
-  App, Point, HelmType, IHelmBio, HelmAtom, HelmBond, HelmMol, GetMonomerFunc, GetMonomerResType,
-  MonomerExplorer, TabDescType, MonomersFuncs, MonomerSetType, ISeqMonomer, PolymerType, MonomerType,
-  DojoType, JSDraw2ModuleType, IHelmEditorOptions, IHelmDrawOptions,
-  Editor,
-  IBio,
+  App, Point, HelmAtom, HelmMol, MonomersFuncs,
+  IHelmEditorOptions,
 } from '@datagrok-libraries/bio/src/helm/types';
-import {HelmTabKeys, HelmTypes, MonomerTypes, PolymerTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {errInfo} from '@datagrok-libraries/bio/src/utils/err-info';
 import {ILogger} from '@datagrok-libraries/bio/src/utils/logger';
 import {
-  HelmConvertRes, HelmInputBase, HelmNotSupportedError, IHelmHelper, IHelmInputInitOptions
+  HelmConvertRes, HelmInputBase, IHelmHelper, IHelmInputInitOptions
 } from '@datagrok-libraries/bio/src/helm/helm-helper';
 import {IHelmWebEditor} from '@datagrok-libraries/bio/src/helm/types';
-import {IMonomerLib, IMonomerLibBase, IMonomerLinkData, IMonomerSetPlaceholder} from '@datagrok-libraries/bio/src/types/monomer-library';
-import {GAP_SYMBOL, GapOriginals, NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {IMonomerLib, IMonomerLibBase} from '@datagrok-libraries/bio/src/types/monomer-library';
 import {ISeqHelper} from '@datagrok-libraries/bio/src/utils/seq-helper';
+import type {RDModule} from '@datagrok-libraries/chem-meta/src/rdkit-api';
 
-import {HelmWebEditor} from './helm-web-editor';
-import {OrgHelmModule, ScilModule} from './types';
 import {HelmInput} from './widgets/helm-input';
 import {getHoveredMonomerFromEditorMol} from './utils/get-hovered';
+import * as DG from 'datagrok-api/dg';
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
 /* eslint-enable max-len */
 
 import {_package} from './package';
-import {IEditorOptions} from '@datagrok-libraries/js-draw-lite/src/types/jsdraw2';
 
-declare const dojo: DojoType;
-declare const JSDraw2: JSDraw2ModuleType;
-declare const scil: ScilModule;
-declare const org: OrgHelmModule;
-
-const HELM_GAP_SYMBOL: string = GapOriginals[NOTATION.HELM];
+// hwe migration (Phases 3-7): every editor / parse / calc path now runs through
+// the standalone `@datagrok-libraries/hwe` library via its Datagrok adapter
+// (`HelmHelperAdapter` over `HelmService`). The legacy forked Pistoia HELM Web
+// Editor (`org.helm.webeditor` / JSDraw2 / Dojo) is gone — this class no longer
+// touches any of those globals.
+import {HelmHelperAdapter, bridgeMonomerLib, HelmService, PolymerTypes} from '@datagrok-libraries/hwe';
+import type {IMonomerLibBaseLike, MonomersFuncsLike} from '@datagrok-libraries/hwe';
+import {NOTATION} from '@datagrok-libraries/bio/src/utils/macromolecule';
+import {ISeqHandler} from '@datagrok-libraries/bio/src/utils/macromolecule/seq-handler';
 
 export class HelmHelper implements IHelmHelper {
   private static instanceCount: number = 0;
 
   constructor(
     public readonly seqHelper: ISeqHelper,
-    private readonly logger: ILogger
+    private readonly logger: ILogger,
+    // Datagrok's RDKit module (from `getRdKitModule()`), forwarded to hwe so the
+    // editor can render monomer structures (atom / palette / RNA-builder tooltips
+    // and the bond-props dialog). hwe consumes only `get_mol(...).get_svg(...)`.
+    private readonly rdKitModule?: RDModule,
   ) {
     // Watchdog for singleton
     if ((++HelmHelper.instanceCount) > 1)
       throw new Error(`HelmHelper must be a single.`);
   }
 
+  // -- hwe editor adapter --
+  // The adapter owns one `HelmService` reading Bio's monomer library through
+  // `bridgeMonomerLib`, so the editor / parser / calculators resolve exactly
+  // the same monomers as the rest of the platform. Built lazily on first use
+  // (after `completeInit` has populated `_package._libHelper`).
+  private _editorAdapter: HelmHelperAdapter | null = null;
+  private get editorAdapter(): HelmHelperAdapter {
+    if (this._editorAdapter === null) {
+      const monomerLib = _package._libHelper!.getMonomerLib() as unknown as IMonomerLibBaseLike;
+      const paneProviders: Map<string, (helm: string) => Promise<HTMLElement>> = new Map();
+      paneProviders.set('FASTA', async (helm) => this._toFastaProvider(helm));
+      paneProviders.set('BILN', async (helm) => this._toBilnProvider(helm));
+      paneProviders.set('Molecular Structure', async (helm) => this._atomicLevelProvider(helm));
+      paneProviders.set('Composition Analysis', async (helm) => this._compositionAnalysisProvider(helm));
+
+
+      const service = new HelmService({monomerLib: bridgeMonomerLib(monomerLib),
+        rdkitModule: this.rdKitModule, extraPanes: paneProviders});
+      this._editorAdapter = new HelmHelperAdapter({service, seqHelper: this.seqHelper});
+    }
+    return this._editorAdapter;
+  }
+
   createHelmInput(name?: string, options?: IHelmInputInitOptions): HelmInputBase {
     try {
       const monomerLib: IMonomerLibBase = _package._libHelper!.getMonomerLib();
@@ -63,420 +83,124 @@ export class HelmHelper implements IHelmHelper {
   }
 
   createHelmWebEditor(host?: HTMLDivElement, options?: Partial<IHelmEditorOptions>): IHelmWebEditor {
-    return new HelmWebEditor(host, options);
-  }
-
-  createWebEditorApp(host: HTMLDivElement, helm: string): App {
-    org.helm.webeditor.MolViewer.molscale = 0.8;
-    const webEditorApp: App = new org.helm.webeditor.App(host, {
-      showabout: false,
-      mexfontsize: '90%',
-      mexrnapinontab: true,
-      topmargin: 20,
-      mexmonomerstab: true,
-      sequenceviewonly: false,
-      mexfavoritefirst: true,
-      mexfilter: true,
-      currentTabKey: HelmTabKeys.Helm,
-      overrideTabs: (tabs: Partial<TabDescType>[]): Partial<TabDescType>[] => {
-        const res: Partial<TabDescType>[] = [...tabs,
-          {caption: 'Placeholders', tabkey: 'placeholders'},
-        ];
-        return res;
-      },
-      onShowTab: (mex: MonomerExplorer, div: HTMLDivElement, key: string): void => {
-        switch (key) {
-        case 'placeholders': {
-          this.onShowTabPlaceholders(mex, div);
-          break;
-        }
-        case 'placeholders-meta': {
-          this.onShowTabPlaceholdersMeta(mex, div);
-          break;
-        }
-        case 'placeholders-sets': {
-          this.onShowTabPlaceholdersSets(mex, div);
-          break;
-        }
-        }
-        dojo.connect(div, 'onmousedown', function(e: MouseEvent) {
-          mex.select(e);
-        });
-        dojo.connect(div, 'ondblclick', function(e: MouseEvent) {
-          mex.dblclick(e);
-        });
-      }
-    });
-    const sizes = webEditorApp.calculateSizes();
-    webEditorApp.canvas!.resize(sizes.rightwidth - 100, sizes.topheight - 210);
-    let s: Partial<CSSStyleDeclaration> = {width: sizes.rightwidth - 100 + 'px', height: sizes.bottomheight + 'px'};
-    scil.apply(webEditorApp.sequence.style, s);
-    scil.apply(webEditorApp.notation!.style, s);
-    s = {width: sizes.rightwidth + 'px', height: (sizes.bottomheight + webEditorApp.toolbarheight) + 'px'};
-    scil.apply(webEditorApp.properties!.parent.style, s);
-    webEditorApp.structureview!.resize(sizes.rightwidth, sizes.bottomheight + webEditorApp.toolbarheight);
-    webEditorApp.mex!.resize(sizes.topheight - 80);
-    webEditorApp.canvas?.setHelm(helm);
-    return webEditorApp;
-  }
-
-  // -- MonomerExplorer.onShowTab --
-
-  public onShowTabPlaceholders(mex: MonomerExplorer, div: HTMLDivElement): void {
-    const d = scil.Utils.createElement(div, 'div', null, {paddingTop: '5px'});
-
-    /* eslint-disable max-len*/
-    // if (this.options.canvastoolbar == false) {
-    //   const b = scil.Utils.createElement(d, 'div', '<img src=\'' + scil.Utils.imgSrc('helm/arrow.png') + '\' style=\'vertical-align:middle\'>Mouse Pointer', {cursor: 'pointer', padding: '2px', border: 'solid 1px gray', margin: '5px'});
-    //   scil.connect(b, 'onclick', function() {
-    //     mex.plugin.jsd.doCmd('lasso');
-    //   });
-    // }
-    /* eslint-enable max-len*/
-
-    const phTabs: Partial<TabDescType>[] = [];
-    phTabs.push({caption: 'Meta', tabkey: 'placeholders-meta'});
-    phTabs.push({caption: 'Sets', tabkey: 'placeholders-sets'});
-    const placeholdersTabs = new scil.Tabs(d, {
-      onShowTab(td: HTMLTableCellElement) {
-        mex.onShowTab(td);
-      },
-      tabpadding: '5px 2px 1px 2px',
-      tabs: phTabs,
-      marginBottom: `0`,
-    });
+    return this.editorAdapter.createHelmWebEditor(host, {
+      ...(options?.width !== undefined ? {width: options.width} : {}),
+      ...(options?.height !== undefined ? {height: options.height} : {}),
+    }) as unknown as IHelmWebEditor;
   }
 
-  public onShowTabPlaceholdersMeta(mex: MonomerExplorer, div: HTMLDivElement): void {
-
+  /**
+   * Returns the standalone hwe editor (palette + toolbar + canvas +
+   * Sequence/HELM/Properties/Atomic tabs) wrapped in a `LegacyAppWrapper` that
+   * presents the legacy Pistoia `App` shape — `canvas.getHelm(true)`,
+   * `canvas.helm.jsd.m.atoms[i].selected`, `sequence` / `notation` /
+   * `properties.parent`, etc. — so the existing dialog consumers swap in
+   * unchanged.
+   */
+  createWebEditorApp(host: HTMLDivElement, helm?: string): App {
+    return this.editorAdapter.createWebEditorApp(host, helm) as unknown as App;
   }
 
-  public onShowTabPlaceholdersSets(mex: MonomerExplorer, div: HTMLDivElement): void {
-    const monomerSets = _package._libHelper!.getMonomerSets();
-
-    const phSet: { [polymerType: string]: { [helmType: string]: IMonomerSetPlaceholder[] } } = {};
-    for (const ph of monomerSets.placeholders) {
-      let ofPolymerTypeSet = phSet[ph.polymerType];
-      if (!ofPolymerTypeSet) ofPolymerTypeSet = phSet[ph.polymerType] = {};
-
-      const phHelmType = this.toHelmType(ph.polymerType, ph.monomerType);
-      let phList = ofPolymerTypeSet[phHelmType];
-      if (!phList) phList = ofPolymerTypeSet[phHelmType] = [];
-      phList.push(ph);
-    }
+  // -- GetMonomer (monomer-funcs hooks) --
+  // Delegated to the adapter. The legacy implementation patched the global
+  // `org.helm.webeditor.Monomers` registry so the forked editor used Bio's
+  // library; the hwe editor reads `bridgeMonomerLib(...)` directly, so these
+  // are now thin pass-throughs kept for the `IHelmHelper` contract.
 
-    const fillPlaceholders = (
-      parentDiv: HTMLDivElement, phList: IMonomerSetPlaceholder[], helmType: HelmType
-    ): void => {
-      for (const ph of phList) {
-        const phDiv = mex.createMonomerDiv(parentDiv, ph.symbol, helmType);
-        ui.tooltip.bind(phDiv, () => {
-          const phTooltipDiv = ui.div([
-            ui.table(ph.monomerLinks, (ml: IMonomerLinkData, idx: number) => {
-              return [ml.symbol, ml.source];
-            }, ['Symbol', 'Library source'])
-          ]);
-          return phTooltipDiv;
-        });
-      }
-    };
-
-    const polymerTypes: [string, PolymerType][] = [
-      ['Chem', PolymerTypes.CHEM],
-      ['Peptide', PolymerTypes.PEPTIDE],
-      ['RNA', PolymerTypes.RNA],
-      ['Blob', PolymerTypes.BLOB],
-      ['G', PolymerTypes.G],
-    ];
-    const polymerTypeAcc = ui.accordion();
-    for (const [name, polymerType] of polymerTypes) {
-      if (polymerType in phSet) {
-        polymerTypeAcc.addPane(name, () => {
-          const polymerTypeDiv = ui.div();
-          const ofPolymerTypeSet = phSet[polymerType];
-          if (Object.keys(ofPolymerTypeSet).length == 1) {
-            const [helmType, phList] = Object.entries(ofPolymerTypeSet)[0];
-            fillPlaceholders(polymerTypeDiv, phList, helmType as HelmType);
-          } else {
-            const helmTypeAcc = ui.accordion();
-            for (const [helmTypeName, helmType] of Object.entries(HelmTypes)) {
-              if (helmType in ofPolymerTypeSet) {
-                helmTypeAcc.addPane(helmTypeName, () => {
-                  const helmTypeDiv = ui.div();
-
-                  const phList = ofPolymerTypeSet[helmType];
-                  fillPlaceholders(helmTypeDiv, phList, helmType as HelmType);
-
-                  return helmTypeDiv;
-                });
-              }
-            }
-            polymerTypeDiv.appendChild(helmTypeAcc.root);
-          }
-          return polymerTypeDiv;
-        }, true, undefined, false);
-      }
-    }
-    div.appendChild(polymerTypeAcc.root);
+  public get originalMonomersFuncs(): MonomersFuncs | null {
+    return this.editorAdapter.originalMonomersFuncs as unknown as MonomersFuncs | null;
   }
 
-  // -- GetMonomer --
-
-  public originalMonomersFuncs: MonomersFuncs | null = null;
-
   public revertOriginalMonomersFuncs(): MonomersFuncs {
-    const logPrefix = `Helm: revertOriginalGetMonomer()`;
-    if (this.originalMonomersFuncs === null)
-      throw new Error('Unable to revert original getMonomer');
-
-    const monomers = org.helm.webeditor.Monomers;
-    const overriddenMonomersFuncs: MonomersFuncs = {
-      getMonomer: monomers.getMonomer,
-      getMonomerSet: monomers.getMonomerSet,
-    };
-
-    monomers.getMonomer = this.originalMonomersFuncs.getMonomer;
-    monomers.getMonomerSet = this.originalMonomersFuncs.getMonomerSet;
-    this.originalMonomersFuncs = null;
-
-    return overriddenMonomersFuncs;
+    return this.editorAdapter.revertOriginalMonomersFuncs() as unknown as MonomersFuncs;
   }
 
   public overrideMonomersFuncs(monomersFuncs: MonomersFuncs): MonomersFuncs {
-    const logPrefix = `Helm: HelmHelper.overrideGetMonomer()`;
-
-    if (this.originalMonomersFuncs != null)
-      throw new Error(`${logPrefix}, originalGetMonomer is overridden already`);
-
-    const monomers = org.helm.webeditor.Monomers;
-    this.originalMonomersFuncs = {
-      getMonomer: monomers.getMonomer.bind(monomers),
-      getMonomerSet: monomers.getMonomerSet.bind(monomers),
-    };
-    monomers.getMonomer = monomersFuncs.getMonomer;
-    monomers.getMonomerSet = monomersFuncs.getMonomerSet;
-    return this.originalMonomersFuncs!;
+    return this.editorAdapter.overrideMonomersFuncs(
+      monomersFuncs as unknown as MonomersFuncsLike) as unknown as MonomersFuncs;
   }
 
   public buildMonomersFuncsFromLib(monomerLib: IMonomerLib): MonomersFuncs {
-    const logPrefix = `Helm: HelmHelper.buildGetMonomerFromLib()`;
-
-    return {
-      getMonomer: (a: HelmAtom | HelmType, name?: string): GetMonomerResType => {
-        const logPrefixInt = `${logPrefix}, org.helm.webeditor.Monomers.getMonomer()`;
-        try {
-          // logger.debug(`${logPrefixInt}, a: ${JSON.stringify(a, helmJsonReplacer)}, name: '${name}'`);
-          if (name?.startsWith('[') && name.endsWith(']'))
-            name = name.substring(1, name.length - 1);
-          // Creates monomers in lib
-          const dgWem = monomerLib.getWebEditorMonomer(a, name);
-
-          return dgWem; //dgWem;
-        } catch (err) {
-          const [errMsg, errStack] = errInfo(err);
-          this.logger.error(`${logPrefixInt}, Error: ${errMsg}`, undefined, errStack);
-          throw err;
-        }
-      },
-      getMonomerSet: (a: HelmAtom | HelmType | null): MonomerSetType | null => {
-        // if (a == null)
-        //   return null;
-        // const atom = a as HelmAtom;
-        // if (atom.T === 'ATOM')
-        //   a = atom.biotype();
-        // return monomerLib.getMonomerSet(a as HelmType);
-        return this.originalMonomersFuncs!.getMonomerSet(a);
-      }
-    };
-  }
-
-  // helm2type(seqM: ISeqMonomer): HelmType {
-  //   if (seqM.polymerType == "PEPTIDE")
-  //     return org.helm.webeditor.HELM.AA;
-  //   else if (seqM.polymerType == "CHEM")
-  //     return org.helm.webeditor.HELM.CHEM;
-  //   else if (seqM.polymerType == "RNA") {
-  //     if (seqM.mt == "Branch")
-  //       return org.helm.webeditor.HELM.BASE;
-  //     if (seqM.mt == "Backbone") {
-  //       if (seqM.na == "P" || seqM.na == "p")
-  //         return org.helm.webeditor.HELM.LINKER;
-  //       else
-  //         return org.helm.webeditor.HELM.SUGAR;
-  //     }
-  //   }
-  //   throw new Error(`Not supported seq monomer ${JSON.stringify(seqM)}.`);
-  // }
-  private toHelmType(polymerType: PolymerType, monomerType: MonomerType, naturalAnalog?: string) {
-    if (polymerType == PolymerTypes.PEPTIDE)
-      return org.helm.webeditor.HELM.AA;
-    else if (polymerType == PolymerTypes.CHEM)
-      return org.helm.webeditor.HELM.CHEM;
-    else if (polymerType == PolymerTypes.RNA) {
-      if (monomerType == MonomerTypes.BRANCH)
-        return org.helm.webeditor.HELM.BASE;
-      if (monomerType == MonomerTypes.BACKBONE) {
-        if (naturalAnalog == 'P' || naturalAnalog == 'p')
-          return org.helm.webeditor.HELM.LINKER;
-        else
-          return org.helm.webeditor.HELM.SUGAR;
-      }
-    }
-    throw new Error(`Not supported monomer polymerType: '${polymerType}', monomerType: '${monomerType}'.`);
+    return this.editorAdapter.buildMonomersFuncsFromLib(
+      monomerLib as unknown as IMonomerLibBaseLike) as unknown as MonomersFuncs;
   }
 
   public getHoveredAtom(x: number, y: number, mol: HelmMol, height: number): HelmAtom | null {
     return getHoveredMonomerFromEditorMol(x, y, mol, height);
   }
 
-  //if molfiles are accessed too often, it is better to cache it
-  private _molfilesEditor: Editor<unknown, IBio<unknown>, IEditorOptions> | null = null;
-  private _molfilesEditorHost: HTMLDivElement | null = null;
-  private get molfilesEditor(): Editor<unknown, IBio<unknown>, IEditorOptions> {
-    if (this._molfilesEditorRemovingTimer)
-      clearTimeout(this._molfilesEditorRemovingTimer);
-    if (this._molfilesEditor == null) {
-      this._molfilesEditorHost = ui.div([], {style: {width: '0px', height: '0px', position: 'fixed'}});
-      document.documentElement.appendChild(this._molfilesEditorHost);
-      this._molfilesEditor = new JSDraw2.Editor(this._molfilesEditorHost, {viewonly: true});
-    }
-    this._molfilesEditorRemovingTimer = setTimeout(() => {
-      this.removeMolfilesEditor();
-    }, 1000);
-    return this._molfilesEditor;
-  }
-
-  // after batch conversion, remove the editor to avoid sliding pages
-  private _molfilesEditorRemovingTimer: any = null;
-  private removeMolfilesEditor(): void {
-    if (this._molfilesEditorHost) {
-      $(this._molfilesEditorHost).empty();
-      this._molfilesEditorHost.remove();
-      this._molfilesEditorHost = null;
-      this._molfilesEditor = null;
-    }
-  }
-
   public getMolfiles(helmStrList: string[]): string[] {
-    try {
-      const editor = this.molfilesEditor;
-      const resList = helmStrList.map((helmStr, i) => {
-        //no-draw instruction to avoid time spent on rendering
-        editor.helm && (editor.helm.noDraw = true);
-        editor.setHelm(helmStr);
-        const mol = editor.getMolfile();
-        return mol;
-      });
-      return resList;
-    } finally {
-      // $(host).empty();
-      // host.remove();
-    }
+    return this.editorAdapter.getMolfiles(helmStrList);
   }
 
   public parse(helm: string, origin?: Point): HelmMol {
-    const molHandler = new JSDraw2.MolHandler<HelmType, IHelmBio, IHelmEditorOptions>();
-    const plugin = new org.helm.webeditor.Plugin(molHandler);
-    org.helm.webeditor.IO.parseHelm(plugin, helm, origin ?? new JSDraw2.Point(0, 0));
-    return plugin.jsd.m;
+    return this.editorAdapter.parse(helm, origin) as unknown as HelmMol;
   }
 
   removeGaps(srcHelm: string): HelmConvertRes {
-    const monomerMap = new Map<number, number>();
-    const mol: HelmMol = this.parse(srcHelm);
-    for (let aI: number = mol.atoms.length - 1; aI >= 0; --aI) {
-      const a = mol.atoms[aI];
-      if (a.elem === HELM_GAP_SYMBOL /* '*' - original */) {
-        // Collect all bonds connected to this gap atom, tracking which side the gap is on
-        const connectedBonds: { bI: number, gapSide: 1 | 2 }[] = [];
-        for (let bI: number = mol.bonds.length - 1; bI >= 0; --bI) {
-          const b = mol.bonds[bI];
-          if (b.a1 === a) connectedBonds.push({bI, gapSide: 1}); // gap is a1
-          else if (b.a2 === a) connectedBonds.push({bI, gapSide: 2}); // gap is a2
-        }
-
-        if (connectedBonds.length > 2) {
-          throw new HelmNotSupportedError(
-            `Removing gap monomer #${aI} with ${connectedBonds.length} bonds is unsupported (max 2).`);
-        }
-
-        // Separate into backbone bonds (R1/R2) and other bonds (R3+ cross-polymer)
-        // A backbone bond connects to the gap's R1 or R2 attachment point
-        let backboneR1Bond: { bI: number, gapSide: 1 | 2 } | null = null; // bond using gap's R1
-        let backboneR2Bond: { bI: number, gapSide: 1 | 2 } | null = null; // bond using gap's R2
-        const otherBonds: number[] = []; // bond indices to just remove
-
-        for (const cb of connectedBonds) {
-          const bond = mol.bonds[cb.bI];
-          // The R-group on the gap's side tells us which attachment point is used
-          const gapR = cb.gapSide === 1 ? bond.r1 : bond.r2;
-          const gapRNum = typeof gapR === 'string' ? parseInt(gapR.replace(/\D/g, '')) : gapR;
-          if (gapRNum === 1)
-            backboneR1Bond = cb;
-          else if (gapRNum === 2)
-            backboneR2Bond = cb;
-          else
-            otherBonds.push(cb.bI);
-        }
-
-        // Remove other (non-backbone) bonds first (iterate in reverse to keep indices valid)
-        otherBonds.sort((a, b) => b - a);
-        for (const bI of otherBonds)
-          mol.bonds.splice(bI, 1);
-
-        // Recalculate bond indices after splice (otherBonds were removed)
-        // We need to adjust backboneR1Bond/R2Bond indices
-        const adjustIdx = (origBi: number): number => {
-          let adj = origBi;
-          for (const removedBi of otherBonds)
-            if (removedBi < origBi) adj--;
-          return adj;
-        };
-
-        const r1 = backboneR1Bond ? {...backboneR1Bond, bI: adjustIdx(backboneR1Bond.bI)} : null;
-        const r2 = backboneR2Bond ? {...backboneR2Bond, bI: adjustIdx(backboneR2Bond.bI)} : null;
-
-        if (r1 && r2) {
-          // Re-link: the neighbor on the R1 side connects directly to the neighbor on the R2 side
-          const r1Bond = mol.bonds[r1.bI];
-          const r2Bond = mol.bonds[r2.bI];
-          // The "other" atom (not the gap) on each bond
-          const r1Neighbor = r1.gapSide === 1 ? r1Bond.a2 : r1Bond.a1;
-          const r2Neighbor = r2.gapSide === 1 ? r2Bond.a2 : r2Bond.a1;
-          const r1NeighborR = r1.gapSide === 1 ? r1Bond.r2 : r1Bond.r1;
-          const r1NeighborApo = r1.gapSide === 1 ? r1Bond.apo2 : r1Bond.apo1;
-          const r2NeighborR = r2.gapSide === 1 ? r2Bond.r2 : r2Bond.r1;
-          const r2NeighborApo = r2.gapSide === 1 ? r2Bond.apo2 : r2Bond.apo1;
-
-          // Rewrite the R1 bond to connect r1Neighbor ↔ r2Neighbor directly
-          r1Bond.a1 = r1Neighbor;
-          r1Bond.r1 = r1NeighborR;
-          r1Bond.apo1 = r1NeighborApo;
-          r1Bond.a2 = r2Neighbor;
-          r1Bond.r2 = r2NeighborR;
-          r1Bond.apo2 = r2NeighborApo;
-
-          // Remove the R2 bond (no longer needed)
-          mol.bonds.splice(r2.bI, 1);
-        } else if (r1 && !r2) {
-          // Gap at the end (only R1 bond) — just remove
-          mol.bonds.splice(r1.bI, 1);
-        } else if (!r1 && r2) {
-          // Gap at the start (only R2 bond) — just remove
-          mol.bonds.splice(r2.bI, 1);
-        }
-        // else: isolated gap, no backbone bonds — just remove atom
-
-        mol.atoms.splice(aI, 1);
-      }
+    return this.editorAdapter.removeGaps(srcHelm);
+  }
+
+  private _singeHelmDf: DG.DataFrame | null = null;
+  private _getSingleHelmDf(helm: string) {
+    if (this._singeHelmDf === null) {
+      const col = DG.Column.fromStrings('helm', [helm]);
+      col.setTag('quality', DG.SEMTYPE.MACROMOLECULE);
+      col.setTag('units', 'helm');
+      col.setTag('.alphabetIsMultichar', 'true');
+      col.setTag('alphabet', 'UN');
+      this._singeHelmDf = DG.DataFrame.fromColumns([col]);
     }
+    this._singeHelmDf.col('helm')!.set(0, helm);
+    return this._singeHelmDf;
+  }
 
-    for (let aI: number = 0; aI < mol.atoms.length; ++aI) {
-      const a: HelmAtom = mol.atoms[aI];
-      monomerMap.set(a.bio!.continuousId - 1, aI);
+  private _singleHelmSh: ISeqHandler | null = null;
+  private _getSingleHelmDfSh(helm: string) {
+    if (!this._singleHelmSh) {
+      const df = this._getSingleHelmDf(helm);
+      this._singleHelmSh = this.seqHelper.getSeqHandler(df.col('helm')!);
     }
-
-    const resHelm = org.helm.webeditor.IO.getHelm(mol)!;
-    return {srcHelm, resHelm, monomerMap};
+    return this._singleHelmSh;
+  }
+
+  private async _atomicLevelProvider(helm: string) {
+    const df = this._getSingleHelmDf(helm);
+    const semValue = DG.SemanticValue.fromTableCell(df.cell(0, 'helm')!);
+    const w: DG.Widget = await grok.functions.call('Bio:toAtomicLevelPanel', {sequence: semValue}) as DG.Widget;
+    return w.root;
+  }
+
+  private async _compositionAnalysisProvider(helm: string) {
+    const df = this._getSingleHelmDf(helm);
+    const semValue = DG.SemanticValue.fromTableCell(df.cell(0, 'helm')!);
+    const w: DG.Widget = await grok.functions.call('Bio:compositionAnalysisWidget', {sequence: semValue}) as DG.Widget;
+    return w.root;
+  }
+
+  private _toBilnProvider(helm: string) {
+    const parseResult = this.editorAdapter.service.parse(helm);
+    if (parseResult.mol.chains.length < 1 || parseResult.mol.chains.some((c) => c.polymerType !== PolymerTypes.PEPTIDE))
+      return ui.divText('Unsupported sequence for BILN');
+    const sh = this._getSingleHelmDfSh(helm);
+    const ta = ui.input.textArea('', {});
+    ta.value = sh.getConverter(NOTATION.BILN)(helm);
+    ta.input.setAttribute('disabled', 'true');
+    ta.input.style.width = '100%';
+    return ta.input;
+  }
+
+  private _toFastaProvider(helm: string) {
+    const parseResult = this.editorAdapter.service.parse(helm);
+    if (parseResult.mol.chains.length !== 1 ||
+      parseResult.mol.atoms.length !== parseResult.mol.bonds.filter((b) => b.kind !== 'hbond').length + 1
+    )
+      return ui.divText('Unsupported sequence for FASTA');
+    const sh = this._getSingleHelmDfSh(helm);
+    const ta = ui.input.textArea('', {});
+    ta.value = sh.getConverter(NOTATION.FASTA)(helm);
+    ta.input.setAttribute('disabled', 'true');
+    ta.input.style.width = '100%';
+    return ta.input;
   }
 }

package/src/package-api.ts

@@ -12,35 +12,38 @@ export namespace funcs {
     return await grok.functions.call('Helm:InitHelm', {});
   }
 
-  /**
-  Helm renderer service
-  */
-  export async function getHelmService(): Promise<any> {
-    return await grok.functions.call('Helm:GetHelmService', {});
-  }
-
   export async function helmCellRenderer(): Promise<any> {
     return await grok.functions.call('Helm:HelmCellRenderer', {});
   }
 
   /**
-  Macromolecule
-  */
+   * Macromolecule
+   */
   export async function editMoleculeCell(cell: any ): Promise<void> {
     return await grok.functions.call('Helm:EditMoleculeCell', { cell });
   }
 
   /**
-  Adds editor
-  */
+   * Adds editor
+   * @param {any} mol
+   *   semType: Macromolecule
+   */
   export async function openEditor(mol: any ): Promise<void> {
     return await grok.functions.call('Helm:OpenEditor', { mol });
   }
 
+  /**
+   * @param {any} sequence
+   *   semType: Macromolecule
+   */
   export async function propertiesWidget(sequence: any ): Promise<any> {
     return await grok.functions.call('Helm:PropertiesWidget', { sequence });
   }
 
+  /**
+   * @param {DG.Column} col
+   *   semType: Macromolecule
+   */
   export async function getMolfiles(col: DG.Column ): Promise<DG.Column> {
     return await grok.functions.call('Helm:GetMolfiles', { col });
   }

package/src/package-test.ts

@@ -10,11 +10,9 @@ import {runTests, tests, TestContext, initAutoTests as initTests} from '@datagro
 import './tests/_first-tests';
 import './tests/helm-tests';
 import './tests/findMonomers-tests';
-import './tests/helm-service-tests';
 import './tests/renderers-tests';
 import './tests/get-molfiles-tests';
 import './tests/properties-widget-tests';
-import './tests/get-monomer-tests';
 import './tests/parse-helm-tests';
 import './tests/helm-web-editor-tests';
 import './tests/helm-input-tests';