@datagrok/bio 2.26.6 → 2.26.8

package/src/utils/monomer-lib/monomer-collections-view.ts

@@ -9,6 +9,8 @@ import {HelmTypes} from '@datagrok-libraries/bio/src/helm/consts';
 import {MonomerSelectionWidget} from '@datagrok-libraries/bio/src/utils/monomer-selection-dialog';
 
 import {MonomerLibManager} from './lib-manager';
+import {MonomerCollectionHandler, MonomerCollectionInfo} from './monomer-collection-handler';
+import {SEM_TYPES} from '../constants';
 import {_package} from '../../package';
 
 //@ts-ignore
@@ -29,6 +31,12 @@ export class MonomerCollectionsView {
   private currentUser: string = '';
   /** Cached collection data for search filtering */
   private collectionsCache: Map<string, MonomerCollection> = new Map();
+  /** Currently selected collection names */
+  private selectedCollections: Set<string> = new Set();
+  /** Map of collection name -> card element for quick access */
+  private cardElements: Map<string, HTMLDivElement> = new Map();
+  /** The handler instance for context menu and actions */
+  private handler: MonomerCollectionHandler = new MonomerCollectionHandler();
 
   static readonly VIEW_NAME = 'Monomer Collections';
 
@@ -40,13 +48,15 @@ export class MonomerCollectionsView {
 
     this.view = DG.View.create();
     this.view.name = MonomerCollectionsView.VIEW_NAME;
+    // Store reference for the handler to find
+    (this.view as any)._mcView = this;
 
     // Ribbon
     const addBtn = ui.icons.add(() => this.showAddCollectionDialog(), 'Create new monomer collection');
     const refreshBtn = ui.iconFA('sync', () => this.refresh(), 'Refresh collections');
     this.view.setRibbonPanels([[addBtn, refreshBtn]]);
 
-    // Context menu
+    // Background context menu (not on cards)
     this.view.root.addEventListener('contextmenu', (e: MouseEvent) => {
       const target = e.target as HTMLElement;
       if (target.closest('.monomer-collection-card') || target.closest('.monomer-collection-add-card'))
@@ -58,6 +68,20 @@ export class MonomerCollectionsView {
       menu.show();
     });
 
+    // Click on empty space deselects all
+    this.view.root.addEventListener('click', (e: MouseEvent) => {
+      const target = e.target as HTMLElement;
+      if (!target.closest('.monomer-collection-card') && !target.closest('.monomer-collection-add-card'))
+        this.clearSelection();
+    });
+
+    // Escape key clears selection
+    this.view.root.tabIndex = 0;
+    this.view.root.addEventListener('keydown', (e: KeyboardEvent) => {
+      if (e.key === 'Escape')
+        this.clearSelection();
+    });
+
     await this.buildContent();
     return this.view;
   }
@@ -125,13 +149,17 @@ export class MonomerCollectionsView {
 
     this.displayedCount = 0;
     this.cardsContainer!.innerHTML = '';
+    this.cardElements.clear();
     this.showNextPage();
   }
 
   private showNextPage(): void {
     const end = Math.min(this.displayedCount + PAGE_SIZE, this.filteredNames.length);
-    for (let i = this.displayedCount; i < end; i++)
-      this.cardsContainer!.appendChild(this.createCollectionCard(this.filteredNames[i]));
+    for (let i = this.displayedCount; i < end; i++) {
+      const card = this.createCollectionCard(this.filteredNames[i]);
+      this.cardsContainer!.appendChild(card);
+      this.cardElements.set(this.filteredNames[i], card);
+    }
 
     this.displayedCount = end;
 
@@ -175,6 +203,34 @@ export class MonomerCollectionsView {
     const actionsEl = ui.div([], {classes: 'monomer-collection-card-actions'});
 
     const card = ui.div([headerEl, bodyEl, actionsEl], {classes: 'monomer-collection-card'}) as HTMLDivElement;
+    card.dataset.collectionName = collectionName;
+
+    // Apply selected state if already selected
+    if (this.selectedCollections.has(collectionName))
+      card.classList.add('monomer-collection-card-selected');
+
+    // Click handler: select card and set as current object
+    card.addEventListener('click', (e: MouseEvent) => {
+      // Don't handle clicks on buttons or monomer tags
+      const target = e.target as HTMLElement;
+      if (target.closest('.monomer-collection-card-actions') || target.closest('.monomer-collection-tag'))
+        return;
+
+      e.stopPropagation();
+      this.handleCardClick(collectionName, e.ctrlKey || e.metaKey);
+    });
+
+    // Right-click context menu
+    card.addEventListener('contextmenu', (e: MouseEvent) => {
+      e.preventDefault();
+      e.stopPropagation();
+
+      // If right-clicking a non-selected card, select it first
+      if (!this.selectedCollections.has(collectionName))
+        this.handleCardClick(collectionName, false);
+
+      this.showCardContextMenu(e);
+    });
 
     // Load content in background
     const loadContent = async (): Promise<HTMLElement> => {
@@ -222,20 +278,31 @@ export class MonomerCollectionsView {
           }
         });
         tag.addEventListener('mouseleave', () => ui.tooltip.hide());
+        // Clicking a monomer tag sets its SemanticValue as the current object
+        tag.addEventListener('click', (e: MouseEvent) => {
+          e.stopPropagation();
+          grok.shell.o = DG.SemanticValue.fromValueType(symbol, SEM_TYPES.MONOMER);
+        });
         monomerTagsContainer.appendChild(tag);
       }
 
       const countLabel = ui.divText(`${symbols.length} monomer(s)`, {style: {fontSize: '11px', color: 'var(--grey-4)', marginBottom: '6px'}});
       const contentDiv = ui.divV([countLabel, monomerTagsContainer]);
 
-      // Actions: only show edit/delete if the current user matches updatedBy
+      // Actions: show edit/delete with disabled state for non-owners
       const isOwner = collection.updatedBy === this.currentUser;
-      if (isOwner) {
-        const editBtn = ui.button('Edit', () => this.showEditCollectionDialog(collectionName, collection));
-        const deleteBtn = ui.button('Delete', () => this.confirmDeleteCollection(collectionName));
-        actionsEl.appendChild(editBtn);
-        actionsEl.appendChild(deleteBtn);
+      const editBtn = ui.button('Edit', () => { if (isOwner) this.showEditCollectionDialog(collectionName, collection); });
+      const deleteBtn = ui.button('Delete', () => { if (isOwner) this.confirmDeleteCollection(collectionName); });
+      if (!isOwner) {
+        for (const btn of [editBtn, deleteBtn]) {
+          btn.style.opacity = '0.4';
+          btn.style.cursor = 'default';
+        }
+        ui.tooltip.bind(editBtn, 'Only the author can edit');
+        ui.tooltip.bind(deleteBtn, 'Only the author can delete');
       }
+      actionsEl.appendChild(editBtn);
+      actionsEl.appendChild(deleteBtn);
 
       return contentDiv;
     };
@@ -244,6 +311,91 @@ export class MonomerCollectionsView {
     return card;
   }
 
+  /** Handle card click with optional Ctrl/Cmd for multi-select. */
+  private handleCardClick(collectionName: string, isMulti: boolean): void {
+    if (isMulti) {
+      // Toggle selection
+      if (this.selectedCollections.has(collectionName))
+        this.selectedCollections.delete(collectionName);
+      else
+        this.selectedCollections.add(collectionName);
+    } else {
+      // Single select: clear others
+      this.selectedCollections.clear();
+      this.selectedCollections.add(collectionName);
+    }
+
+    this.updateCardSelectionStyles();
+    this.setCurrentObject();
+  }
+
+  /** Clear all selections. */
+  private clearSelection(): void {
+    this.selectedCollections.clear();
+    this.updateCardSelectionStyles();
+  }
+
+  /** Update card CSS classes to reflect current selection. */
+  private updateCardSelectionStyles(): void {
+    for (const [name, card] of this.cardElements) {
+      if (this.selectedCollections.has(name))
+        card.classList.add('monomer-collection-card-selected');
+      else
+        card.classList.remove('monomer-collection-card-selected');
+    }
+  }
+
+  /** Set the current object in grok.shell.o based on selection. */
+  private async setCurrentObject(): Promise<void> {
+    const selected = [...this.selectedCollections];
+    if (selected.length === 0) return;
+
+    // Build MonomerCollectionInfo items for the selected collections
+    const infos: MonomerCollectionInfo[] = [];
+    for (const name of selected) {
+      let data = this.collectionsCache.get(name);
+      if (!data) {
+        try { data = await this.libHelper!.readMonomerCollection(name); } catch { continue; }
+      }
+      infos.push({
+        name,
+        displayName: name.replace(/\.json$/i, ''),
+        data,
+      });
+    }
+
+    if (infos.length === 1)
+      grok.shell.o = infos[0];
+    else if (infos.length > 1)
+      grok.shell.o = infos;
+  }
+
+  /** Show context menu for selected cards. */
+  private showCardContextMenu(e: MouseEvent): void {
+    const menu = DG.Menu.popup();
+    const selected = [...this.selectedCollections];
+
+    if (selected.length <= 1 && selected.length > 0) {
+      const name = selected[0];
+      const data = this.collectionsCache.get(name);
+      if (data) {
+        const info: MonomerCollectionInfo = {name, displayName: name.replace(/\.json$/i, ''), data};
+        MonomerCollectionHandler.buildContextMenu(menu, info, this.handler);
+      }
+    } else if (selected.length > 1) {
+      const items: MonomerCollectionInfo[] = selected
+        .map((name) => {
+          const data = this.collectionsCache.get(name);
+          return data ? {name, displayName: name.replace(/\.json$/i, ''), data} : null;
+        })
+        .filter((x): x is MonomerCollectionInfo => x !== null);
+      if (items.length > 0)
+        MonomerCollectionHandler.buildMultiContextMenu(menu, items, this.handler);
+    }
+
+    menu.show();
+  }
+
   private getMonomerTooltipSafe(symbol: string): HTMLElement | null {
     if (!this.monomerLib) return null;
     const helmTypes: HelmType[] = [HelmTypes.AA, HelmTypes.NUCLEOTIDE, HelmTypes.CHEM, HelmTypes.BLOB];
@@ -321,6 +473,11 @@ export class MonomerCollectionsView {
     monomerWidget.focus();
   }
 
+  /** Public method so the handler can trigger edit from the context panel. */
+  editCollectionPublic(collectionName: string, collection: MonomerCollection): void {
+    this.showEditCollectionDialog(collectionName, collection);
+  }
+
   private showEditCollectionDialog(collectionName: string, collection: MonomerCollection): void {
     const displayName = collectionName.replace(/\.json$/i, '');
     const nameInput = ui.input.string('Name', {value: displayName, nullable: false});
@@ -395,6 +552,7 @@ export class MonomerCollectionsView {
   }
 
   async refresh(): Promise<void> {
+    this.selectedCollections.clear();
     await this.loadCollections();
   }
 }

package/src/widgets/monomer-info-widget.ts

@@ -0,0 +1,119 @@
+/* eslint-disable max-len */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {IMonomerLib, Monomer} from '@datagrok-libraries/bio/src/types/monomer-library';
+import {HELM_REQUIRED_FIELD as REQ, HELM_RGROUP_FIELDS as RGP} from '@datagrok-libraries/bio/src/utils/const';
+import {MONOMER_MOTIF_SPLITTER, MONOMER_CANONICALIZER_TEMP} from '@datagrok-libraries/bio/src/utils/macromolecule/consts';
+import {IMonomerCanonicalizer} from '@datagrok-libraries/bio/src/utils/macromolecule/types';
+
+import {getCorrectedSmiles, capSmiles} from '../utils/monomer-lib/monomer-manager/monomer-manager';
+
+/** Caps the monomer (replaces R-groups with cap atoms) and returns capped SMILES. */
+function getCappedSmiles(monomer: Monomer): string | null {
+  try {
+    const corrected = getCorrectedSmiles(monomer[REQ.RGROUPS], monomer.smiles, monomer.molfile);
+    return capSmiles(corrected, monomer[REQ.RGROUPS]);
+  } catch { /* capping may fail for some monomers */ }
+  return null;
+}
+
+/** Renders a single-monomer details pane content. */
+function renderMonomerDetails(monomer: Monomer): HTMLElement {
+  const map: {[key: string]: any} = {
+    'Symbol': monomer[REQ.SYMBOL],
+    'Name': monomer[REQ.NAME],
+    'Polymer Type': monomer[REQ.POLYMER_TYPE],
+    'Monomer Type': monomer[REQ.MONOMER_TYPE],
+  };
+  if (monomer[REQ.AUTHOR])
+    map['Author'] = monomer[REQ.AUTHOR];
+  if (monomer.naturalAnalog)
+    map['Natural Analog'] = monomer.naturalAnalog;
+  if (monomer.lib?.source) {
+    let source = monomer.lib.source;
+    if (source.endsWith('.json'))
+      source = source.substring(0, source.length - 5);
+    map['Library'] = source;
+  }
+
+  // Structure
+  if (monomer.molfile)
+    map['Structure'] = grok.chem.drawMolecule(monomer.molfile, 150, 150);
+  else if (monomer.smiles)
+    map['Structure'] = grok.chem.drawMolecule(monomer.smiles, 150, 150);
+
+  // R-Groups
+  const rgroups = monomer[REQ.RGROUPS];
+  if (rgroups && rgroups.length > 0) {
+    for (const rg of rgroups)
+      map[rg[RGP.LABEL] ?? '?'] = rg[RGP.ALTERNATE_ID] ?? '';
+  }
+
+  return ui.tableFromMap(map);
+}
+
+/** Renders the molecule info panel pane content for a single monomer. */
+function renderMoleculePane(monomer: Monomer): HTMLElement {
+  const cappedMol = getCappedSmiles(monomer);
+  if (!cappedMol)
+    return ui.divText('No molecular structure available');
+
+  const molSv = DG.SemanticValue.fromValueType(cappedMol, DG.SEMTYPE.MOLECULE);
+  return ui.panels.infoPanel(molSv).root;
+}
+
+/** Tries to get the canonicalizer from the SemanticValue's cell column. */
+function getCanonicalizer(sv: DG.SemanticValue): IMonomerCanonicalizer | null {
+  try {
+    const col = sv.cell?.column;
+    if (col)
+      return col.temp[MONOMER_CANONICALIZER_TEMP] ?? null;
+  } catch { /* no cell context */ }
+  return null;
+}
+
+/** Creates a widget for the monomer info panel shown in the context panel. */
+export function getMonomerInfoWidget(sv: DG.SemanticValue, monomerLib: IMonomerLib): DG.Widget {
+  const rawValue = sv.value as string;
+  if (!rawValue)
+    return new DG.Widget(ui.divText('No monomer value.'));
+
+  // Canonicalize if a canonicalizer is available from the column context
+  const canonicalizer = getCanonicalizer(sv);
+  const canonicalized = canonicalizer ? canonicalizer.canonicalize(rawValue) : rawValue;
+
+  // Split by motif splitter — a cell value may contain multiple monomers
+  const symbols = canonicalized.split(MONOMER_MOTIF_SPLITTER).map((s) => s.trim()).filter((s) => s.length > 0);
+
+  // Resolve monomers from library
+  const monomers: {symbol: string; monomer: Monomer | null}[] =
+    symbols.map((s) => ({symbol: s, monomer: monomerLib.getMonomer(null, s)}));
+
+  const found = monomers.filter((m) => m.monomer !== null);
+  if (found.length === 0)
+    return new DG.Widget(ui.divText(`Monomer '${rawValue}' not found in the library.`));
+
+  const acc = ui.accordion('Monomer');
+
+  if (found.length === 1) {
+    // Single monomer — flat panes
+    const m = found[0].monomer!;
+    acc.addPane('Details', () => renderMonomerDetails(m), true);
+    acc.addPane('Molecule', () => renderMoleculePane(m), true);
+  } else {
+    // Multiple monomers — one pane per monomer
+    for (const {symbol, monomer} of found) {
+      acc.addPane(symbol, () => {
+        return ui.divV([
+          renderMonomerDetails(monomer!),
+          ui.element('hr'),
+          renderMoleculePane(monomer!),
+        ]);
+      }, true);
+    }
+  }
+
+  return new DG.Widget(acc.root);
+}