#3738 - Macro/Micro: Switching from Macromolecules view to Molecules …

…view causes crash if custom aromatic hydrocarbon was connected with monomer

- added ability to bond micro and macro structures in macro mode

packages/ketcher-core/src/application/editor/MacromoleculesConverter.ts

@@ -76,20 +76,31 @@ export class MacromoleculesConverter {
   }
 
   private static findAttachmentPointAtom(
-    sgroup: SGroup,
     polymerBond: PolymerBond,
     monomer: BaseMonomer,
     struct: Struct,
+    sgroup?: SGroup,
+    fragmentId?: number,
   ) {
     const attachmentPointName = monomer.getAttachmentPointByBond(polymerBond);
     assert(attachmentPointName);
-    return sgroup.atoms.find(
-      (atomId) =>
-        Number(struct.atoms.get(atomId)?.rglabel) ===
-        MacromoleculesConverter.convertAttachmentPointNameToNumber(
-          attachmentPointName,
-        ),
-    );
+    const attachmentPointNumber =
+      MacromoleculesConverter.convertAttachmentPointNameToNumber(
+        attachmentPointName,
+      );
+
+    return sgroup
+      ? sgroup.atoms.find(
+          (atomId) =>
+            Number(struct.atoms.get(atomId)?.rglabel) === attachmentPointNumber,
+        )
+      : struct.atoms.find((atomId) => {
+          const atom = struct.atoms.get(atomId) as Atom;
+          return (
+            atom.fragment === fragmentId &&
+            Number(atom.rglabel) === attachmentPointNumber
+          );
+        });
   }
 
   public static convertDrawingEntitiesToStruct(
@@ -98,13 +109,15 @@ export class MacromoleculesConverter {
     reStruct?: ReStruct,
   ) {
     const monomerToSgroup = new Map<BaseMonomer, SGroup>();
+    const monomerToFragmentId = new Map<BaseMonomer, number>();
 
     drawingEntitiesManager.micromoleculesHiddenEntities.mergeInto(struct);
 
     drawingEntitiesManager.clearMicromoleculesHiddenEntities();
     drawingEntitiesManager.monomers.forEach((monomer) => {
       if (monomer.monomerItem.props.isMicromoleculeFragment) {
         monomer.monomerItem.struct.mergeInto(struct);
+        monomerToFragmentId.set(monomer, struct.frags.size - 1);
       } else {
         const atomIdsMap = {};
         const monomerMicromolecule = this.convertMonomerToMonomerMicromolecule(
@@ -146,16 +159,18 @@ export class MacromoleculesConverter {
     drawingEntitiesManager.polymerBonds.forEach((polymerBond) => {
       assert(polymerBond.secondMonomer);
       const beginAtom = this.findAttachmentPointAtom(
-        monomerToSgroup.get(polymerBond.firstMonomer) as SGroup,
         polymerBond,
         polymerBond.firstMonomer,
         struct,
+        monomerToSgroup.get(polymerBond.firstMonomer),
+        monomerToFragmentId.get(polymerBond.firstMonomer),
       );
       const endAtom = this.findAttachmentPointAtom(
-        monomerToSgroup.get(polymerBond.secondMonomer) as SGroup,
         polymerBond,
         polymerBond.secondMonomer,
         struct,
+        monomerToSgroup.get(polymerBond.secondMonomer),
+        monomerToFragmentId.get(polymerBond.secondMonomer),
       );
 
       if (!beginAtom || !endAtom) {
@@ -223,9 +238,9 @@ export class MacromoleculesConverter {
     );
   }
 
-  public static getAttachmentPointLabel(atomId: number, struct: Struct) {
+  public static getAttachmentPointLabel(atom: Atom) {
     let attachmentPointLabel = '';
-    const atomRglabel = Number(struct.atoms.get(atomId)?.rglabel);
+    const atomRglabel = Number(atom.rglabel);
     assert(Number.isInteger(atomRglabel));
     for (let rgi = 0; rgi < 32; rgi++) {
       if (atomRglabel & (1 << rgi)) {
@@ -240,6 +255,7 @@ export class MacromoleculesConverter {
     drawingEntitiesManager: DrawingEntitiesManager,
   ) {
     const sgroupToMonomer = new Map<SGroup, BaseMonomer>();
+    const fragmentIdToMonomer = new Map<number, BaseMonomer>();
     const command = new Command();
     struct.sgroups.forEach((sgroup) => {
       if (sgroup instanceof MonomerMicromolecule) {
@@ -255,30 +271,38 @@ export class MacromoleculesConverter {
     let fragmentNumber = 1;
     struct.frags.forEach((_fragment, fragmentId) => {
       const fragmentStruct = struct.getFragment(fragmentId, false);
-      command.merge(
-        this.convertFragmentToChem(
-          fragmentNumber,
-          fragmentStruct,
-          drawingEntitiesManager,
-        ),
+      const monomerAddCommand = this.convertFragmentToChem(
+        fragmentNumber,
+        fragmentStruct,
+        drawingEntitiesManager,
+      );
+      fragmentIdToMonomer.set(
+        fragmentId,
+        monomerAddCommand.operations[0].monomer as BaseMonomer,
       );
+      command.merge(monomerAddCommand);
       fragmentNumber++;
     });
     struct.bonds.forEach((bond) => {
+      const beginAtom = struct.atoms.get(bond.begin) as Atom;
+      const endAtom = struct.atoms.get(bond.end) as Atom;
       const beginAtomSgroup = struct.getGroupFromAtomId(bond.begin);
       const endAtomSgroup = struct.getGroupFromAtomId(bond.end);
       const beginAtomAttachmentPointNumber =
-        MacromoleculesConverter.getAttachmentPointLabel(bond.begin, struct);
+        MacromoleculesConverter.getAttachmentPointLabel(beginAtom);
       const endAtomAttachmentPointNumber =
-        MacromoleculesConverter.getAttachmentPointLabel(bond.end, struct);
-      if (
-        beginAtomAttachmentPointNumber &&
-        endAtomAttachmentPointNumber &&
-        beginAtomSgroup instanceof MonomerMicromolecule &&
-        endAtomSgroup instanceof MonomerMicromolecule
-      ) {
-        const firstMonomer = sgroupToMonomer.get(beginAtomSgroup);
-        const secondMonomer = sgroupToMonomer.get(endAtomSgroup);
+        MacromoleculesConverter.getAttachmentPointLabel(endAtom);
+      if (beginAtomAttachmentPointNumber && endAtomAttachmentPointNumber) {
+        // Here we take monomers from sgroupToMonomer in case of macromolecules structure and
+        // from fragmentIdToMonomer in case of micromolecules structure.
+        const firstMonomer =
+          beginAtomSgroup instanceof MonomerMicromolecule
+            ? sgroupToMonomer.get(beginAtomSgroup)
+            : fragmentIdToMonomer.get(beginAtom.fragment);
+        const secondMonomer =
+          endAtomSgroup instanceof MonomerMicromolecule
+            ? sgroupToMonomer.get(endAtomSgroup)
+            : fragmentIdToMonomer.get(endAtom.fragment);
         assert(firstMonomer);
         assert(secondMonomer);