#10216 - Refactor: Explicit Any type clean up (part 5.1) (#10217)

* #10216 - Replace explicit any with typed/unknown alternatives (part 5.1)

Remove explicit any from the KET serializers and editor/UI code:
- serializers.types: default KetFileNode<T = unknown> + new KetFileRootContent; narrow the rgroup case in ketSerializer accordingly
- multitailArrowToStruct / imageToStruct: type ketItem via the entity fromKetNode param types
- multitailArrowsValidator: type json as KetFileRootContent
- isMacroMolecule: type dragCtx via the existing DragContext
- templatePreview: type the action promise as a tuple
- closest: Map<number, number> for the merge reducer
- Recognize / Check: ThunkDispatch for mapDispatchToProps; typed window.webkitURL

The four remaining flagged locations (Tool.ts, Select.tsx, Tabs.types.ts, SettingsManager.ts) require refactors/dependency changes beyond a type swap and are split into a follow-up.

* #10216 - Address svvald review comments

- isMacroMolecule: simplify dragCtx param to DragContext (mergeItems is on the shared base; only caller passes a DragContext).
- serializers.types: extract KetFileRoot interface instead of inlining root: { nodes }.
- Recognize: extract a WindowWithWebkitURL type alias instead of the inline window cast.
- ketcher-core actions/template: add force-keyed overloads to fromTemplateOnBondAction (sync tuple vs Promise) so templatePreview no longer casts its result.

Author: mariam-khutuashvili

packages/ketcher-core/src/application/editor/actions/template.ts

@@ -222,6 +222,26 @@ export function fromTemplateOnAtom(
   return [action, pasteItems];
 }
 
+type FromTemplateOnBondResult = [Action, { atoms: number[]; bonds: number[] }];
+
+export function fromTemplateOnBondAction(
+  restruct,
+  template,
+  bid,
+  events,
+  flip,
+  force: false,
+  isPreview?: boolean,
+): FromTemplateOnBondResult;
+export function fromTemplateOnBondAction(
+  restruct,
+  template,
+  bid,
+  events,
+  flip,
+  force: true,
+  isPreview?: boolean,
+): Promise<FromTemplateOnBondResult>;
 export function fromTemplateOnBondAction(
   restruct,
   template,

packages/ketcher-core/src/domain/serializers/ket/fromKet/imageToStruct.ts

@@ -15,10 +15,12 @@
  ***************************************************************************/
 
 import type { Struct } from 'domain/entities/struct';
-import { Image } from 'domain/entities/image';
+import { type KetFileImageNode, Image } from 'domain/entities/image';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function imageToStruct(ketItem: any, struct: Struct): Struct {
+export function imageToStruct(
+  ketItem: KetFileImageNode,
+  struct: Struct,
+): Struct {
   struct.images.add(Image.fromKetNode(ketItem));
   return struct;
 }

packages/ketcher-core/src/domain/serializers/ket/fromKet/multitailArrowToStruct.ts

@@ -1,8 +1,14 @@
 import type { Struct } from 'domain/entities/struct';
-import { MultitailArrow } from 'domain/entities/multitailArrow';
+import {
+  type KetFileMultitailArrowNode,
+  MultitailArrow,
+} from 'domain/entities/multitailArrow';
+import type { KetFileNode } from 'domain/serializers/serializers.types';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function multitailArrowToStruct(ketItem: any, struct: Struct) {
+export function multitailArrowToStruct(
+  ketItem: KetFileNode<KetFileMultitailArrowNode>,
+  struct: Struct,
+) {
   struct.addMultitailArrow(MultitailArrow.fromKetNode(ketItem));
   return struct;
 }

packages/ketcher-core/src/domain/serializers/ket/ketSerializer.ts

@@ -206,11 +206,9 @@ export class KetSerializer implements Serializer<Struct> {
           break;
         }
         case 'rgroup': {
-          result.root.nodes.push({ $ref: `rg${item.data!.rgnumber}` });
-          result[`rg${item.data!.rgnumber}`] = rgroupToKet(
-            item.fragment!,
-            item.data,
-          );
+          const { rgnumber } = item.data as { rgnumber: number };
+          result.root.nodes.push({ $ref: `rg${rgnumber}` });
+          result[`rg${rgnumber}`] = rgroupToKet(item.fragment!, item.data);
           break;
         }
         case 'plus': {

packages/ketcher-core/src/domain/serializers/ket/multitailArrowsValidator.ts

@@ -1,12 +1,14 @@
-import type { KetFileNode } from 'domain/serializers/serializers.types';
+import type {
+  KetFileNode,
+  KetFileRootContent,
+} from 'domain/serializers/serializers.types';
 import {
   type KetFileMultitailArrowNode,
   MultitailArrow,
 } from 'domain/entities/multitailArrow';
 import { MULTITAIL_ARROW_SERIALIZE_KEY } from 'domain/constants';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const validateMultitailArrows = (json: any): boolean => {
+export const validateMultitailArrows = (json: KetFileRootContent): boolean => {
   const nodes: Array<KetFileNode<unknown>> = json.root.nodes;
   return nodes.every((node) => {
     if (node.type === MULTITAIL_ARROW_SERIALIZE_KEY) {

packages/ketcher-core/src/domain/serializers/serializers.types.ts

@@ -21,11 +21,18 @@ export interface Serializer<T> {
   serialize: (struct: T) => string;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface KetFileNode<T = any> {
+export interface KetFileNode<T = unknown> {
   type: string;
   fragment?: Struct;
   center: Vec2;
   data?: T;
   selected?: boolean;
 }
+
+export interface KetFileRoot {
+  nodes: KetFileNode[];
+}
+
+export interface KetFileRootContent {
+  root: KetFileRoot;
+}

packages/ketcher-react/src/script/editor/shared/closest.ts

@@ -614,26 +614,24 @@ function findCloseMerge(
           mergeAtomToFunctionalGroup(atomId, restruct, atomPosition, result);
       });
     } else {
-      result[map] = Array.from(pos[map].keys()).reduce(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        (res: Map<any, any>, srcId) => {
-          const skip = { map, id: srcId };
-          const item = findMaps[map](
-            restruct,
-            pos[map].get(srcId),
-            skip,
-            null,
-            options,
-          );
-
-          if (item && !selected[map].includes(item.id)) {
-            res.set(srcId, item.id);
-          }
-
-          return res;
-        },
-        new Map(),
-      );
+      result[map] = Array.from<number>(pos[map].keys()).reduce<
+        Map<number, number>
+      >((res, srcId) => {
+        const skip = { map, id: srcId };
+        const item = findMaps[map](
+          restruct,
+          pos[map].get(srcId),
+          skip,
+          null,
+          options,
+        );
+
+        if (item && !selected[map].includes(item.id)) {
+          res.set(srcId, item.id);
+        }
+
+        return res;
+      }, new Map());
     }
   });
 

packages/ketcher-react/src/script/editor/tool/helper/isMacroMolecule.ts

@@ -1,13 +1,15 @@
 import type { Editor } from '../../Editor';
+import type { DragContext } from '../select/select.types';
 
 const isMacroMolecule = (editor: Editor, id: number): boolean => {
   const struct = editor.struct();
   return struct.isFunctionalGroupFromMacromolecule(id);
 };
 
-// dragCtx is actually "any" in the code
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isMergingToMacroMolecule = (editor: Editor, dragCtx: any): boolean => {
+const isMergingToMacroMolecule = (
+  editor: Editor,
+  dragCtx: DragContext,
+): boolean => {
   const funcGroups = dragCtx?.mergeItems?.atomToFunctionalGroup;
   if (!funcGroups?.size) {
     return false;

packages/ketcher-react/src/script/editor/tool/templatePreview.ts

@@ -196,8 +196,7 @@ class TemplatePreview {
         shouldFlip,
         true,
         true,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ) as Promise<any>;
+      );
 
       promise.then(([action, pasteItems]) => {
         if (!this.isModeFunctionalGroup) {

packages/ketcher-react/src/script/ui/views/modal/components/process/Check/Check.tsx

@@ -16,6 +16,8 @@
 
 import { type ComponentType, type FC, useEffect, useState } from 'react';
 import { connect } from 'react-redux';
+import type { AnyAction } from 'redux';
+import type { ThunkDispatch } from 'redux-thunk';
 import Form, {
   type FormState,
   Field,
@@ -312,7 +314,7 @@ const mapStateToProps = (state: State): CheckDialogStateProps => ({
 });
 
 const mapDispatchToProps = (
-  dispatch: any, // eslint-disable-line @typescript-eslint/no-explicit-any
+  dispatch: ThunkDispatch<State, undefined, AnyAction>,
   ownProps: CheckDialogOwnProps,
 ): CheckDialogDispatchProps => ({
   onCheck: (opts: CheckOption[]) =>