chore: release version v1.82.0

Copy past systems with connections

CHANGELOG.md

@@ -2,6 +2,125 @@
 
 <!-- changelog -->
 
+## [v1.82.0](https://github.com/wanderer-industries/wanderer/compare/v1.81.15...v1.82.0) (2025-10-15)
+
+
+
+
+### Features:
+
+* Core: Added an ability to copy/paste selected map area between maps
+
+### Bug Fixes:
+
+* Map: Add ability to copy and past systems (UI part)
+
+## [v1.81.15](https://github.com/wanderer-industries/wanderer/compare/v1.81.14...v1.81.15) (2025-10-15)
+
+
+
+
+### Bug Fixes:
+
+* Map: Fixed problem with commit - for correct restore deprecated data - change config key
+
+## [v1.81.14](https://github.com/wanderer-industries/wanderer/compare/v1.81.13...v1.81.14) (2025-10-15)
+
+
+
+
+### Bug Fixes:
+
+* Map: Fixed problem with commit - for correct restore deprecated data
+
+## [v1.81.13](https://github.com/wanderer-industries/wanderer/compare/v1.81.12...v1.81.13) (2025-10-15)
+
+
+
+
+### Bug Fixes:
+
+* Core: Fixed system select after tab switch
+
+## [v1.81.12](https://github.com/wanderer-industries/wanderer/compare/v1.81.11...v1.81.12) (2025-10-15)
+
+
+
+
+### Bug Fixes:
+
+* Core: Fixed map events buffering on tab switch
+
+## [v1.81.11](https://github.com/wanderer-industries/wanderer/compare/v1.81.10...v1.81.11) (2025-10-15)
+
+
+
+
+### Bug Fixes:
+
+* Signatures: Fixed EOL indication for un-splashed and signatures list
+
+## [v1.81.10](https://github.com/wanderer-industries/wanderer/compare/v1.81.9...v1.81.10) (2025-10-13)
+
+
+
+
+### Bug Fixes:
+
+* Signatures: Rework for lazy signatures deletion
+
+## [v1.81.9](https://github.com/wanderer-industries/wanderer/compare/v1.81.8...v1.81.9) (2025-10-12)
+
+
+
+
+### Bug Fixes:
+
+* Signatures: Fixed issue with wrong linked signatures deletions
+
+## [v1.81.8](https://github.com/wanderer-industries/wanderer/compare/v1.81.7...v1.81.8) (2025-10-11)
+
+
+
+
+### Bug Fixes:
+
+* Map: Fix problem with restoring settings on widgets
+
+## [v1.81.7](https://github.com/wanderer-industries/wanderer/compare/v1.81.6...v1.81.7) (2025-10-10)
+
+
+
+
+### Bug Fixes:
+
+* Map: Fixed problem with rendering dropdown classes in signatures
+
+## [v1.81.6](https://github.com/wanderer-industries/wanderer/compare/v1.81.5...v1.81.6) (2025-10-10)
+
+
+
+
+### Bug Fixes:
+
+* Map: Fixed problem with a lot unnecessary loads zkb data on resize map
+
+* Map: Added ability to see focused element
+
+* Map: Removed unnecessary vertical scroller in Character Tracking dialog. Main always first in list of tracking characters, following next after main, another characters sorting by name
+
+* Map: Added Search tool for systems what on the map
+
+* Map: Added migration mechanism
+
+* Map: Remove settings some default values if migration from very old settings system
+
+* Map: MIGRATION: support from old store settings import
+
+* Map: Add common migration mechanism. ATTENTION! This is a non-reversible stored map settings commit — it means we do not guarantee that settings will work if you check out back. We’ve tried to migrate old settings, but it may not work well or may NOT work at all.
+
+* Map: Add front-end migrations for local store settings
+
 ## [v1.81.5](https://github.com/wanderer-industries/wanderer/compare/v1.81.4...v1.81.5) (2025-10-09)
 
 

assets/js/hooks/Mapper/MapRoot.tsx

@@ -9,6 +9,7 @@ import { useMapperHandlers } from './useMapperHandlers';
 import { MapRootContent } from '@/hooks/Mapper/components/mapRootContent/MapRootContent.tsx';
 import { MapRootProvider } from '@/hooks/Mapper/mapRootProvider';
 import './common-styles/main.scss';
+import { ToastProvider } from '@/hooks/Mapper/ToastProvider.tsx';
 
 const ErrorFallback = () => {
   return <div className="!z-100 absolute w-screen h-screen bg-transparent"></div>;
@@ -39,13 +40,15 @@ export default function MapRoot({ hooks }) {
 
   return (
     <PrimeReactProvider>
-      <MapRootProvider fwdRef={providerRef} outCommand={handleCommand}>
-        <ErrorBoundary FallbackComponent={ErrorFallback} onError={logError}>
-          <ReactFlowProvider>
-            <MapRootContent />
-          </ReactFlowProvider>
-        </ErrorBoundary>
-      </MapRootProvider>
+      <ToastProvider>
+        <MapRootProvider fwdRef={providerRef} outCommand={handleCommand}>
+          <ErrorBoundary FallbackComponent={ErrorFallback} onError={logError}>
+            <ReactFlowProvider>
+              <MapRootContent />
+            </ReactFlowProvider>
+          </ErrorBoundary>
+        </MapRootProvider>
+      </ToastProvider>
     </PrimeReactProvider>
   );
 }

assets/js/hooks/Mapper/ToastProvider.tsx

@@ -0,0 +1,31 @@
+import React, { createContext, useContext, useRef } from 'react';
+import { Toast } from 'primereact/toast';
+import type { ToastMessage } from 'primereact/toast';
+
+interface ToastContextValue {
+  toastRef: React.RefObject<Toast>;
+  show: (message: ToastMessage | ToastMessage[]) => void;
+}
+
+const ToastContext = createContext<ToastContextValue | null>(null);
+
+export const ToastProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const toastRef = useRef<Toast>(null);
+
+  const show = (message: ToastMessage | ToastMessage[]) => {
+    toastRef.current?.show(message);
+  };
+
+  return (
+    <ToastContext.Provider value={{ toastRef, show }}>
+      <Toast ref={toastRef} position="top-right" />
+      {children}
+    </ToastContext.Provider>
+  );
+};
+
+export const useToast = (): ToastContextValue => {
+  const context = useContext(ToastContext);
+  if (!context) throw new Error('useToast must be used within a ToastProvider');
+  return context;
+};

assets/js/hooks/Mapper/components/contexts/ContextMenuSystemMultiple/ContextMenuSystemMultiple.tsx

@@ -6,21 +6,28 @@ import { MenuItem } from 'primereact/menuitem';
 export interface ContextMenuSystemMultipleProps {
   contextMenuRef: RefObject<ContextMenu>;
   onDeleteSystems(): void;
+  onCopySystems(): void;
 }
 
 export const ContextMenuSystemMultiple: React.FC<ContextMenuSystemMultipleProps> = ({
   contextMenuRef,
   onDeleteSystems,
+  onCopySystems,
 }) => {
   const items: MenuItem[] = useMemo(() => {
     return [
+      {
+        label: 'Copy',
+        icon: PrimeIcons.COPY,
+        command: onCopySystems,
+      },
       {
         label: 'Delete',
         icon: PrimeIcons.TRASH,
         command: onDeleteSystems,
       },
     ];
-  }, [onDeleteSystems]);
+  }, [onCopySystems, onDeleteSystems]);
 
   return (
     <>

assets/js/hooks/Mapper/components/contexts/ContextMenuSystemMultiple/useContextMenuSystemMultipleHandlers.ts

@@ -6,27 +6,34 @@ import { ctxManager } from '@/hooks/Mapper/utils/contextManager.ts';
 import { NodeSelectionMouseHandler } from '@/hooks/Mapper/components/contexts/types.ts';
 import { useDeleteSystems } from '@/hooks/Mapper/components/contexts/hooks';
 import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
+import { encodeJsonToUriBase64 } from '@/hooks/Mapper/utils';
+import { useToast } from '@/hooks/Mapper/ToastProvider.tsx';
 
 export const useContextMenuSystemMultipleHandlers = () => {
   const {
-    data: { pings },
+    data: { pings, connections },
   } = useMapRootState();
 
+  const { show } = useToast();
+
   const contextMenuRef = useRef<ContextMenu | null>(null);
   const [systems, setSystems] = useState<Node<SolarSystemRawType>[]>();
 
   const { deleteSystems } = useDeleteSystems();
-
   const ping = useMemo(() => (pings.length === 1 ? pings[0] : undefined), [pings]);
+  const refVars = useRef({ systems, ping, connections, deleteSystems });
+  refVars.current = { systems, ping, connections, deleteSystems };
 
-  const handleSystemMultipleContext: NodeSelectionMouseHandler = (ev, systems_) => {
+  const handleSystemMultipleContext = useCallback<NodeSelectionMouseHandler>((ev, systems_) => {
     setSystems(systems_);
     ev.preventDefault();
     ctxManager.next('ctxSysMult', contextMenuRef.current);
     contextMenuRef.current?.show(ev);
-  };
+  }, []);
 
   const onDeleteSystems = useCallback(() => {
+    const { systems, ping, deleteSystems } = refVars.current;
+
     if (!systems) {
       return;
     }
@@ -41,11 +48,34 @@ export const useContextMenuSystemMultipleHandlers = () => {
     }
 
     deleteSystems(sysToDel);
-  }, [deleteSystems, systems, ping]);
+  }, []);
+
+  const onCopySystems = useCallback(async () => {
+    const { systems, connections } = refVars.current;
+    if (!systems) {
+      return;
+    }
+
+    const connectionToCopy = connections.filter(
+      c => systems.filter(s => [c.target, c.source].includes(s.id)).length == 2,
+    );
+
+    await navigator.clipboard.writeText(
+      encodeJsonToUriBase64({ systems: systems.map(x => x.data), connections: connectionToCopy }),
+    );
+
+    show({
+      severity: 'success',
+      summary: 'Copied to clipboard',
+      detail: `Successfully copied to clipboard - [${systems.length}] systems and [${connectionToCopy.length}] connections`,
+      life: 3000,
+    });
+  }, [show]);
 
   return {
     handleSystemMultipleContext,
     contextMenuRef,
     onDeleteSystems,
+    onCopySystems,
   };
 };

assets/js/hooks/Mapper/components/contexts/types.ts

@@ -8,6 +8,4 @@ export type WaypointSetContextHandlerProps = {
   destination: string;
 };
 export type WaypointSetContextHandler = (props: WaypointSetContextHandlerProps) => void;
-export type NodeSelectionMouseHandler =
-  | ((event: React.MouseEvent<Element, MouseEvent>, nodes: Node[]) => void)
-  | undefined;
+export type NodeSelectionMouseHandler = (event: React.MouseEvent<Element, MouseEvent>, nodes: Node[]) => void;

assets/js/hooks/Mapper/components/map/Map.tsx

@@ -120,7 +120,7 @@ const MapComp = ({
   useMapHandlers(refn, onSelectionChange);
   useUpdateNodes(nodes);
 
-  const { handleRootContext, ...rootCtxProps } = useContextMenuRootHandlers({ onAddSystem });
+  const { handleRootContext, ...rootCtxProps } = useContextMenuRootHandlers({ onAddSystem, onCommand });
   const { handleConnectionContext, ...connectionCtxProps } = useContextMenuConnectionHandlers();
   const { update } = useMapState();
   const { variant, gap, size, color } = useBackgroundVars(theme);

assets/js/hooks/Mapper/components/map/components/ContextMenuRoot/ContextMenuRoot.tsx

@@ -2,13 +2,21 @@ import React, { RefObject, useMemo } from 'react';
 import { ContextMenu } from 'primereact/contextmenu';
 import { PrimeIcons } from 'primereact/api';
 import { MenuItem } from 'primereact/menuitem';
+import { PasteSystemsAndConnections } from '@/hooks/Mapper/components/map/components';
 
 export interface ContextMenuRootProps {
   contextMenuRef: RefObject<ContextMenu>;
+  pasteSystemsAndConnections: PasteSystemsAndConnections | undefined;
   onAddSystem(): void;
+  onPasteSystemsAnsConnections(): void;
 }
 
-export const ContextMenuRoot: React.FC<ContextMenuRootProps> = ({ contextMenuRef, onAddSystem }) => {
+export const ContextMenuRoot: React.FC<ContextMenuRootProps> = ({
+  contextMenuRef,
+  onAddSystem,
+  onPasteSystemsAnsConnections,
+  pasteSystemsAndConnections,
+}) => {
   const items: MenuItem[] = useMemo(() => {
     return [
       {
@@ -16,8 +24,17 @@ export const ContextMenuRoot: React.FC<ContextMenuRootProps> = ({ contextMenuRef
         icon: PrimeIcons.PLUS,
         command: onAddSystem,
       },
+      ...(pasteSystemsAndConnections != null
+        ? [
+            {
+              label: 'Paste',
+              icon: 'pi pi-clipboard',
+              command: onPasteSystemsAnsConnections,
+            },
+          ]
+        : []),
     ];
-  }, [onAddSystem]);
+  }, [onAddSystem, onPasteSystemsAnsConnections, pasteSystemsAndConnections]);
 
   return (
     <>

assets/js/hooks/Mapper/components/map/components/ContextMenuRoot/useContextMenuRootHandlers.ts

@@ -1,36 +1,76 @@
-import { useReactFlow, XYPosition } from 'reactflow';
-import React, { useCallback, useRef, useState } from 'react';
-import { ContextMenu } from 'primereact/contextmenu';
-import { ctxManager } from '@/hooks/Mapper/utils/contextManager.ts';
 import { OnMapAddSystemCallback } from '@/hooks/Mapper/components/map/map.types.ts';
+import { recenterSystemsByBounds } from '@/hooks/Mapper/helpers/recenterSystems.ts';
+import { OutCommand, OutCommandHandler, SolarSystemConnection, SolarSystemRawType } from '@/hooks/Mapper/types';
+import { decodeUriBase64ToJson } from '@/hooks/Mapper/utils';
+import { ctxManager } from '@/hooks/Mapper/utils/contextManager.ts';
+import { ContextMenu } from 'primereact/contextmenu';
+import React, { useCallback, useRef, useState } from 'react';
+import { useReactFlow, XYPosition } from 'reactflow';
+
+export type PasteSystemsAndConnections = {
+  systems: SolarSystemRawType[];
+  connections: SolarSystemConnection[];
+};
 
 type UseContextMenuRootHandlers = {
   onAddSystem?: OnMapAddSystemCallback;
+  onCommand?: OutCommandHandler;
 };
 
-export const useContextMenuRootHandlers = ({ onAddSystem }: UseContextMenuRootHandlers = {}) => {
+export const useContextMenuRootHandlers = ({ onAddSystem, onCommand }: UseContextMenuRootHandlers = {}) => {
   const rf = useReactFlow();
   const contextMenuRef = useRef<ContextMenu | null>(null);
   const [position, setPosition] = useState<XYPosition | null>(null);
+  const [pasteSystemsAndConnections, setPasteSystemsAndConnections] = useState<PasteSystemsAndConnections>();
 
-  const handleRootContext = (e: React.MouseEvent<HTMLDivElement>) => {
+  const handleRootContext = async (e: React.MouseEvent<HTMLDivElement>) => {
     setPosition(rf.project({ x: e.clientX, y: e.clientY }));
     e.preventDefault();
     ctxManager.next('ctxRoot', contextMenuRef.current);
     contextMenuRef.current?.show(e);
+
+    try {
+      const text = await navigator.clipboard.readText();
+      const result = decodeUriBase64ToJson(text);
+      setPasteSystemsAndConnections(result as PasteSystemsAndConnections);
+    } catch (err) {
+      setPasteSystemsAndConnections(undefined);
+      // do nothing
+    }
   };
 
-  const ref = useRef({ onAddSystem, position });
-  ref.current = { onAddSystem, position };
+  const ref = useRef({ onAddSystem, position, pasteSystemsAndConnections, onCommand });
+  ref.current = { onAddSystem, position, pasteSystemsAndConnections, onCommand };
 
   const onAddSystemCallback = useCallback(() => {
     ref.current.onAddSystem?.({ coordinates: position });
   }, [position]);
 
+  const onPasteSystemsAnsConnections = useCallback(async () => {
+    const { pasteSystemsAndConnections, onCommand, position } = ref.current;
+    if (!position || !onCommand || !pasteSystemsAndConnections) {
+      return;
+    }
+
+    const { systems } = recenterSystemsByBounds(pasteSystemsAndConnections.systems);
+
+    await onCommand({
+      type: OutCommand.manualPasteSystemsAndConnections,
+      data: {
+        systems: systems.map(({ position: srcPos, ...rest }) => ({
+          position: { x: Math.round(srcPos.x + position.x), y: Math.round(srcPos.y + position.y) },
+          ...rest,
+        })),
+        connections: pasteSystemsAndConnections.connections,
+      },
+    });
+  }, []);
+
   return {
     handleRootContext,
-
+    pasteSystemsAndConnections,
     contextMenuRef,
     onAddSystem: onAddSystemCallback,
+    onPasteSystemsAnsConnections,
   };
 };

assets/js/hooks/Mapper/components/map/components/UnsplashedSignature/UnsplashedSignature.tsx

@@ -1,15 +1,16 @@
-import { WdTooltipWrapper } from '@/hooks/Mapper/components/ui-kit/WdTooltipWrapper';
 import { InfoDrawer } from '@/hooks/Mapper/components/ui-kit';
+import { WdTooltipWrapper } from '@/hooks/Mapper/components/ui-kit/WdTooltipWrapper';
 
-import classes from './UnsplashedSignature.module.scss';
-import { SystemSignature } from '@/hooks/Mapper/types/signatures';
-import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 import { WORMHOLE_CLASS_STYLES, WORMHOLES_ADDITIONAL_INFO } from '@/hooks/Mapper/components/map/constants.ts';
-import { useMemo } from 'react';
-import clsx from 'clsx';
 import { renderInfoColumn } from '@/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/renders';
 import { K162_TYPES_MAP } from '@/hooks/Mapper/constants.ts';
 import { parseSignatureCustomInfo } from '@/hooks/Mapper/helpers/parseSignatureCustomInfo.ts';
+import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
+import { TimeStatus } from '@/hooks/Mapper/types';
+import { SystemSignature } from '@/hooks/Mapper/types/signatures';
+import clsx from 'clsx';
+import { useMemo } from 'react';
+import classes from './UnsplashedSignature.module.scss';
 
 interface UnsplashedSignatureProps {
   signature: SystemSignature;
@@ -35,7 +36,7 @@ export const UnsplashedSignature = ({ signature }: UnsplashedSignatureProps) =>
   }, [customInfo]);
 
   const isEOL = useMemo(() => {
-    return customInfo?.isEOL;
+    return customInfo?.time_status === TimeStatus._1h;
   }, [customInfo]);
 
   const whClassStyle = useMemo(() => {

assets/js/hooks/Mapper/components/map/hooks/useMapHandlers.ts

@@ -49,91 +49,87 @@ export const useMapHandlers = (ref: ForwardedRef<MapHandlers>, onSelectionChange
   const { charactersUpdated, presentCharacters, characterAdded, characterRemoved, characterUpdated } =
     useCommandsCharacters();
 
-  useImperativeHandle(
-    ref,
-    () => {
-      return {
-        command(type, data) {
-          switch (type) {
-            case Commands.init:
-              mapInit(data as CommandInit);
-              break;
-            case Commands.addSystems:
-              setTimeout(() => mapAddSystems(data as CommandAddSystems), 100);
-              break;
-            case Commands.updateSystems:
-              mapUpdateSystems(data as CommandUpdateSystems);
-              break;
-            case Commands.removeSystems:
-              setTimeout(() => removeSystems(data as CommandRemoveSystems), 100);
-              break;
-            case Commands.addConnections:
-              setTimeout(() => addConnections(data as CommandAddConnections), 100);
-              break;
-            case Commands.removeConnections:
-              setTimeout(() => removeConnections(data as CommandRemoveConnections), 100);
-              break;
-            case Commands.charactersUpdated:
-              charactersUpdated(data as CommandCharactersUpdated);
-              break;
-            case Commands.characterAdded:
-              characterAdded(data as CommandCharacterAdded);
-              break;
-            case Commands.characterRemoved:
-              characterRemoved(data as CommandCharacterRemoved);
-              break;
-            case Commands.characterUpdated:
-              characterUpdated(data as CommandCharacterUpdated);
-              break;
-            case Commands.presentCharacters:
-              presentCharacters(data as CommandPresentCharacters);
-              break;
-            case Commands.updateConnection:
-              updateConnection(data as CommandUpdateConnection);
-              break;
-            case Commands.mapUpdated:
-              mapUpdated(data as CommandMapUpdated);
-              break;
-            case Commands.killsUpdated:
-              killsUpdated(data as CommandKillsUpdated);
-              break;
+  useImperativeHandle(ref, () => {
+    return {
+      command(type, data) {
+        switch (type) {
+          case Commands.init:
+            mapInit(data as CommandInit);
+            break;
+          case Commands.addSystems:
+            setTimeout(() => mapAddSystems(data as CommandAddSystems), 100);
+            break;
+          case Commands.updateSystems:
+            mapUpdateSystems(data as CommandUpdateSystems);
+            break;
+          case Commands.removeSystems:
+            setTimeout(() => removeSystems(data as CommandRemoveSystems), 100);
+            break;
+          case Commands.addConnections:
+            setTimeout(() => addConnections(data as CommandAddConnections), 100);
+            break;
+          case Commands.removeConnections:
+            setTimeout(() => removeConnections(data as CommandRemoveConnections), 100);
+            break;
+          case Commands.charactersUpdated:
+            charactersUpdated(data as CommandCharactersUpdated);
+            break;
+          case Commands.characterAdded:
+            characterAdded(data as CommandCharacterAdded);
+            break;
+          case Commands.characterRemoved:
+            characterRemoved(data as CommandCharacterRemoved);
+            break;
+          case Commands.characterUpdated:
+            characterUpdated(data as CommandCharacterUpdated);
+            break;
+          case Commands.presentCharacters:
+            presentCharacters(data as CommandPresentCharacters);
+            break;
+          case Commands.updateConnection:
+            updateConnection(data as CommandUpdateConnection);
+            break;
+          case Commands.mapUpdated:
+            mapUpdated(data as CommandMapUpdated);
+            break;
+          case Commands.killsUpdated:
+            killsUpdated(data as CommandKillsUpdated);
+            break;
 
-            case Commands.centerSystem:
-              setTimeout(() => {
-                const systemId = `${data}`;
-                centerSystem(systemId as CommandSelectSystem);
-              }, 100);
-              break;
+          case Commands.centerSystem:
+            setTimeout(() => {
+              const systemId = `${data}`;
+              centerSystem(systemId as CommandSelectSystem);
+            }, 100);
+            break;
 
-            case Commands.selectSystem:
-              selectSystems({ systems: [data as string], delay: 500 });
-              break;
+          case Commands.selectSystem:
+            selectSystems({ systems: [data as string], delay: 500 });
+            break;
 
-            case Commands.selectSystems:
-              selectSystems(data as CommandSelectSystems);
-              break;
+          case Commands.selectSystems:
+            selectSystems(data as CommandSelectSystems);
+            break;
 
-            case Commands.pingAdded:
-            case Commands.pingCancelled:
-            case Commands.routes:
-            case Commands.signaturesUpdated:
-            case Commands.linkSignatureToSystem:
-            case Commands.detailedKillsUpdated:
-            case Commands.characterActivityData:
-            case Commands.trackingCharactersData:
-            case Commands.updateActivity:
-            case Commands.updateTracking:
-            case Commands.userSettingsUpdated:
-              // do nothing
-              break;
+          case Commands.pingAdded:
+          case Commands.pingCancelled:
+          case Commands.routes:
+          case Commands.signaturesUpdated:
+          case Commands.linkSignatureToSystem:
+          case Commands.detailedKillsUpdated:
+          case Commands.characterActivityData:
+          case Commands.trackingCharactersData:
+          case Commands.updateActivity:
+          case Commands.updateTracking:
+          case Commands.userSettingsUpdated:
+            // do nothing
+            break;
 
-            default:
-              console.warn(`Map handlers: Unknown command: ${type}`, data);
-              break;
-          }
-        },
-      };
-    },
-    [],
-  );
+          default:
+            console.warn(`Map handlers: Unknown command: ${type}`, data);
+            break;
+        }
+      },
+    };
+  }, []);
 };

assets/js/hooks/Mapper/components/mapInterface/components/SystemLinkSignatureDialog/SystemLinkSignatureDialog.tsx

@@ -9,11 +9,12 @@ import {
 } from '@/hooks/Mapper/components/map/constants.ts';
 import { SystemSignaturesContent } from '@/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/SystemSignaturesContent';
 import { K162_TYPES_MAP } from '@/hooks/Mapper/constants.ts';
+import { SETTINGS_KEYS, SignatureSettingsType } from '@/hooks/Mapper/constants/signatures';
 import { parseSignatureCustomInfo } from '@/hooks/Mapper/helpers/parseSignatureCustomInfo';
 import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 import { CommandLinkSignatureToSystem, SignatureGroup, SystemSignature } from '@/hooks/Mapper/types';
 import { OutCommand } from '@/hooks/Mapper/types/mapHandlers.ts';
-import { SETTINGS_KEYS, SignatureSettingsType } from '@/hooks/Mapper/constants/signatures';
+import { useSystemSignaturesData } from '../../widgets/SystemSignatures/hooks/useSystemSignaturesData';
 
 const K162_SIGNATURE_TYPE = WORMHOLES_ADDITIONAL_INFO_BY_SHORT_NAME['K162'].shortName;
 
@@ -135,6 +136,11 @@ export const SystemLinkSignatureDialog = ({ data, setVisible }: SystemLinkSignat
     [data, setVisible],
   );
 
+  const { signatures } = useSystemSignaturesData({
+    systemId: `${data.solar_system_source}`,
+    settings: LINK_SIGNTATURE_SETTINGS,
+  });
+
   useEffect(() => {
     if (!targetSystemDynamicInfo) {
       handleHide();
@@ -152,10 +158,12 @@ export const SystemLinkSignatureDialog = ({ data, setVisible }: SystemLinkSignat
     >
       <SystemSignaturesContent
         systemId={`${data.solar_system_source}`}
-        hideLinkedSignatures
+        signatures={signatures}
+        hasUnsupportedLanguage={false}
         settings={LINK_SIGNTATURE_SETTINGS}
+        hideLinkedSignatures
+        selectable
         onSelect={handleSelect}
-        selectable={true}
         filterSignature={filterSignature}
       />
     </Dialog>

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/SystemSignatures.tsx

@@ -1,123 +1,16 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Widget } from '@/hooks/Mapper/components/mapInterface/components';
+import { SETTINGS_KEYS, SIGNATURE_WINDOW_ID, SignatureSettingsType } from '@/hooks/Mapper/constants/signatures';
+import { useHotkey } from '@/hooks/Mapper/hooks/useHotkey';
+import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
+import { useCallback, useMemo, useState } from 'react';
+import { useSignatureUndo } from './hooks/useSignatureUndo';
+import { useSystemSignaturesData } from './hooks/useSystemSignaturesData';
+import { SystemSignaturesHeader } from './SystemSignatureHeader';
 import { SystemSignaturesContent } from './SystemSignaturesContent';
 import { SystemSignatureSettingsDialog } from './SystemSignatureSettingsDialog';
-import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
-import { SystemSignaturesHeader } from './SystemSignatureHeader';
-import { useHotkey } from '@/hooks/Mapper/hooks/useHotkey';
-import { getDeletionTimeoutMs } from '@/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/constants.ts';
-import { OutCommand, OutCommandHandler } from '@/hooks/Mapper/types/mapHandlers';
-import { ExtendedSystemSignature } from '@/hooks/Mapper/types';
-import { SETTINGS_KEYS, SIGNATURE_WINDOW_ID, SignatureSettingsType } from '@/hooks/Mapper/constants/signatures';
-
-/**
- * Custom hook for managing pending signature deletions and undo countdown.
- */
-function useSignatureUndo(
-  systemId: string | undefined,
-  settings: SignatureSettingsType,
-  outCommand: OutCommandHandler,
-) {
-  const [countdown, setCountdown] = useState<number>(0);
-  const [pendingIds, setPendingIds] = useState<Set<string>>(new Set());
-  const [deletedSignatures, setDeletedSignatures] = useState<ExtendedSystemSignature[]>([]);
-  const intervalRef = useRef<number | null>(null);
-
-  const addDeleted = useCallback((signatures: ExtendedSystemSignature[]) => {
-    const newIds = signatures.map(sig => sig.eve_id);
-    setPendingIds(prev => {
-      const next = new Set(prev);
-      newIds.forEach(id => next.add(id));
-      return next;
-    });
-    setDeletedSignatures(prev => [...prev, ...signatures]);
-  }, []);
-
-  // Clear deleted signatures when system changes
-  useEffect(() => {
-    if (systemId) {
-      setDeletedSignatures([]);
-      setPendingIds(new Set());
-      setCountdown(0);
-      if (intervalRef.current != null) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-    }
-  }, [systemId]);
-
-  // kick off or clear countdown whenever pendingIds changes
-  useEffect(() => {
-    // clear any existing timer
-    if (intervalRef.current != null) {
-      clearInterval(intervalRef.current);
-      intervalRef.current = null;
-    }
-
-    if (pendingIds.size === 0) {
-      setCountdown(0);
-      setDeletedSignatures([]);
-      return;
-    }
-
-    // determine timeout from settings
-    const timeoutMs = getDeletionTimeoutMs(settings);
-    
-    // Ensure a minimum of 1 second for immediate deletion so the UI shows
-    const effectiveTimeoutMs = timeoutMs === 0 ? 1000 : timeoutMs;
-
-    setCountdown(Math.ceil(effectiveTimeoutMs / 1000));
-
-    // start new interval
-    intervalRef.current = window.setInterval(() => {
-      setCountdown(prev => {
-        if (prev <= 1) {
-          clearInterval(intervalRef.current!);
-          intervalRef.current = null;
-          setPendingIds(new Set());
-          setDeletedSignatures([]);
-          return 0;
-        }
-        return prev - 1;
-      });
-    }, 1000);
-
-    return () => {
-      if (intervalRef.current != null) {
-        clearInterval(intervalRef.current);
-        intervalRef.current = null;
-      }
-    };
-  }, [pendingIds, settings]);
-
-  // undo handler
-  const handleUndo = useCallback(async () => {
-    if (!systemId || pendingIds.size === 0) return;
-    await outCommand({
-      type: OutCommand.undoDeleteSignatures,
-      data: { system_id: systemId, eve_ids: Array.from(pendingIds) },
-    });
-    setPendingIds(new Set());
-    setDeletedSignatures([]);
-    setCountdown(0);
-    if (intervalRef.current != null) {
-      clearInterval(intervalRef.current);
-      intervalRef.current = null;
-    }
-  }, [systemId, pendingIds, outCommand]);
-
-  return {
-    pendingIds,
-    countdown,
-    deletedSignatures,
-    addDeleted,
-    handleUndo,
-  };
-}
 
 export const SystemSignatures = () => {
-  const [visible, setVisible] = useState(false);
-  const [sigCount, setSigCount] = useState(0);
+  const [showSettings, setShowSettings] = useState(false);
 
   const {
     data: { selectedSystems },
@@ -127,31 +20,6 @@ export const SystemSignatures = () => {
 
   const [systemId] = selectedSystems;
   const isSystemSelected = useMemo(() => selectedSystems.length === 1, [selectedSystems.length]);
-  const { pendingIds, countdown, deletedSignatures, addDeleted, handleUndo } = useSignatureUndo(
-    systemId,
-    settingsSignatures,
-    outCommand,
-  );
-
-  useHotkey(true, ['z', 'Z'], (event: KeyboardEvent) => {
-    if (pendingIds.size > 0 && countdown > 0) {
-      event.preventDefault();
-      event.stopPropagation();
-      handleUndo();
-    }
-  });
-
-  const handleCountChange = useCallback((count: number) => {
-    setSigCount(count);
-  }, []);
-
-  const handleSettingsSave = useCallback(
-    (newSettings: SignatureSettingsType) => {
-      settingsSignaturesUpdate(newSettings);
-      setVisible(false);
-    },
-    [settingsSignaturesUpdate],
-  );
 
   const handleLazyDeleteToggle = useCallback(
     (value: boolean) => {
@@ -163,7 +31,42 @@ export const SystemSignatures = () => {
     [settingsSignaturesUpdate],
   );
 
-  const openSettings = useCallback(() => setVisible(true), []);
+  const {
+    signatures,
+    selectedSignatures,
+    setSelectedSignatures,
+    handleDeleteSelected,
+    handleSelectAll,
+    handlePaste,
+    hasUnsupportedLanguage,
+  } = useSystemSignaturesData({
+    systemId,
+    settings: settingsSignatures,
+    onLazyDeleteChange: handleLazyDeleteToggle,
+  });
+
+  const sigCount = useMemo(() => signatures.length, [signatures]);
+  const deletedSignatures = useMemo(() => signatures.filter(s => s.deleted), [signatures]);
+
+  const { countdown, handleUndo } = useSignatureUndo(systemId, settingsSignatures, deletedSignatures, outCommand);
+
+  useHotkey(true, ['z', 'Z'], (event: KeyboardEvent) => {
+    if (deletedSignatures.length > 0 && countdown > 0) {
+      event.preventDefault();
+      event.stopPropagation();
+      handleUndo();
+    }
+  });
+
+  const handleSettingsSave = useCallback(
+    (newSettings: SignatureSettingsType) => {
+      settingsSignaturesUpdate(newSettings);
+      setShowSettings(false);
+    },
+    [settingsSignaturesUpdate],
+  );
+
+  const openSettings = useCallback(() => setShowSettings(true), []);
 
   return (
     <Widget
@@ -171,7 +74,7 @@ export const SystemSignatures = () => {
         <SystemSignaturesHeader
           sigCount={sigCount}
           lazyDeleteValue={settingsSignatures[SETTINGS_KEYS.LAZY_DELETE_SIGNATURES] as boolean}
-          pendingCount={pendingIds.size}
+          pendingCount={deletedSignatures.length}
           undoCountdown={countdown}
           onLazyDeleteChange={handleLazyDeleteToggle}
           onUndoClick={handleUndo}
@@ -187,18 +90,21 @@ export const SystemSignatures = () => {
       ) : (
         <SystemSignaturesContent
           systemId={systemId}
+          signatures={signatures}
+          selectedSignatures={selectedSignatures}
+          onSelectSignatures={setSelectedSignatures}
+          onDeleteSelected={handleDeleteSelected}
+          onSelectAll={handleSelectAll}
+          onPaste={handlePaste}
+          hasUnsupportedLanguage={hasUnsupportedLanguage}
           settings={settingsSignatures}
-          deletedSignatures={deletedSignatures}
-          onLazyDeleteChange={handleLazyDeleteToggle}
-          onCountChange={handleCountChange}
-          onSignatureDeleted={addDeleted}
         />
       )}
 
-      {visible && (
+      {showSettings && (
         <SystemSignatureSettingsDialog
           settings={settingsSignatures}
-          onCancel={() => setVisible(false)}
+          onCancel={() => setShowSettings(false)}
           onSave={handleSettingsSave}
         />
       )}

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/SystemSignaturesContent/SystemSignaturesContent.tsx

@@ -33,34 +33,39 @@ import { useClipboard, useHotkey } from '@/hooks/Mapper/hooks';
 import useMaxWidth from '@/hooks/Mapper/hooks/useMaxWidth';
 import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 import { getSignatureRowClass } from '../helpers/rowStyles';
-import { useSystemSignaturesData } from '../hooks/useSystemSignaturesData';
 
 const renderColIcon = (sig: SystemSignature) => renderIcon(sig);
 
 interface SystemSignaturesContentProps {
   systemId: string;
+  signatures: ExtendedSystemSignature[];
+  selectedSignatures?: ExtendedSystemSignature[];
+  onSelectSignatures?: (s: ExtendedSystemSignature[]) => void;
+  onDeleteSelected?: () => Promise<void>;
+  onSelectAll?: () => void;
+  onPaste?: (clipboardString: string) => void;
   settings: SignatureSettingsType;
   hideLinkedSignatures?: boolean;
+  hasUnsupportedLanguage?: boolean;
   selectable?: boolean;
   onSelect?: (signature: SystemSignature) => void;
-  onLazyDeleteChange?: (value: boolean) => void;
-  onCountChange?: (count: number) => void;
   filterSignature?: (signature: SystemSignature) => boolean;
-  onSignatureDeleted?: (deletedSignatures: ExtendedSystemSignature[]) => void;
-  deletedSignatures?: ExtendedSystemSignature[];
 }
 
 export const SystemSignaturesContent = ({
   systemId,
+  signatures,
+  selectedSignatures,
+  onSelectSignatures,
+  onDeleteSelected,
+  onSelectAll,
+  onPaste,
   settings,
   hideLinkedSignatures,
+  hasUnsupportedLanguage,
   selectable,
   onSelect,
-  onLazyDeleteChange,
-  onCountChange,
   filterSignature,
-  onSignatureDeleted,
-  deletedSignatures = [],
 }: SystemSignaturesContentProps) => {
   const [selectedSignatureForDialog, setSelectedSignatureForDialog] = useState<SystemSignature | null>(null);
   const [showSignatureSettings, setShowSignatureSettings] = useState(false);
@@ -79,32 +84,18 @@ export const SystemSignaturesContent = ({
 
   const { clipboardContent, setClipboardContent } = useClipboard();
 
-  const {
-    signatures,
-    selectedSignatures,
-    setSelectedSignatures,
-    handleDeleteSelected,
-    handleSelectAll,
-    handlePaste,
-    hasUnsupportedLanguage,
-  } = useSystemSignaturesData({
-    systemId,
-    settings,
-    onCountChange,
-    onLazyDeleteChange,
-    onSignatureDeleted,
-  });
+  const deletedSignatures = useMemo(() => signatures.filter(s => s.deleted), [signatures]);
 
   useEffect(() => {
     if (selectable) return;
     if (!clipboardContent?.text) return;
 
-    handlePaste(clipboardContent.text);
+    onPaste?.(clipboardContent.text);
 
     setClipboardContent(null);
-  }, [selectable, clipboardContent, handlePaste, setClipboardContent]);
+  }, [selectable, clipboardContent, onPaste, setClipboardContent]);
 
-  useHotkey(true, ['a'], handleSelectAll);
+  useHotkey(true, ['a'], () => onSelectAll?.());
 
   useHotkey(false, ['Backspace', 'Delete'], (event: KeyboardEvent) => {
     const targetWindow = (event.target as HTMLHtmlElement)?.closest(`[data-window-id="${SIGNATURE_WINDOW_ID}"]`);
@@ -117,7 +108,7 @@ export const SystemSignaturesContent = ({
     event.stopPropagation();
 
     // Delete key should always immediately delete, never show pending deletions
-    handleDeleteSelected();
+    onDeleteSelected?.();
   });
 
   const handleResize = useCallback(() => {
@@ -152,9 +143,9 @@ export const SystemSignaturesContent = ({
 
       selectable
         ? onSelect?.(selectableSignatures[0])
-        : setSelectedSignatures(selectableSignatures as ExtendedSystemSignature[]);
+        : onSelectSignatures?.(selectableSignatures as ExtendedSystemSignature[]);
     },
-    [onSelect, selectable, setSelectedSignatures, deletedSignatures],
+    [onSelect, selectable, onSelectSignatures, deletedSignatures],
   );
 
   const {
@@ -177,9 +168,6 @@ export const SystemSignaturesContent = ({
   );
 
   const filteredSignatures = useMemo<ExtendedSystemSignature[]>(() => {
-    // Get the set of deleted signature IDs for quick lookup
-    const deletedIds = new Set(deletedSignatures.map(sig => sig.eve_id));
-
     // Common filter function
     const shouldShowSignature = (sig: ExtendedSystemSignature): boolean => {
       if (filterSignature && !filterSignature(sig)) {
@@ -213,24 +201,8 @@ export const SystemSignaturesContent = ({
       return settings[sig.kind] as boolean;
     };
 
-    // Filter active signatures, excluding any that are in the deleted list
-    const activeSignatures = signatures.filter(sig => {
-      // Skip if this signature is in the deleted list
-      if (deletedIds.has(sig.eve_id)) {
-        return false;
-      }
-
-      return shouldShowSignature(sig);
-    });
-
-    // Add deleted signatures with pending deletion flag, applying the same filters
-    const deletedWithPendingFlag = deletedSignatures.filter(shouldShowSignature).map(sig => ({
-      ...sig,
-      pendingDeletion: true,
-    }));
-
-    return [...activeSignatures, ...deletedWithPendingFlag];
-  }, [signatures, hideLinkedSignatures, settings, filterSignature, deletedSignatures]);
+    return signatures.filter(sig => shouldShowSignature(sig));
+  }, [signatures, hideLinkedSignatures, settings, filterSignature]);
 
   const onRowMouseEnter = useCallback((e: DataTableRowMouseEvent) => {
     setHoveredSignature(e.data as SystemSignature);
@@ -253,20 +225,18 @@ export const SystemSignaturesContent = ({
 
     return getSignatureRowClass(
       rowData as ExtendedSystemSignature,
-      refVars.current.selectedSignatures,
+      refVars.current.selectedSignatures || [],
       refVars.current.settings[SETTINGS_KEYS.COLOR_BY_TYPE] as boolean,
     );
   }, []);
 
-  const handleSortSettings = useCallback(
-    (e: DataTableStateEvent) =>
-      refVars.current.settingsSignaturesUpdate({
-        ...refVars.current.settingsSignatures,
-        [SETTINGS_KEYS.SORT_FIELD]: e.sortField,
-        [SETTINGS_KEYS.SORT_ORDER]: e.sortOrder,
-      }),
-    [],
-  );
+  const handleSortSettings = useCallback((e: DataTableStateEvent) => {
+    refVars.current.settingsSignaturesUpdate({
+      ...refVars.current.settingsSignatures,
+      [SETTINGS_KEYS.SORT_FIELD]: e.sortField,
+      [SETTINGS_KEYS.SORT_ORDER]: e.sortOrder,
+    });
+  }, []);
 
   return (
     <div ref={tableRef} className="h-full">
@@ -287,7 +257,7 @@ export const SystemSignaturesContent = ({
             value={filteredSignatures}
             size="small"
             selectionMode="multiple"
-            selection={selectedSignatures}
+            selection={selectedSignatures || []}
             metaKeySelection
             onSelectionChange={handleSelectSignatures}
             dataKey="eve_id"
@@ -336,6 +306,8 @@ export const SystemSignaturesContent = ({
               style={{ maxWidth: nameColumnWidth }}
               hidden={isCompact || isMedium}
               body={renderInfoColumn}
+              sortable
+              sortField="name"
             />
             {showDescriptionColumn && (
               <Column

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/helpers/rowStyles.ts

@@ -1,5 +1,5 @@
-import clsx from 'clsx';
 import { ExtendedSystemSignature, SignatureGroup } from '@/hooks/Mapper/types';
+import clsx from 'clsx';
 import { getRowBackgroundColor } from './getRowBackgroundColor';
 import classes from './rowStyles.module.scss';
 
@@ -20,7 +20,7 @@ export function getSignatureRowClass(
     return clsx([...baseCls, 'bg-violet-400/40 hover:bg-violet-300/40']);
   }
 
-  if (row.pendingDeletion) {
+  if (row.deleted) {
     return clsx([...baseCls, 'bg-red-400/40 hover:bg-red-400/50']);
   }
 

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/types.ts

@@ -1,24 +1,20 @@
-import { ExtendedSystemSignature } from '@/hooks/Mapper/types';
 import { SignatureSettingsType } from '@/hooks/Mapper/constants/signatures.ts';
+import { ExtendedSystemSignature } from '@/hooks/Mapper/types';
 
 export interface UseSystemSignaturesDataProps {
   systemId: string;
   settings: SignatureSettingsType;
   hideLinkedSignatures?: boolean;
   onCountChange?: (count: number) => void;
-  onPendingChange?: (
-    pending: React.MutableRefObject<Record<string, ExtendedSystemSignature>>,
-    undo: () => void,
-  ) => void;
   onLazyDeleteChange?: (value: boolean) => void;
   deletionTiming?: number;
 }
 
 export interface UseFetchingParams {
   systemId: string;
+  settings: SignatureSettingsType;
   signaturesRef: React.MutableRefObject<ExtendedSystemSignature[]>;
   setSignatures: React.Dispatch<React.SetStateAction<ExtendedSystemSignature[]>>;
-  pendingDeletionMapRef: React.MutableRefObject<Record<string, ExtendedSystemSignature>>;
 }
 
 export interface UsePendingDeletionParams {

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/usePendingDeletions.ts

@@ -1,42 +0,0 @@
-import { useCallback, useRef } from 'react';
-import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
-import { prepareUpdatePayload } from '../helpers';
-import { UsePendingDeletionParams } from './types';
-import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
-import { ExtendedSystemSignature } from '@/hooks/Mapper/types';
-
-export function usePendingDeletions({
-  systemId,
-  setSignatures,
-  onPendingChange,
-}: Omit<UsePendingDeletionParams, 'deletionTiming'>) {
-  const { outCommand } = useMapRootState();
-  const pendingDeletionMapRef = useRef<Record<string, ExtendedSystemSignature>>({});
-
-  const processRemovedSignatures = useCallback(
-    async (
-      removed: ExtendedSystemSignature[],
-      added: ExtendedSystemSignature[],
-      updated: ExtendedSystemSignature[],
-    ) => {
-      if (!removed.length) return;
-      await outCommand({
-        type: OutCommand.updateSignatures,
-        data: prepareUpdatePayload(systemId, added, updated, removed),
-      });
-    },
-    [systemId, outCommand],
-  );
-
-  const clearPendingDeletions = useCallback(() => {
-    pendingDeletionMapRef.current = {};
-    setSignatures(prev => prev.map(x => (x.pendingDeletion ? { ...x, pendingDeletion: false } : x)));
-    onPendingChange?.(pendingDeletionMapRef, clearPendingDeletions);
-  }, []);
-
-  return {
-    pendingDeletionMapRef,
-    processRemovedSignatures,
-    clearPendingDeletions,
-  };
-}

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSignatureFetching.ts

@@ -1,21 +1,27 @@
-import { useCallback } from 'react';
+import { SETTINGS_KEYS } from '@/hooks/Mapper/constants/signatures';
+import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 import { ExtendedSystemSignature, SystemSignature } from '@/hooks/Mapper/types';
 import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
-import { prepareUpdatePayload, getActualSigs, mergeLocalPending } from '../helpers';
+import { useCallback, useMemo } from 'react';
+import { getDeletionTimeoutMs } from '../constants';
+import { getActualSigs, prepareUpdatePayload } from '../helpers';
 import { UseFetchingParams } from './types';
-import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 
-export const useSignatureFetching = ({
-  systemId,
-  signaturesRef,
-  setSignatures,
-  pendingDeletionMapRef,
-}: UseFetchingParams) => {
+export const useSignatureFetching = ({ systemId, settings, signaturesRef, setSignatures }: UseFetchingParams) => {
   const {
     data: { characters },
     outCommand,
   } = useMapRootState();
 
+  const deleteTimeout = useMemo(() => {
+    const lazyDelete = settings[SETTINGS_KEYS.LAZY_DELETE_SIGNATURES] as boolean;
+    if (!lazyDelete) {
+      return 0;
+    }
+
+    return getDeletionTimeoutMs(settings);
+  }, [settings]);
+
   const handleGetSignatures = useCallback(async () => {
     if (!systemId) {
       setSignatures([]);
@@ -32,24 +38,23 @@ export const useSignatureFetching = ({
       character_name: characters.find(c => c.eve_id === s.character_eve_id)?.name,
     })) as ExtendedSystemSignature[];
 
-    setSignatures(() => mergeLocalPending(pendingDeletionMapRef, extended));
+    setSignatures(() => extended);
   }, [characters, systemId, outCommand]);
 
   const handleUpdateSignatures = useCallback(
     async (newList: ExtendedSystemSignature[], updateOnly: boolean, skipUpdateUntouched?: boolean) => {
-      const { added, updated, removed } = getActualSigs(
-        signaturesRef.current,
-        newList,
-        updateOnly,
-        skipUpdateUntouched,
-      );
+      const actualSigs = getActualSigs(signaturesRef.current, newList, updateOnly, skipUpdateUntouched);
 
-      await outCommand({
-        type: OutCommand.updateSignatures,
-        data: prepareUpdatePayload(systemId, added, updated, removed),
-      });
+      const { added, updated, removed } = actualSigs;
+
+      if (updated.length !== 0 || added.length !== 0 || removed.length !== 0) {
+        await outCommand({
+          type: OutCommand.updateSignatures,
+          data: { ...prepareUpdatePayload(systemId, added, updated, removed), deleteTimeout },
+        });
+      }
     },
-    [systemId, outCommand, signaturesRef],
+    [systemId, deleteTimeout, outCommand, signaturesRef],
   );
 
   return {

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSignatureUndo.ts

@@ -0,0 +1,89 @@
+import { SignatureSettingsType } from '@/hooks/Mapper/constants/signatures';
+import { ExtendedSystemSignature, OutCommandHandler } from '@/hooks/Mapper/types';
+import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { getDeletionTimeoutMs } from '../constants';
+
+/**
+ * Custom hook for managing pending signature deletions and undo countdown.
+ */
+export function useSignatureUndo(
+  systemId: string | undefined,
+  settings: SignatureSettingsType,
+  deletedSignatures: ExtendedSystemSignature[],
+  outCommand: OutCommandHandler,
+) {
+  const [countdown, setCountdown] = useState<number>(0);
+  const intervalRef = useRef<number | null>(null);
+
+  // Clear deleted signatures when system changes
+  useEffect(() => {
+    if (systemId) {
+      setCountdown(0);
+      if (intervalRef.current != null) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    }
+  }, [systemId]);
+
+  // kick off or clear countdown whenever pendingIds changes
+  useEffect(() => {
+    // clear any existing timer
+    if (intervalRef.current != null) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+
+    if (deletedSignatures.length === 0) {
+      setCountdown(0);
+      return;
+    }
+
+    // determine timeout from settings
+    const timeoutMs = getDeletionTimeoutMs(settings);
+
+    // Ensure a minimum of 1 second for immediate deletion so the UI shows
+    const effectiveTimeoutMs = timeoutMs === 0 ? 1000 : timeoutMs;
+
+    setCountdown(Math.ceil(effectiveTimeoutMs / 1000));
+
+    // start new interval
+    intervalRef.current = window.setInterval(() => {
+      setCountdown(prev => {
+        if (prev <= 1) {
+          clearInterval(intervalRef.current!);
+          intervalRef.current = null;
+          return 0;
+        }
+        return prev - 1;
+      });
+    }, 1000);
+
+    return () => {
+      if (intervalRef.current != null) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [deletedSignatures, settings]);
+
+  // undo handler
+  const handleUndo = useCallback(async () => {
+    if (!systemId || deletedSignatures.length === 0) return;
+    await outCommand({
+      type: OutCommand.undoDeleteSignatures,
+      data: { system_id: systemId, eve_ids: deletedSignatures.map(s => s.eve_id) },
+    });
+    setCountdown(0);
+    if (intervalRef.current != null) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+  }, [systemId, deletedSignatures, outCommand]);
+
+  return {
+    countdown,
+    handleUndo,
+  };
+}

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSystemSignaturesData.ts

@@ -1,44 +1,29 @@
 import { useMapEventListener } from '@/hooks/Mapper/events';
 import { parseSignatures } from '@/hooks/Mapper/helpers';
 import { Commands, ExtendedSystemSignature, SignatureKind } from '@/hooks/Mapper/types';
-import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
 import { useCallback, useEffect, useState } from 'react';
 import useRefState from 'react-usestateref';
 
-import { getDeletionTimeoutMs } from '@/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/constants.ts';
-import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
-import { getActualSigs } from '../helpers';
-import { UseSystemSignaturesDataProps } from './types';
-import { usePendingDeletions } from './usePendingDeletions';
-import { useSignatureFetching } from './useSignatureFetching';
 import { SETTINGS_KEYS } from '@/hooks/Mapper/constants/signatures.ts';
+import { UseSystemSignaturesDataProps } from './types';
+import { useSignatureFetching } from './useSignatureFetching';
 
 export const useSystemSignaturesData = ({
   systemId,
   settings,
-  onCountChange,
-  onPendingChange,
   onLazyDeleteChange,
-  onSignatureDeleted,
 }: Omit<UseSystemSignaturesDataProps, 'deletionTiming'> & {
   onSignatureDeleted?: (deletedSignatures: ExtendedSystemSignature[]) => void;
 }) => {
-  const { outCommand } = useMapRootState();
   const [signatures, setSignatures, signaturesRef] = useRefState<ExtendedSystemSignature[]>([]);
   const [selectedSignatures, setSelectedSignatures] = useState<ExtendedSystemSignature[]>([]);
   const [hasUnsupportedLanguage, setHasUnsupportedLanguage] = useState<boolean>(false);
 
-  const { pendingDeletionMapRef, processRemovedSignatures, clearPendingDeletions } = usePendingDeletions({
-    systemId,
-    setSignatures,
-    onPendingChange,
-  });
-
   const { handleGetSignatures, handleUpdateSignatures } = useSignatureFetching({
     systemId,
+    settings,
     signaturesRef,
     setSignatures,
-    pendingDeletionMapRef,
   });
 
   const handlePaste = useCallback(
@@ -67,40 +52,14 @@ export const useSystemSignaturesData = ({
         setHasUnsupportedLanguage(false);
       }
 
-      const currentNonPending = lazyDeleteValue
-        ? signaturesRef.current.filter(sig => !sig.pendingDeletion)
-        : signaturesRef.current.filter(sig => !sig.pendingDeletion || !sig.pendingAddition);
-
-      const { added, updated, removed } = getActualSigs(currentNonPending, incomingSignatures, !lazyDeleteValue, false);
-
-      if (removed.length > 0) {
-        await processRemovedSignatures(removed, added, updated);
-
-        // Show pending deletions if lazy deletion is enabled
-        // The deletion timing controls how long the countdown lasts, not whether lazy delete is active
-        if (onSignatureDeleted && lazyDeleteValue) {
-          onSignatureDeleted(removed);
-        }
-      }
-
-      if (updated.length !== 0 || added.length !== 0) {
-        await outCommand({
-          type: OutCommand.updateSignatures,
-          data: {
-            system_id: systemId,
-            added,
-            updated,
-            removed: [],
-          },
-        });
-      }
+      await handleUpdateSignatures(incomingSignatures, !lazyDeleteValue, false);
 
       const keepLazy = settings[SETTINGS_KEYS.KEEP_LAZY_DELETE] as boolean;
       if (lazyDeleteValue && !keepLazy) {
         onLazyDeleteChange?.(false);
       }
     },
-    [settings, signaturesRef, processRemovedSignatures, outCommand, systemId, onLazyDeleteChange, onSignatureDeleted],
+    [settings, handleUpdateSignatures, onLazyDeleteChange],
   );
 
   const handleDeleteSelected = useCallback(async () => {
@@ -109,23 +68,15 @@ export const useSystemSignaturesData = ({
     const selectedIds = selectedSignatures.map(s => s.eve_id);
     const finalList = signatures.filter(s => !selectedIds.includes(s.eve_id));
 
-    // IMPORTANT: Send deletion to server BEFORE updating local state
-    // Otherwise signaturesRef.current will be updated and getActualSigs won't detect removals
-    await handleUpdateSignatures(finalList, false, true);
-
-    // Update local state after server call
-    setSignatures(finalList);
     setSelectedSignatures([]);
-  }, [handleUpdateSignatures, selectedSignatures, signatures, setSignatures]);
+
+    await handleUpdateSignatures(finalList, false, true);
+  }, [handleUpdateSignatures, selectedSignatures, signatures]);
 
   const handleSelectAll = useCallback(() => {
     setSelectedSignatures(signatures);
   }, [signatures]);
 
-  const undoPending = useCallback(() => {
-    clearPendingDeletions();
-  }, [clearPendingDeletions]);
-
   useMapEventListener(event => {
     if (event.name === Commands.signaturesUpdated && String(event.data) === String(systemId)) {
       handleGetSignatures();
@@ -136,18 +87,13 @@ export const useSystemSignaturesData = ({
   useEffect(() => {
     if (!systemId) {
       setSignatures([]);
-      undoPending();
       return;
     }
     handleGetSignatures();
   }, [systemId]);
 
-  useEffect(() => {
-    onCountChange?.(signatures.length);
-  }, [signatures]);
-
   return {
-    signatures: signatures.filter(sig => !sig.deleted),
+    signatures,
     selectedSignatures,
     setSelectedSignatures,
     handleDeleteSelected,

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/renders/renderInfoColumn.tsx

@@ -1,14 +1,14 @@
-import { PrimeIcons } from 'primereact/api';
-import { SignatureGroup, SystemSignature } from '@/hooks/Mapper/types';
 import { SystemViewStandalone, TooltipPosition, WHClassView } from '@/hooks/Mapper/components/ui-kit';
+import { SignatureGroup, SystemSignature, TimeStatus } from '@/hooks/Mapper/types';
+import { PrimeIcons } from 'primereact/api';
 
 import { renderK162Type } from '@/hooks/Mapper/components/mapRootContent/components/SignatureSettings/components/SignatureK162TypeSelect';
 import { WdTooltipWrapper } from '@/hooks/Mapper/components/ui-kit/WdTooltipWrapper';
 
-import clsx from 'clsx';
-import { renderName } from './renderName.tsx';
 import { K162_TYPES_MAP } from '@/hooks/Mapper/constants.ts';
 import { parseSignatureCustomInfo } from '@/hooks/Mapper/helpers/parseSignatureCustomInfo.ts';
+import clsx from 'clsx';
+import { renderName } from './renderName.tsx';
 
 export const renderInfoColumn = (row: SystemSignature) => {
   if (!row.group || row.group === SignatureGroup.Wormhole) {
@@ -18,7 +18,9 @@ export const renderInfoColumn = (row: SystemSignature) => {
 
     return (
       <div className="flex justify-start items-center gap-[4px]">
-        {customInfo.isEOL && (
+        {row.temporary_name && <span className={clsx('text-[12px]')}>{row.temporary_name}</span>}
+
+        {customInfo.time_status === TimeStatus._1h && (
           <WdTooltipWrapper offset={5} position={TooltipPosition.top} content="Signature marked as EOL">
             <div className="pi pi-clock text-fuchsia-400 text-[11px] mr-[2px]"></div>
           </WdTooltipWrapper>

assets/js/hooks/Mapper/components/mapRootContent/components/MapSettings/components/ImportExport.tsx

@@ -64,7 +64,7 @@ export const ImportExport = () => {
 
       // INFO: WE NOT SUPPORT MIGRATIONS FOR OLD FILES AND Clipboard
       const parsed = parseMapUserSettings(text);
-      if (applySettings(applyMigrations(parsed))) {
+      if (applySettings(applyMigrations(parsed) || createDefaultStoredSettings())) {
         toast.current?.show({
           severity: 'success',
           summary: 'Import',

assets/js/hooks/Mapper/components/mapRootContent/components/MapSettings/components/ServerSettings.tsx

@@ -35,7 +35,7 @@ export const ServerSettings = () => {
 
     try {
       //INFO: INSTEAD CHECK WE WILL TRY TO APPLY MIGRATION
-      applySettings(applyMigrations(JSON.parse(res.default_settings)));
+      applySettings(applyMigrations(JSON.parse(res.default_settings)) || createDefaultStoredSettings());
       callToastSuccess(toast.current, 'Settings synchronized successfully');
     } catch (error) {
       applySettings(createDefaultStoredSettings());

assets/js/hooks/Mapper/components/mapRootContent/components/SignatureSettings/SignatureSettings.tsx

@@ -1,15 +1,15 @@
-import { Dialog } from 'primereact/dialog';
-import { useCallback, useEffect } from 'react';
-import { OutCommand, SignatureGroup, SystemSignature, TimeStatus } from '@/hooks/Mapper/types';
-import { Controller, FormProvider, useForm } from 'react-hook-form';
 import {
   SignatureGroupContent,
   SignatureGroupSelect,
 } from '@/hooks/Mapper/components/mapRootContent/components/SignatureSettings/components';
-import { InputText } from 'primereact/inputtext';
 import { SystemsSettingsProvider } from '@/hooks/Mapper/components/mapRootContent/components/SignatureSettings/Provider.tsx';
-import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 import { WdButton } from '@/hooks/Mapper/components/ui-kit';
+import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
+import { OutCommand, SignatureGroup, SystemSignature, TimeStatus } from '@/hooks/Mapper/types';
+import { Dialog } from 'primereact/dialog';
+import { InputText } from 'primereact/inputtext';
+import { useCallback, useEffect } from 'react';
+import { Controller, FormProvider, useForm } from 'react-hook-form';
 
 type SystemSignaturePrepared = Omit<SystemSignature, 'linked_system'> & {
   linked_system: string;
@@ -119,6 +119,7 @@ export const SignatureSettings = ({ systemId, show, onHide, signatureData }: Map
           added: [],
           updated: [out],
           removed: [],
+          deleteTimeout: 0,
         },
       });
 

assets/js/hooks/Mapper/components/mapWrapper/MapWrapper.tsx

@@ -1,36 +1,36 @@
-import { Map, MAP_ROOT_ID } from '@/hooks/Mapper/components/map/Map.tsx';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { CommandSelectSystems, OutCommand, OutCommandHandler, SolarSystemConnection } from '@/hooks/Mapper/types';
-import { MapRootData, useMapRootState } from '@/hooks/Mapper/mapRootProvider';
-import { OnMapAddSystemCallback, OnMapSelectionChange } from '@/hooks/Mapper/components/map/map.types.ts';
-import isEqual from 'lodash.isequal';
 import { ContextMenuSystem, useContextMenuSystemHandlers } from '@/hooks/Mapper/components/contexts';
+import { Map, MAP_ROOT_ID } from '@/hooks/Mapper/components/map/Map.tsx';
+import { OnMapAddSystemCallback, OnMapSelectionChange } from '@/hooks/Mapper/components/map/map.types.ts';
 import {
   SystemCustomLabelDialog,
   SystemLinkSignatureDialog,
   SystemSettingsDialog,
 } from '@/hooks/Mapper/components/mapInterface/components';
 import { Connections } from '@/hooks/Mapper/components/mapRootContent/components/Connections';
-import { ContextMenuSystemMultiple, useContextMenuSystemMultipleHandlers } from '../contexts/ContextMenuSystemMultiple';
 import { getSystemById } from '@/hooks/Mapper/helpers';
+import { MapRootData, useMapRootState } from '@/hooks/Mapper/mapRootProvider';
+import { CommandSelectSystems, OutCommand, OutCommandHandler, SolarSystemConnection } from '@/hooks/Mapper/types';
 import { Commands } from '@/hooks/Mapper/types/mapHandlers.ts';
+import isEqual from 'lodash.isequal';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Node, useReactFlow, Viewport, XYPosition } from 'reactflow';
+import { ContextMenuSystemMultiple, useContextMenuSystemMultipleHandlers } from '../contexts/ContextMenuSystemMultiple';
 
-import { useCommandsSystems } from '@/hooks/Mapper/mapRootProvider/hooks/api';
 import { emitMapEvent, useMapEventListener } from '@/hooks/Mapper/events';
+import { useCommandsSystems } from '@/hooks/Mapper/mapRootProvider/hooks/api';
 
 import { useDeleteSystems } from '@/hooks/Mapper/components/contexts/hooks';
-import { useCommonMapEventProcessor } from '@/hooks/Mapper/components/mapWrapper/hooks/useCommonMapEventProcessor.ts';
 import {
   AddSystemDialog,
   SearchOnSubmitCallback,
 } from '@/hooks/Mapper/components/mapInterface/components/AddSystemDialog';
-import { useHotkey } from '../../hooks/useHotkey';
-import { PingType } from '@/hooks/Mapper/types/ping.ts';
 import { SystemPingDialog } from '@/hooks/Mapper/components/mapInterface/components/SystemPingDialog';
-import { MiniMapPlacement } from '@/hooks/Mapper/mapRootProvider/types.ts';
+import { useCommonMapEventProcessor } from '@/hooks/Mapper/components/mapWrapper/hooks/useCommonMapEventProcessor.ts';
 import { MINIMAP_PLACEMENT_MAP } from '@/hooks/Mapper/constants.ts';
+import { MiniMapPlacement } from '@/hooks/Mapper/mapRootProvider/types.ts';
+import { PingType } from '@/hooks/Mapper/types/ping.ts';
 import type { PanelPosition } from '@reactflow/core';
+import { useHotkey } from '../../hooks/useHotkey';
 import { MINI_MAP_PLACEMENT_OFFSETS } from './constants.ts';
 
 // TODO: INFO - this component needs for abstract work with Map instance
@@ -106,7 +106,7 @@ export const MapWrapper = () => {
 
       runCommand({
         name: Commands.selectSystems,
-        data: { systems: selectedSystems } as CommandSelectSystems,
+        data: { systems: selectedSystems, delay: 200 } as CommandSelectSystems,
       });
     }
   });

assets/js/hooks/Mapper/components/ui-kit/WHClassView/WHClassView.tsx

@@ -45,40 +45,42 @@ export const WHClassView = ({
   const whClass = useMemo(() => WORMHOLES_ADDITIONAL_INFO[whData.dest], [whData.dest]);
   const whClassStyle = WORMHOLE_CLASS_STYLES[whClass?.wormholeClassID] ?? '';
 
-  return (
-    <div className={clsx(classes.WHClassViewRoot, className)}>
-      {!hideTooltip && (
-        <WdTooltipWrapper
-          position={TooltipPosition.bottom}
-          content={
-            <div className="flex gap-3">
-              <div className="flex flex-col gap-1">
-                <InfoDrawer title="Total mass">{prepareMass(whData.total_mass)}</InfoDrawer>
-                <InfoDrawer title="Jump mass">{prepareMass(whData.max_mass_per_jump)}</InfoDrawer>
-              </div>
-              <div className="flex flex-col gap-1">
-                <InfoDrawer title="Lifetime">{whData.lifetime}h</InfoDrawer>
-                <InfoDrawer title="Mass regen">{prepareMass(whData.mass_regen)}</InfoDrawer>
-              </div>
-            </div>
-          }
-        >
-          <div
-            className={clsx(
-              classes.WHClassViewContent,
-              { [classes.NoOffset]: noOffset },
-              'wh-name select-none cursor-help',
-            )}
-          >
-            {!hideWhClassName && <span className={clsx({ [whClassStyle]: highlightName })}>{whClassName}</span>}
-            {!hideWhClass && whClass && (
-              <span className={clsx(classes.WHClassName, whClassStyle, classNameWh)}>
-                {useShortTitle ? whClass.shortTitle : whClass.shortName}
-              </span>
-            )}
-          </div>
-        </WdTooltipWrapper>
+  const content = (
+    <div
+      className={clsx(classes.WHClassViewContent, { [classes.NoOffset]: noOffset }, 'wh-name select-none cursor-help')}
+    >
+      {!hideWhClassName && <span className={clsx({ [whClassStyle]: highlightName })}>{whClassName}</span>}
+      {!hideWhClass && whClass && (
+        <span className={clsx(classes.WHClassName, whClassStyle, classNameWh)}>
+          {useShortTitle ? whClass.shortTitle : whClass.shortName}
+        </span>
       )}
     </div>
   );
+
+  if (hideTooltip) {
+    return <div className={clsx(classes.WHClassViewRoot, className)}>{content}</div>;
+  }
+
+  return (
+    <div className={clsx(classes.WHClassViewRoot, className)}>
+      <WdTooltipWrapper
+        position={TooltipPosition.bottom}
+        content={
+          <div className="flex gap-3">
+            <div className="flex flex-col gap-1">
+              <InfoDrawer title="Total mass">{prepareMass(whData.total_mass)}</InfoDrawer>
+              <InfoDrawer title="Jump mass">{prepareMass(whData.max_mass_per_jump)}</InfoDrawer>
+            </div>
+            <div className="flex flex-col gap-1">
+              <InfoDrawer title="Lifetime">{whData.lifetime}h</InfoDrawer>
+              <InfoDrawer title="Mass regen">{prepareMass(whData.mass_regen)}</InfoDrawer>
+            </div>
+          </div>
+        }
+      >
+        {content}
+      </WdTooltipWrapper>
+    </div>
+  );
 };

assets/js/hooks/Mapper/helpers/index.ts

@@ -3,3 +3,4 @@ export * from './parseSignatures';
 export * from './getSystemById';
 export * from './getEveImageUrl';
 export * from './toastHelpers';
+export * from './recenterSystems';

assets/js/hooks/Mapper/helpers/recenterSystems.ts

@@ -0,0 +1,39 @@
+import { XYPosition } from 'reactflow';
+
+export type WithPosition<T = unknown> = T & { position: XYPosition };
+
+export const computeBoundsCenter = (items: Array<WithPosition>): XYPosition => {
+  if (items.length === 0) return { x: 0, y: 0 };
+
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+
+  for (const { position } of items) {
+    if (position.x < minX) minX = position.x;
+    if (position.x > maxX) maxX = position.x;
+    if (position.y < minY) minY = position.y;
+    if (position.y > maxY) maxY = position.y;
+  }
+
+  return {
+    x: minX + (maxX - minX) / 2,
+    y: minY + (maxY - minY) / 2,
+  };
+};
+
+/** Смещает все точки так, чтобы центр области стал (0,0) */
+export const recenterSystemsByBounds = <T extends WithPosition>(items: T[]): { center: XYPosition; systems: T[] } => {
+  const center = computeBoundsCenter(items);
+
+  const systems = items.map(it => ({
+    ...it,
+    position: {
+      x: it.position.x - center.x,
+      y: it.position.y - center.y,
+    },
+  }));
+
+  return { center, systems };
+};

assets/js/hooks/Mapper/hooks/useEventBuffer.ts

@@ -28,14 +28,17 @@ export const useEventBuffer = <T>(handler: UseEventBufferHandler<T>) => {
   eventTickRef.current = eventTick;
 
   // @ts-ignore
-  const handleEvent = useCallback(event => {
-    if (!eventTickRef.current) {
-      return;
-    }
+  const handleEvent = useCallback(
+    event => {
+      if (!eventTickRef.current) {
+        return;
+      }
 
-    eventsBufferRef.current.push(event);
-    eventTickRef.current();
-  }, []);
+      eventsBufferRef.current.push(event);
+      eventTickRef.current();
+    },
+    [eventTickRef.current],
+  );
 
   return { handleEvent };
 };

assets/js/hooks/Mapper/mapRootProvider/helpers/createDefaultStoredSettings.ts

@@ -19,7 +19,7 @@ export const createWidgetSettings = <T>(settings: T) => {
 export const createDefaultStoredSettings = (): MapUserSettings => {
   return {
     version: STORED_SETTINGS_VERSION,
-    migratedFromOld: true,
+    migratedFromOld: false,
     killsWidget: createWidgetSettings(DEFAULT_KILLS_WIDGET_SETTINGS),
     localWidget: createWidgetSettings(DEFAULT_WIDGET_LOCAL_SETTINGS),
     widgets: createWidgetSettings(getDefaultWidgetProps()),

assets/js/hooks/Mapper/mapRootProvider/hooks/useActualizeRemoteMapSettings.ts

@@ -42,7 +42,7 @@ export const useActualizeRemoteMapSettings = ({
     }
 
     try {
-      applySettings(applyMigrations(JSON.parse(res.default_settings)));
+      applySettings(applyMigrations(JSON.parse(res.default_settings) || createDefaultStoredSettings()));
     } catch (error) {
       applySettings(createDefaultStoredSettings());
     }

assets/js/hooks/Mapper/mapRootProvider/hooks/useMapUserSettings.ts

@@ -115,10 +115,15 @@ export const useMapUserSettings = ({ map_slug }: MapRootData, outCommand: OutCom
     }
 
     try {
+      // here we try to restore settings
+      let oldMapData;
+      if (!currentMapUserSettings.migratedFromOld) {
+        const allData = extractData(LS_KEY_LEGASY);
+        oldMapData = allData?.[map_slug];
+      }
+
       // INFO: after migrations migratedFromOld always will be true
-      const migratedResult = applyMigrations(
-        !currentMapUserSettings.migratedFromOld ? extractData(LS_KEY_LEGASY) : currentMapUserSettings,
-      );
+      const migratedResult = applyMigrations(oldMapData ? oldMapData : currentMapUserSettings);
 
       if (!migratedResult) {
         setIsReady(true);

assets/js/hooks/Mapper/mapRootProvider/migrations/applyMigrations.ts

@@ -26,7 +26,7 @@ export const applyMigrations = (mapSettings: any) => {
       return { ...currentMapSettings, version: STORED_SETTINGS_VERSION, migratedFromOld: true };
     }
 
-    return;
+    return currentMapSettings;
   }
 
   const cmVersion = currentMapSettings.version || 0;

assets/js/hooks/Mapper/mapRootProvider/version.ts

@@ -1,4 +1,4 @@
 export const STORED_SETTINGS_VERSION = 2;
 
 export const LS_KEY_LEGASY = 'map-user-settings';
-export const LS_KEY = 'map-user-settings-v2';
+export const LS_KEY = 'map-user-settings-v3';

assets/js/hooks/Mapper/types/mapHandlers.ts

@@ -247,6 +247,7 @@ export enum OutCommand {
   deleteSystems = 'delete_systems',
   manualAddSystem = 'manual_add_system',
   manualAddConnection = 'manual_add_connection',
+  manualPasteSystemsAndConnections = 'manual_paste_systems_and_connections',
   manualDeleteConnection = 'manual_delete_connection',
   setAutopilotWaypoint = 'set_autopilot_waypoint',
   addSystem = 'add_system',

assets/js/hooks/Mapper/types/signatures.ts

@@ -29,7 +29,7 @@ export type GroupType = {
 
 export type SignatureCustomInfo = {
   k162Type?: string;
-  isEOL?: boolean;
+  time_status?: number;
   isCrit?: boolean;
 };
 

assets/js/hooks/Mapper/useMapperHandlers.ts

@@ -1,5 +1,5 @@
-import { useEventBuffer } from '@/hooks/Mapper/hooks';
 import usePageVisibility from '@/hooks/Mapper/hooks/usePageVisibility.ts';
+import debounce from 'lodash.debounce';
 
 import { MapHandlers } from '@/hooks/Mapper/types/mapHandlers.ts';
 import { RefObject, useCallback, useEffect, useRef } from 'react';
@@ -16,23 +16,6 @@ export const useMapperHandlers = (handlerRefs: RefObject<MapHandlers>[], hooksRe
   const visibleRef = useRef(visible);
   visibleRef.current = visible;
 
-  // @ts-ignore
-  const handleBufferedEvent = useCallback(({ type, body }) => {
-    if (!visibleRef.current) {
-      return;
-    }
-
-    handlerRefs.forEach(ref => {
-      if (!ref.current) {
-        return;
-      }
-
-      ref.current?.command(type, body);
-    });
-  }, []);
-
-  const { handleEvent: handleMapEvent } = useEventBuffer<any>(handleBufferedEvent);
-
   // TODO - do not delete THIS code it needs for debug
   // const [record, setRecord] = useLocalStorageState<boolean>('record', {
   //   defaultValue: false,
@@ -73,6 +56,52 @@ export const useMapperHandlers = (handlerRefs: RefObject<MapHandlers>[], hooksRe
     [hooksRef.current],
   );
 
+  // @ts-ignore
+  const eventsBufferRef = useRef<{ type; body }[]>([]);
+
+  const eventTick = useCallback(
+    debounce(() => {
+      if (eventsBufferRef.current.length === 0) {
+        return;
+      }
+
+      const { type, body } = eventsBufferRef.current.shift()!;
+      handlerRefs.forEach(ref => {
+        if (!ref.current) {
+          return;
+        }
+
+        ref.current?.command(type, body);
+      });
+
+      // TODO - do not delete THIS code it needs for debug
+      // console.log('JOipP', `Tick Buff`, eventsBufferRef.current.length);
+
+      if (eventsBufferRef.current.length > 0) {
+        eventTick();
+      }
+    }, 10),
+    [],
+  );
+  const eventTickRef = useRef(eventTick);
+  eventTickRef.current = eventTick;
+
+  // @ts-ignore
+  const handleMapEvent = useCallback(({ type, body }) => {
+    // TODO - do not delete THIS code it needs for debug
+    // const currentTime = +new Date();
+    // const timeDiff = currentTime - prevEventTime;
+    // prevEventTime = currentTime;
+    // console.log('JOipP', `IN [${inIndex++}] [${timeDiff}] ${getFormattedTime()}`, { type, body });
+
+    if (!eventTickRef.current || !visibleRef.current) {
+      return;
+    }
+
+    eventsBufferRef.current.push({ type, body });
+    eventTickRef.current();
+  }, []);
+
   useEffect(() => {
     if (!visible && !wasHiddenOnce.current) {
       wasHiddenOnce.current = true;

assets/js/hooks/Mapper/utils/index.ts

@@ -3,3 +3,4 @@ export * from './getQueryVariable';
 export * from './loadTextFile';
 export * from './saveToFile';
 export * from './omit';
+export * from './jsonToUriBase64';

assets/js/hooks/Mapper/utils/jsonToUriBase64.ts

@@ -0,0 +1,26 @@
+export const encodeJsonToUriBase64 = (value: unknown): string => {
+  const json = JSON.stringify(value);
+  const uriEncoded = encodeURIComponent(json);
+
+  if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
+    return window.btoa(uriEncoded);
+  }
+  // Node.js
+  // @ts-ignore
+  return Buffer.from(uriEncoded, 'utf8').toString('base64');
+};
+
+export const decodeUriBase64ToJson = <T = unknown>(base64: string): T => {
+  let uriEncoded: string;
+
+  if (typeof window !== 'undefined' && typeof window.atob === 'function') {
+    uriEncoded = window.atob(base64);
+  } else {
+    // Node.js
+    // @ts-ignore
+    uriEncoded = Buffer.from(base64, 'base64').toString('utf8');
+  }
+
+  const json = decodeURIComponent(uriEncoded);
+  return JSON.parse(json) as T;
+};

lib/wanderer_app/map/map_manager.ex

@@ -9,15 +9,12 @@ defmodule WandererApp.Map.Manager do
 
   alias WandererApp.Map.Server
   alias WandererApp.Map.ServerSupervisor
-  alias WandererApp.Api.MapSystemSignature
 
   @maps_start_per_second 10
   @maps_start_interval 1000
   @maps_queue :maps_queue
   @garbage_collection_interval :timer.hours(1)
   @check_maps_queue_interval :timer.seconds(1)
-  @signatures_cleanup_interval :timer.minutes(30)
-  @delete_after_minutes 30
 
   @pings_cleanup_interval :timer.minutes(10)
   @pings_expire_minutes 60
@@ -66,9 +63,6 @@ defmodule WandererApp.Map.Manager do
     {:ok, garbage_collector_timer} =
       :timer.send_interval(@garbage_collection_interval, :garbage_collect)
 
-    {:ok, signatures_cleanup_timer} =
-      :timer.send_interval(@signatures_cleanup_interval, :cleanup_signatures)
-
     {:ok, pings_cleanup_timer} =
       :timer.send_interval(@pings_cleanup_interval, :cleanup_pings)
 
@@ -80,7 +74,6 @@ defmodule WandererApp.Map.Manager do
      %{
        garbage_collector_timer: garbage_collector_timer,
        check_maps_queue_timer: check_maps_queue_timer,
-       signatures_cleanup_timer: signatures_cleanup_timer,
        pings_cleanup_timer: pings_cleanup_timer
      }}
   end
@@ -143,18 +136,6 @@ defmodule WandererApp.Map.Manager do
     end
   end
 
-  @impl true
-  def handle_info(:cleanup_signatures, state) do
-    try do
-      cleanup_deleted_signatures()
-      {:noreply, state}
-    rescue
-      e ->
-        Logger.error("Failed to cleanup signatures: #{inspect(e)}")
-        {:noreply, state}
-    end
-  end
-
   @impl true
   def handle_info(:cleanup_pings, state) do
     try do
@@ -167,23 +148,6 @@ defmodule WandererApp.Map.Manager do
     end
   end
 
-  defp cleanup_deleted_signatures() do
-    delete_after_date = DateTime.utc_now() |> DateTime.add(-1 * @delete_after_minutes, :minute)
-
-    case MapSystemSignature.by_deleted_and_updated_before!(true, delete_after_date) do
-      {:ok, deleted_signatures} ->
-        Enum.each(deleted_signatures, fn sig ->
-          Ash.destroy!(sig)
-        end)
-
-        :ok
-
-      {:error, error} ->
-        Logger.error("Failed to fetch deleted signatures: #{inspect(error)}")
-        {:error, error}
-    end
-  end
-
   defp cleanup_expired_pings() do
     delete_after_date = DateTime.utc_now() |> DateTime.add(-1 * @pings_expire_minutes, :minute)
 

lib/wanderer_app/map/map_server.ex

@@ -107,6 +107,18 @@ defmodule WandererApp.Map.Server do
       |> map_pid!
       |> GenServer.cast({&Impl.add_system/4, [system_info, user_id, character_id]})
 
+  def paste_connections(map_id, connections, user_id, character_id) when is_binary(map_id),
+    do:
+      map_id
+      |> map_pid!
+      |> GenServer.cast({&Impl.paste_connections/4, [connections, user_id, character_id]})
+
+  def paste_systems(map_id, systems, user_id, character_id) when is_binary(map_id),
+    do:
+      map_id
+      |> map_pid!
+      |> GenServer.cast({&Impl.paste_systems/4, [systems, user_id, character_id]})
+
   def add_system_comment(map_id, comment_info, user_id, character_id) when is_binary(map_id),
     do:
       map_id

lib/wanderer_app/map/server/map_server_characters_impl.ex

@@ -366,7 +366,8 @@ defmodule WandererApp.Map.Server.CharactersImpl do
                     location,
                     old_location,
                     character_id,
-                    false
+                    false,
+                    nil
                   )
               end
 

lib/wanderer_app/map/server/map_server_connections_impl.ex

@@ -144,7 +144,7 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
           solar_system_source_id: solar_system_source_id,
           solar_system_target_id: solar_system_target_id,
           character_id: character_id
-        } = _connection_info
+        } = connection_info
       ) do
     :ok =
       maybe_add_connection(
@@ -154,12 +154,39 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
           solar_system_id: solar_system_source_id
         },
         character_id,
-        true
+        true,
+        connection_info |> Map.get(:extra_info)
       )
 
     state
   end
 
+  def paste_connections(
+        %{map_id: map_id} = state,
+        connections,
+        _user_id,
+        character_id
+      ) do
+    connections
+    |> Enum.each(fn %{
+                      "source" => source,
+                      "target" => target
+                    } = connection ->
+      solar_system_source_id = source |> String.to_integer()
+      solar_system_target_id = target |> String.to_integer()
+
+      state
+      |> add_connection(%{
+        solar_system_source_id: solar_system_source_id,
+        solar_system_target_id: solar_system_target_id,
+        character_id: character_id,
+        extra_info: connection
+      })
+    end)
+
+    state
+  end
+
   def delete_connection(
         %{map_id: map_id} = state,
         %{
@@ -445,7 +472,14 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
     Impl.broadcast!(map_id, :signatures_updated, solar_system_id)
   end
 
-  def maybe_add_connection(map_id, location, old_location, character_id, is_manual)
+  def maybe_add_connection(
+        map_id,
+        location,
+        old_location,
+        character_id,
+        is_manual,
+        extra_info
+      )
       when not is_nil(location) and not is_nil(old_location) and
              not is_nil(old_location.solar_system_id) and
              location.solar_system_id != old_location.solar_system_id do
@@ -496,6 +530,12 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
             @connection_time_status_default
           end
 
+        connection_type = get_extra_info(extra_info, "type", connection_type)
+        ship_size_type = get_extra_info(extra_info, "ship_size_type", ship_size_type)
+        time_status = get_extra_info(extra_info, "time_status", time_status)
+        mass_status = get_extra_info(extra_info, "mass_status", 0)
+        locked = get_extra_info(extra_info, "locked", false)
+
         {:ok, connection} =
           WandererApp.MapConnectionRepo.create(%{
             map_id: map_id,
@@ -503,7 +543,9 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
             solar_system_target: location.solar_system_id,
             type: connection_type,
             ship_size_type: ship_size_type,
-            time_status: time_status
+            time_status: time_status,
+            mass_status: mass_status,
+            locked: locked
           })
 
         if connection_type == @connection_type_wormhole do
@@ -563,7 +605,19 @@ defmodule WandererApp.Map.Server.ConnectionsImpl do
     end
   end
 
-  def maybe_add_connection(_map_id, _location, _old_location, _character_id, _is_manual), do: :ok
+  def maybe_add_connection(
+        _map_id,
+        _location,
+        _old_location,
+        _character_id,
+        _is_manual,
+        _connection_extra_info
+      ),
+      do: :ok
+
+  defp get_extra_info(nil, _key, default_value), do: default_value
+
+  defp get_extra_info(extra_info, key, default_value), do: Map.get(extra_info, key, default_value)
 
   def get_start_time(map_id, connection_id) do
     case WandererApp.Cache.get("map_#{map_id}:conn_#{connection_id}:start_time") do

lib/wanderer_app/map/server/map_server_impl.ex

@@ -159,6 +159,8 @@ defmodule WandererApp.Map.Server.Impl do
 
   defdelegate add_system(state, system_info, user_id, character_id), to: SystemsImpl
 
+  defdelegate paste_systems(state, systems, user_id, character_id), to: SystemsImpl
+
   defdelegate add_system_comment(state, comment_info, user_id, character_id), to: SystemsImpl
 
   defdelegate remove_system_comment(state, comment_id, user_id, character_id), to: SystemsImpl
@@ -203,6 +205,8 @@ defmodule WandererApp.Map.Server.Impl do
 
   defdelegate get_connection_info(state, connection_info), to: ConnectionsImpl
 
+  defdelegate paste_connections(state, connections, user_id, character_id), to: ConnectionsImpl
+
   defdelegate update_connection_time_status(state, connection_update), to: ConnectionsImpl
 
   defdelegate update_connection_type(state, connection_update), to: ConnectionsImpl

lib/wanderer_app/map/server/map_server_signatures_impl.ex

@@ -110,23 +110,6 @@ defmodule WandererApp.Map.Server.SignaturesImpl do
         nil ->
           MapSystemSignature.create!(sig)
 
-        %MapSystemSignature{deleted: true} = deleted_sig ->
-          MapSystemSignature.update!(
-            deleted_sig,
-            Map.take(sig, [
-              :name,
-              :temporary_name,
-              :description,
-              :kind,
-              :group,
-              :type,
-              :character_eve_id,
-              :custom_info,
-              :deleted,
-              :update_forced_at
-            ])
-          )
-
         _ ->
           :noop
       end
@@ -206,8 +189,8 @@ defmodule WandererApp.Map.Server.SignaturesImpl do
       })
     end
 
-    # mark as deleted
-    MapSystemSignature.update!(sig, %{deleted: true})
+    sig
+    |> MapSystemSignature.destroy!()
   end
 
   def apply_update_signature(

lib/wanderer_app/map/server/map_server_systems_impl.ex

@@ -57,6 +57,36 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     end
   end
 
+  def paste_systems(
+        %{map_id: map_id} = state,
+        systems,
+        user_id,
+        character_id
+      ) do
+    systems
+    |> Enum.each(fn %{
+                      "id" => solar_system_id,
+                      "position" => coordinates
+                    } = system ->
+      solar_system_id = solar_system_id |> String.to_integer()
+
+      case map_id |> WandererApp.Map.check_location(%{solar_system_id: solar_system_id}) do
+        {:ok, _location} ->
+          state
+          |> _add_system(
+            %{solar_system_id: solar_system_id, coordinates: coordinates, extra_info: system},
+            user_id,
+            character_id
+          )
+
+        {:error, :already_exists} ->
+          :ok
+      end
+    end)
+
+    state
+  end
+
   def add_system_comment(
         %{map_id: map_id} = state,
         %{
@@ -369,8 +399,13 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     |> Enum.uniq_by(& &1.system_id)
     |> Enum.each(fn s ->
       try do
-        {:ok, %{system: system}} = s |> Ash.load([:system])
+        {:ok, %{eve_id: eve_id, system: system}} = s |> Ash.load([:system])
         :ok = Ash.destroy!(s)
+
+        Logger.warning(
+          "[cleanup_linked_signatures] for system #{system.solar_system_id}: #{inspect(eve_id)}"
+        )
+
         Impl.broadcast!(map_id, :signatures_updated, system.solar_system_id)
       rescue
         e ->
@@ -512,6 +547,8 @@ defmodule WandererApp.Map.Server.SystemsImpl do
          user_id,
          character_id
        ) do
+    extra_info = system_info |> Map.get(:extra_info)
+
     %{"x" => x, "y" => y} =
       coordinates
       |> case do
@@ -558,6 +595,7 @@ defmodule WandererApp.Map.Server.SystemsImpl do
             |> WandererApp.MapSystemRepo.cleanup_tags!()
             |> WandererApp.MapSystemRepo.cleanup_temporary_name!()
             |> WandererApp.MapSystemRepo.cleanup_linked_sig_eve_id!()
+            |> maybe_update_extra_info(extra_info)
             |> WandererApp.MapSystemRepo.update_visible(%{visible: true})
           end
 
@@ -616,6 +654,127 @@ defmodule WandererApp.Map.Server.SystemsImpl do
     state
   end
 
+  defp maybe_update_extra_info(system, nil), do: system
+
+  defp maybe_update_extra_info(
+         system,
+         %{
+           "description" => description,
+           "labels" => labels,
+           "name" => name,
+           "status" => status,
+           "tag" => tag,
+           "temporary_name" => temporary_name
+         }
+       ) do
+    system
+    |> maybe_update_name(name)
+    |> maybe_update_description(description)
+    |> maybe_update_labels(labels)
+    |> maybe_update_status(status)
+    |> maybe_update_tag(tag)
+    |> maybe_update_temporary_name(temporary_name)
+  end
+
+  defp maybe_update_description(
+         %{description: old_description} = system,
+         description
+       )
+       when not is_nil(description) and old_description != description do
+    {:ok, updated_system} =
+      system
+      |> WandererApp.MapSystemRepo.update_description(%{description: description})
+
+    updated_system
+  end
+
+  defp maybe_update_description(system, _description), do: system
+
+  defp maybe_update_name(
+         %{name: old_name} = system,
+         name
+       )
+       when not is_nil(name) and old_name != name do
+    {:ok, updated_system} =
+      system
+      |> WandererApp.MapSystemRepo.update_name(%{name: name})
+
+    updated_system
+  end
+
+  defp maybe_update_name(system, _name), do: system
+
+  defp maybe_update_labels(
+         %{name: old_labels} = system,
+         labels
+       )
+       when not is_nil(labels) and old_labels != labels do
+    {:ok, updated_system} =
+      system
+      |> WandererApp.MapSystemRepo.update_labels(%{labels: labels})
+
+    updated_system
+  end
+
+  defp maybe_update_labels(system, _labels), do: system
+
+  defp maybe_update_labels(
+         %{name: old_labels} = system,
+         labels
+       )
+       when not is_nil(labels) and old_labels != labels do
+    {:ok, updated_system} =
+      system
+      |> WandererApp.MapSystemRepo.update_labels(%{labels: labels})
+
+    updated_system
+  end
+
+  defp maybe_update_labels(system, _labels), do: system
+
+  defp maybe_update_status(
+         %{name: old_status} = system,
+         status
+       )
+       when not is_nil(status) and old_status != status do
+    {:ok, updated_system} =
+      system
+      |> WandererApp.MapSystemRepo.update_status(%{status: status})
+
+    updated_system
+  end
+
+  defp maybe_update_status(system, _status), do: system
+
+  defp maybe_update_tag(
+         %{name: old_tag} = system,
+         tag
+       )
+       when not is_nil(tag) and old_tag != tag do
+    {:ok, updated_system} =
+      system
+      |> WandererApp.MapSystemRepo.update_tag(%{tag: tag})
+
+    updated_system
+  end
+
+  defp maybe_update_tag(system, _labels), do: system
+
+  defp maybe_update_temporary_name(
+         %{name: old_temporary_name} = system,
+         temporary_name
+       )
+       when not is_nil(temporary_name) and old_temporary_name != temporary_name do
+    {:ok, updated_system} =
+      system
+      |> WandererApp.MapSystemRepo.update_temporary_name(%{temporary_name: temporary_name})
+
+    updated_system
+  end
+
+  defp maybe_update_temporary_name(system, _temporary_name),
+    do: system
+
   defp calc_new_system_position(map_id, old_location, rtree_name, opts),
     do:
       {:ok,

lib/wanderer_app_web/live/map/event_handlers/map_connections_event_handler.ex

@@ -102,6 +102,12 @@ defmodule WandererAppWeb.MapConnectionsEventHandler do
       |> WandererApp.MapUserSettingsRepo.get_boolean_setting("delete_connection_with_sigs")
 
     if delete_connection_with_sigs do
+      source_system =
+        WandererApp.Map.find_system_by_location(
+          map_id,
+          %{solar_system_id: solar_system_source_id}
+        )
+
       target_system =
         WandererApp.Map.find_system_by_location(
           map_id,
@@ -113,6 +119,9 @@ defmodule WandererAppWeb.MapConnectionsEventHandler do
           WandererApp.Api.MapSystemSignature.by_linked_system_id(solar_system_target_id)
 
         signatures
+        |> Enum.filter(fn s ->
+          s.system_id == source_system.id
+        end)
         |> Enum.each(fn s ->
           if not is_nil(s.temporary_name) && s.temporary_name == target_system.temporary_name do
             map_id

lib/wanderer_app_web/live/map/event_handlers/map_core_event_handler.ex

@@ -703,18 +703,6 @@ defmodule WandererAppWeb.MapCoreEventHandler do
 
     Process.send_after(self(), %{event: :load_map_pings}, 200)
 
-    Process.send_after(
-      self(),
-      %{
-        event: :maybe_select_system,
-        payload: %{
-          character_id: nil,
-          solar_system_id: nil
-        }
-      },
-      200
-    )
-
     if needs_tracking_setup do
       Process.send_after(self(), %{event: :show_tracking}, 10)
 

lib/wanderer_app_web/live/map/event_handlers/map_signatures_event_handler.ex

@@ -38,7 +38,11 @@ defmodule WandererAppWeb.MapSignaturesEventHandler do
       })
       |> case do
         {:ok, system} ->
-          {:ok, get_system_signatures(system.id)}
+          {:ok,
+           get_system_signatures(system.id)
+           |> Enum.filter(fn signature ->
+             is_nil(signature.linked_system) && signature.group == "Wormhole"
+           end)}
 
         _ ->
           {:ok, []}
@@ -69,6 +73,51 @@ defmodule WandererAppWeb.MapSignaturesEventHandler do
           solar_system_id
         )
 
+  def handle_server_event(
+        %{event: :remove_signatures, payload: {solar_system_id, removed_signatures}},
+        %{
+          assigns: %{
+            current_user: %{id: current_user_id},
+            main_character_id: main_character_id,
+            map_id: map_id,
+            map_user_settings: map_user_settings,
+            removed_sig_eve_ids: removed_sig_eve_ids
+          }
+        } = socket
+      ) do
+    solar_system_id = get_integer(solar_system_id)
+
+    delete_connection_with_sigs =
+      map_user_settings
+      |> WandererApp.MapUserSettingsRepo.to_form_data!()
+      |> WandererApp.MapUserSettingsRepo.get_boolean_setting("delete_connection_with_sigs")
+
+    to_remove =
+      removed_signatures
+      |> Enum.filter(fn %{"eve_id" => eve_id} -> eve_id in removed_sig_eve_ids end)
+
+    to_remove_eve_ids =
+      to_remove
+      |> Enum.map(fn %{"eve_id" => eve_id} -> eve_id end)
+
+    map_id
+    |> WandererApp.Map.Server.update_signatures(%{
+      solar_system_id: solar_system_id,
+      character_id: main_character_id,
+      user_id: current_user_id,
+      delete_connection_with_sigs: delete_connection_with_sigs,
+      added_signatures: [],
+      updated_signatures: [],
+      removed_signatures: to_remove
+    })
+
+    socket
+    |> assign(
+      removed_sig_eve_ids:
+        removed_sig_eve_ids |> Enum.reject(fn sig_id -> sig_id in to_remove_eve_ids end)
+    )
+  end
+
   def handle_server_event(event, socket),
     do: MapCoreEventHandler.handle_server_event(event, socket)
 
@@ -110,45 +159,61 @@ defmodule WandererAppWeb.MapSignaturesEventHandler do
           "system_id" => solar_system_id,
           "added" => added_signatures,
           "updated" => updated_signatures,
-          "removed" => removed_signatures
+          "removed" => removed_signatures,
+          "deleteTimeout" => delete_timeout
         },
         %{
-          assigns: %{
-            current_user: %{id: current_user_id},
-            map_id: map_id,
-            main_character_id: main_character_id,
-            map_user_settings: map_user_settings,
-            user_permissions: %{update_system: true}
-          }
+          assigns:
+            %{
+              current_user: %{id: current_user_id},
+              map_id: map_id,
+              main_character_id: main_character_id,
+              map_user_settings: map_user_settings,
+              user_permissions: %{update_system: true}
+            } = assigns
         } = socket
       )
       when not is_nil(main_character_id) do
-    delete_connection_with_sigs =
-      map_user_settings
-      |> WandererApp.MapUserSettingsRepo.to_form_data!()
-      |> WandererApp.MapUserSettingsRepo.get_boolean_setting("delete_connection_with_sigs")
+    solar_system_id = get_integer(solar_system_id)
+
+    old_removed_sig_eve_ids = Map.get(assigns, :removed_sig_eve_ids, [])
+
+    new_removed_sig_eve_ids =
+      removed_signatures
+      |> Enum.map(fn %{"eve_id" => eve_id} -> eve_id end)
+
+    Process.send_after(
+      self(),
+      %{event: :remove_signatures, payload: {solar_system_id, removed_signatures}},
+      delete_timeout
+    )
 
     map_id
     |> WandererApp.Map.Server.update_signatures(%{
-      solar_system_id: get_integer(solar_system_id),
+      solar_system_id: solar_system_id,
       character_id: main_character_id,
       user_id: current_user_id,
-      delete_connection_with_sigs: delete_connection_with_sigs,
+      delete_connection_with_sigs: false,
       added_signatures: added_signatures,
       updated_signatures: updated_signatures,
-      removed_signatures: removed_signatures
+      removed_signatures: []
     })
 
-    {:noreply, socket}
+    {:noreply,
+     socket
+     |> assign(
+       removed_sig_eve_ids: (old_removed_sig_eve_ids ++ new_removed_sig_eve_ids) |> Enum.uniq()
+     )}
   end
 
   def handle_ui_event(
         "get_signatures",
         %{"system_id" => solar_system_id},
         %{
-          assigns: %{
-            map_id: map_id
-          }
+          assigns:
+            %{
+              map_id: map_id
+            } = assigns
         } = socket
       ) do
     case WandererApp.Api.MapSystem.read_by_map_and_solar_system(%{
@@ -156,7 +221,19 @@ defmodule WandererAppWeb.MapSignaturesEventHandler do
            solar_system_id: get_integer(solar_system_id)
          }) do
       {:ok, system} ->
-        {:reply, %{signatures: get_system_signatures(system.id)}, socket}
+        removed_sig_eve_ids = Map.get(assigns, :removed_sig_eve_ids, [])
+
+        system_signatures =
+          get_system_signatures(system.id)
+          |> Enum.map(fn sig ->
+            if sig.eve_id in removed_sig_eve_ids do
+              sig |> Map.put(:deleted, true)
+            else
+              sig
+            end
+          end)
+
+        {:reply, %{signatures: system_signatures}, socket}
 
       _ ->
         {:reply, %{signatures: []}, socket}
@@ -308,33 +385,19 @@ defmodule WandererAppWeb.MapSignaturesEventHandler do
           assigns: %{
             map_id: map_id,
             main_character_id: main_character_id,
-            user_permissions: %{update_system: true}
+            user_permissions: %{update_system: true},
+            removed_sig_eve_ids: removed_sig_eve_ids
           }
         } = socket
       )
       when not is_nil(main_character_id) do
-    case WandererApp.Api.MapSystem.read_by_map_and_solar_system(%{
-           map_id: map_id,
-           solar_system_id: get_integer(solar_system_id)
-         }) do
-      {:ok, system} ->
-        restored =
-          WandererApp.Api.MapSystemSignature.by_system_id_all!(system.id)
-          |> Enum.filter(fn s -> s.eve_id in eve_ids end)
-          |> Enum.map(fn s ->
-            s |> WandererApp.Api.MapSystemSignature.update!(%{deleted: false})
-          end)
+    WandererApp.Map.Server.Impl.broadcast!(map_id, :signatures_updated, solar_system_id)
 
-        Phoenix.PubSub.broadcast!(WandererApp.PubSub, map_id, %{
-          event: :signatures_updated,
-          payload: system.solar_system_id
-        })
-
-        {:noreply, socket}
-
-      _ ->
-        {:noreply, socket}
-    end
+    {:noreply,
+     socket
+     |> assign(
+       removed_sig_eve_ids: removed_sig_eve_ids |> Enum.reject(fn sig_id -> sig_id in eve_ids end)
+     )}
   end
 
   def handle_ui_event(event, body, socket),

lib/wanderer_app_web/live/map/event_handlers/map_systems_event_handler.ex

@@ -129,6 +129,41 @@ defmodule WandererAppWeb.MapSystemsEventHandler do
     {:noreply, socket}
   end
 
+  def handle_ui_event(
+        "manual_paste_systems_and_connections",
+        %{
+          "connections" => connections,
+          "systems" => systems
+        } = _event,
+        %{
+          assigns: %{
+            current_user: current_user,
+            has_tracked_characters?: true,
+            map_id: map_id,
+            main_character_id: main_character_id,
+            user_permissions: %{add_system: true}
+          }
+        } =
+          socket
+      )
+      when not is_nil(main_character_id) do
+    WandererApp.Map.Server.paste_systems(
+      map_id,
+      systems,
+      current_user.id,
+      main_character_id
+    )
+
+    WandererApp.Map.Server.paste_connections(
+      map_id,
+      connections,
+      current_user.id,
+      main_character_id
+    )
+
+    {:noreply, socket}
+  end
+
   def handle_ui_event(
         "update_system_position",
         position,

lib/wanderer_app_web/live/map/map_event_handler.ex

@@ -57,7 +57,8 @@ defmodule WandererAppWeb.MapEventHandler do
     "update_system_locked",
     "update_system_tag",
     "update_system_temporary_name",
-    "update_system_status"
+    "update_system_status",
+    "manual_paste_systems_and_connections"
   ]
 
   @map_system_comments_events [
@@ -116,7 +117,8 @@ defmodule WandererAppWeb.MapEventHandler do
 
   @map_signatures_events [
     :maybe_link_signature,
-    :signatures_updated
+    :signatures_updated,
+    :remove_signatures
   ]
 
   @map_signatures_ui_events [

mix.exs

@@ -3,7 +3,7 @@ defmodule WandererApp.MixProject do
 
   @source_url "https://github.com/wanderer-industries/wanderer"
 
-  @version "1.81.5"
+  @version "1.82.0"
 
   def project do
     [