fix(Map): Fix system static info - add source region for U319 from Null-sec

fix(Map): Fix system static info - for J012635 add D382; for J015092 …

CHANGELOG.md

@@ -2,6 +2,109 @@
 
 <!-- changelog -->
 
+## [v1.82.2](https://github.com/wanderer-industries/wanderer/compare/v1.82.1...v1.82.2) (2025-10-21)
+
+
+
+
+### Bug Fixes:
+
+* Map: Fix system static info - for J012635 add D382; for J015092 - changed from J244, Z060 to N110, J244; for J000487 removed C008
+
+## [v1.82.1](https://github.com/wanderer-industries/wanderer/compare/v1.82.0...v1.82.1) (2025-10-20)
+
+
+
+
+### Bug Fixes:
+
+* Core: Fixed 'viewer' map access & characters tracking
+
+## [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)
 
 

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/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/character/tracking_utils.ex

@@ -173,12 +173,11 @@ defmodule WandererApp.Character.TrackingUtils do
          %{
            id: character_id,
            eve_id: eve_id
-         },
+         } = _character,
          map_id,
          is_track_allowed,
          caller_pid
-       )
-       when not is_nil(caller_pid) do
+       ) do
     WandererAppWeb.Presence.update(caller_pid, map_id, character_id, %{
       tracked: is_track_allowed,
       from: DateTime.utc_now()
@@ -217,13 +216,16 @@ defmodule WandererApp.Character.TrackingUtils do
   end
 
   defp track_character(
-         _character,
+         character,
          _map_id,
          _is_track_allowed,
          _caller_pid
        ) do
-    Logger.error("caller_pid is required for tracking characters")
-    {:error, "caller_pid is required"}
+    Logger.error(
+      "Invalid character data for tracking - character must have :id and :eve_id fields, got: #{inspect(character)}"
+    )
+
+    {:error, "Invalid character data"}
   end
 
   def untrack(characters, map_id, caller_pid) do
@@ -243,7 +245,7 @@ defmodule WandererApp.Character.TrackingUtils do
       :ok
     else
       true ->
-        Logger.error("caller_pid is required for untracking characters")
+        Logger.error("caller_pid is required for untracking characters 2")
         {:error, "caller_pid is required"}
     end
   end

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_characters_event_handler.ex

@@ -365,15 +365,19 @@ defmodule WandererAppWeb.MapCharactersEventHandler do
   end
 
   defp handle_tracking_event({:track_characters, map_characters, track_character}, socket, map_id) do
-    :ok =
-      WandererApp.Character.TrackingUtils.track(
-        map_characters,
-        map_id,
-        track_character,
-        self()
-      )
+    case WandererApp.Character.TrackingUtils.track(
+           map_characters,
+           map_id,
+           track_character,
+           self()
+         ) do
+      :ok ->
+        socket
 
-    socket
+      {:error, reason} ->
+        Logger.error("Failed to track characters: #{inspect(reason)}")
+        socket
+    end
   end
 
   defp handle_tracking_event(:invalid_token_message, socket, _map_id) do

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

@@ -557,7 +557,12 @@ defmodule WandererAppWeb.MapCoreEventHandler do
           # in case user has not tracked any character track his main character as viewer
           track_character && not has_tracked_characters? ->
             main_character = Enum.find(current_user.characters, &(&1.id == main_character_id))
-            events ++ [{:track_characters, [main_character], false}]
+
+            if main_character do
+              events ++ [{:track_characters, [main_character], false}]
+            else
+              events
+            end
 
           track_character && not character_limit_reached? ->
             events ++ [{:track_characters, tracked_characters, track_character}]
@@ -568,7 +573,12 @@ defmodule WandererAppWeb.MapCoreEventHandler do
           # in case user has view only permissions track his main character as viewer
           not track_character ->
             main_character = Enum.find(current_user.characters, &(&1.id == main_character_id))
-            events ++ [{:track_characters, [main_character], track_character}]
+
+            if main_character do
+              events ++ [{:track_characters, [main_character], track_character}]
+            else
+              events
+            end
 
           true ->
             events
@@ -703,18 +713,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 [

lib/wanderer_app_web/presence_grace_period_manager.ex

@@ -73,11 +73,7 @@ defmodule WandererAppWeb.PresenceGracePeriodManager do
     # Update cache with final character IDs (includes grace period logic)
     WandererApp.Cache.insert("map_#{map_id}:presence_character_ids", final_character_ids)
 
-    # Only update presence_data if the character IDs actually changed
-    if final_character_ids != previous_tracked_character_ids do
-      WandererApp.Cache.insert("map_#{map_id}:presence_data", presence_data)
-    end
-
+    WandererApp.Cache.insert("map_#{map_id}:presence_data", presence_data)
     WandererApp.Cache.insert("map_#{map_id}:presence_updated", true)
 
     {:noreply, state}

mix.exs

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

priv/repo/data/wormholeSystems.json

@@ -32562,7 +32562,8 @@
 		"solarSystemID": 31002522,
 		"statics": [
 			"A239",
-			"B274"
+			"B274",
+			"D382"
 		],
 		"systemName": "J012635",
 		"effectName": null
@@ -33100,8 +33101,8 @@
 		],
 		"solarSystemID": 31002505,
 		"statics": [
-			"J244",
-			"Z060"
+			"N110",
+			"J244"
 		],
 		"systemName": "J015092",
 		"effectName": "Black Hole"
@@ -36792,7 +36793,6 @@
 		"wanderers": [],
 		"solarSystemID": 31002581,
 		"statics": [
-			"C008",
 			"Q003",
 			"Z006"
 		],

priv/repo/data/wormholes.json

@@ -827,7 +827,7 @@
   {
     "mass_regen": 0,
     "dest": "pochven",
-    "src": [],
+    "src": ["ns"],
     "static": false,
     "max_mass_per_jump": 375000000,
     "lifetime": "16",