fix(Core): fixed lazy delete timeouts

2025-12-15 12:15:55 +00:00 · 2025-03-16 13:32:39 +01:00
parent 3028a0b1c0
commit 8db46113f4
10 changed files with 155 additions and 234 deletions
--- a/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/types.ts
+++ b/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/types.ts
@@ -6,7 +6,10 @@ export interface UseSystemSignaturesDataProps {
  settings: SignatureSettingsType;
  hideLinkedSignatures?: boolean;
  onCountChange?: (count: number) => void;
-  onPendingChange?: (pending: ExtendedSystemSignature[], undo: () => void) => void;
+  onPendingChange?: (
+    pending: React.MutableRefObject<Record<string, ExtendedSystemSignature>>,
+    undo: () => void,
+  ) => void;
  onLazyDeleteChange?: (value: boolean) => void;
  deletionTiming?: number;
 }
@@ -15,16 +18,21 @@ export interface UseFetchingParams {
  systemId: string;
  signaturesRef: React.MutableRefObject<ExtendedSystemSignature[]>;
  setSignatures: React.Dispatch<React.SetStateAction<ExtendedSystemSignature[]>>;
-  localPendingDeletions: ExtendedSystemSignature[];
+  pendingDeletionMapRef: React.MutableRefObject<Record<string, ExtendedSystemSignature>>;
 }

 export interface UsePendingDeletionParams {
  systemId: string;
-  setSignatures: React.Dispatch<React.SetStateAction<ExtendedSystemSignature[]>>;
  deletionTiming?: number;
+  setSignatures: React.Dispatch<React.SetStateAction<ExtendedSystemSignature[]>>;
+  onPendingChange?: (
+    pending: React.MutableRefObject<Record<string, ExtendedSystemSignature>>,
+    undo: () => void,
+  ) => void;
 }

 export interface UsePendingAdditionParams {
+  systemId: string;
  setSignatures: React.Dispatch<React.SetStateAction<ExtendedSystemSignature[]>>;
  deletionTiming?: number;
 }
--- a/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/usePendingAdditions.ts
+++ b/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/usePendingAdditions.ts
@@ -1,70 +0,0 @@
-import { useCallback, useRef, useState } from 'react';
-import { UsePendingAdditionParams } from './types';
-import { FINAL_DURATION_MS } from '../constants';
-import { ExtendedSystemSignature } from '@/hooks/Mapper/types';
-import { schedulePendingAdditionForSig } from '../helpers/contentHelpers';
-
-export const usePendingAdditions = ({ setSignatures, deletionTiming }: UsePendingAdditionParams) => {
-  const [pendingUndoAdditions, setPendingUndoAdditions] = useState<ExtendedSystemSignature[]>([]);
-  const pendingAdditionMapRef = useRef<Record<string, { finalUntil: number; finalTimeoutId: number }>>({});
-
-  // Use the provided deletion timing or fall back to the default
-  const finalDuration = deletionTiming !== undefined ? deletionTiming : FINAL_DURATION_MS;
-
-  const processAddedSignatures = useCallback(
-    (added: ExtendedSystemSignature[]) => {
-      if (!added.length) return;
-
-      // If duration is 0, don't show pending state
-      if (finalDuration === 0) {
-        setSignatures(prev => [
-          ...prev,
-          ...added.map(sig => ({
-            ...sig,
-            pendingAddition: false,
-          })),
-        ]);
-        return;
-      }
-
-      const now = Date.now();
-      setSignatures(prev => [
-        ...prev,
-        ...added.map(sig => ({
-          ...sig,
-          pendingAddition: true,
-          pendingUntil: now + finalDuration,
-        })),
-      ]);
-      added.forEach(sig => {
-        schedulePendingAdditionForSig(
-          sig,
-          finalDuration,
-          setSignatures,
-          pendingAdditionMapRef,
-          setPendingUndoAdditions,
-        );
-      });
-    },
-    [setSignatures, finalDuration],
-  );
-
-  const clearPendingAdditions = useCallback(() => {
-    Object.values(pendingAdditionMapRef.current).forEach(({ finalTimeoutId }) => {
-      clearTimeout(finalTimeoutId);
-    });
-    pendingAdditionMapRef.current = {};
-    setSignatures(prev =>
-      prev.map(x => (x.pendingAddition ? { ...x, pendingAddition: false, pendingUntil: undefined } : x)),
-    );
-    setPendingUndoAdditions([]);
-  }, [setSignatures]);
-
-  return {
-    pendingUndoAdditions,
-    setPendingUndoAdditions,
-    pendingAdditionMapRef,
-    processAddedSignatures,
-    clearPendingAdditions,
-  };
-};
--- a/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/usePendingDeletions.ts
+++ b/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/usePendingDeletions.ts
@@ -1,17 +1,19 @@
-import { useState, useCallback } from 'react';
+import { useCallback, useRef, useEffect } from 'react';
 import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
-import { prepareUpdatePayload, scheduleLazyDeletionTimers } from '../helpers';
+import { prepareUpdatePayload, scheduleLazyTimers } from '../helpers';
 import { UsePendingDeletionParams } from './types';
 import { FINAL_DURATION_MS } from '../constants';
 import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 import { ExtendedSystemSignature } from '@/hooks/Mapper/types';

-export function usePendingDeletions({ systemId, setSignatures, deletionTiming }: UsePendingDeletionParams) {
+export function usePendingDeletions({
+  systemId,
+  setSignatures,
+  deletionTiming,
+  onPendingChange,
+}: UsePendingDeletionParams) {
  const { outCommand } = useMapRootState();
-  const [localPendingDeletions, setLocalPendingDeletions] = useState<ExtendedSystemSignature[]>([]);
-  const [pendingDeletionMap, setPendingDeletionMap] = useState<
-    Record<string, { finalUntil: number; finalTimeoutId: number }>
-  >({});
+  const pendingDeletionMapRef = useRef<Record<string, ExtendedSystemSignature>>({});

  // Use the provided deletion timing or fall back to the default
  const finalDuration = deletionTiming !== undefined ? deletionTiming : FINAL_DURATION_MS;
@@ -37,15 +39,17 @@ export function usePendingDeletions({ systemId, setSignatures, deletionTiming }:
      const processedRemoved = removed.map(r => ({
        ...r,
        pendingDeletion: true,
-        pendingAddition: false,
        pendingUntil: now + finalDuration,
      }));
-      setLocalPendingDeletions(prev => [...prev, ...processedRemoved]);
+      pendingDeletionMapRef.current = {
+        ...pendingDeletionMapRef.current,
+        ...processedRemoved.reduce((acc: any, sig) => {
+          acc[sig.eve_id] = sig;
+          return acc;
+        }, {}),
+      };

-      outCommand({
-        type: OutCommand.updateSignatures,
-        data: prepareUpdatePayload(systemId, added, updated, []),
-      });
+      onPendingChange?.(pendingDeletionMapRef, clearPendingDeletions);

      setSignatures(prev =>
        prev.map(sig => {
@@ -56,37 +60,34 @@ export function usePendingDeletions({ systemId, setSignatures, deletionTiming }:
        }),
      );

-      scheduleLazyDeletionTimers(
+      scheduleLazyTimers(
        processedRemoved,
-        setPendingDeletionMap,
+        pendingDeletionMapRef,
        async sig => {
          await outCommand({
            type: OutCommand.updateSignatures,
            data: prepareUpdatePayload(systemId, [], [], [sig]),
          });
-          setLocalPendingDeletions(prev => prev.filter(x => x.eve_id !== sig.eve_id));
+          delete pendingDeletionMapRef.current[sig.eve_id];
          setSignatures(prev => prev.filter(x => x.eve_id !== sig.eve_id));
        },
        finalDuration,
      );
    },
-    [systemId, outCommand, setSignatures, finalDuration],
+    [systemId, outCommand, finalDuration],
  );

  const clearPendingDeletions = useCallback(() => {
-    Object.values(pendingDeletionMap).forEach(({ finalTimeoutId }) => clearTimeout(finalTimeoutId));
-    setPendingDeletionMap({});
-    setSignatures(prev =>
-      prev.map(x => (x.pendingDeletion ? { ...x, pendingDeletion: false, pendingUntil: undefined } : x)),
-    );
-    setLocalPendingDeletions([]);
-  }, [pendingDeletionMap, setSignatures]);
+    Object.values(pendingDeletionMapRef.current).forEach(({ finalTimeoutId }) => {
+      clearTimeout(finalTimeoutId);
+    });
+    pendingDeletionMapRef.current = {};
+    setSignatures(prev => prev.map(x => (x.pendingDeletion ? { ...x, pendingDeletion: false } : x)));
+    onPendingChange?.(pendingDeletionMapRef, clearPendingDeletions);
+  }, []);

  return {
-    localPendingDeletions,
-    setLocalPendingDeletions,
-    pendingDeletionMap,
-    setPendingDeletionMap,
+    pendingDeletionMapRef,
    processRemovedSignatures,
    clearPendingDeletions,
  };
--- a/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSignatureFetching.ts
+++ b/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSignatureFetching.ts
@@ -1,16 +1,15 @@
 import { useCallback } from 'react';
 import { ExtendedSystemSignature, SystemSignature } from '@/hooks/Mapper/types';
 import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
-import { prepareUpdatePayload, getActualSigs, mergeLocalPendingAdditions } from '../helpers';
+import { prepareUpdatePayload, getActualSigs, mergeLocalPending } from '../helpers';
 import { UseFetchingParams } from './types';
-import { FINAL_DURATION_MS } from '../constants';
 import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';

 export const useSignatureFetching = ({
  systemId,
  signaturesRef,
  setSignatures,
-  localPendingDeletions,
+  pendingDeletionMapRef,
 }: UseFetchingParams) => {
  const {
    data: { characters },
@@ -22,9 +21,6 @@ export const useSignatureFetching = ({
      setSignatures([]);
      return;
    }
-    if (localPendingDeletions.length) {
-      return;
-    }
    const resp = await outCommand({
      type: OutCommand.getSignatures,
      data: { system_id: systemId },
@@ -36,8 +32,8 @@ export const useSignatureFetching = ({
      character_name: characters.find(c => c.eve_id === s.character_eve_id)?.name,
    })) as ExtendedSystemSignature[];

-    setSignatures(prev => mergeLocalPendingAdditions(extended, prev));
-  }, [characters, systemId, localPendingDeletions, outCommand, setSignatures]);
+    setSignatures(() => mergeLocalPending(pendingDeletionMapRef, extended));
+  }, [characters, systemId, outCommand]);

  const handleUpdateSignatures = useCallback(
    async (newList: ExtendedSystemSignature[], updateOnly: boolean, skipUpdateUntouched?: boolean) => {
@@ -48,24 +44,12 @@ export const useSignatureFetching = ({
        skipUpdateUntouched,
      );

-      if (added.length > 0) {
-        const now = Date.now();
-        setSignatures(prev => [
-          ...prev,
-          ...added.map(a => ({
-            ...a,
-            pendingAddition: true,
-            pendingUntil: now + FINAL_DURATION_MS,
-          })),
-        ]);
-      }
-
      await outCommand({
        type: OutCommand.updateSignatures,
        data: prepareUpdatePayload(systemId, added, updated, removed),
      });
    },
-    [systemId, outCommand, signaturesRef, setSignatures],
+    [systemId, outCommand, signaturesRef],
  );

  return {
--- a/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSystemSignaturesData.ts
+++ b/assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSystemSignaturesData.ts
@@ -1,13 +1,12 @@
 import { useCallback, useEffect, useState } from 'react';
 import useRefState from 'react-usestateref';
 import { useMapEventListener } from '@/hooks/Mapper/events';
-import { Commands, ExtendedSystemSignature, SignatureKind, SystemSignature } from '@/hooks/Mapper/types';
+import { Commands, ExtendedSystemSignature, SignatureKind } from '@/hooks/Mapper/types';
 import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
 import { parseSignatures } from '@/hooks/Mapper/helpers';

-import { getActualSigs, mergeLocalPendingAdditions } from '../helpers';
+import { getActualSigs } from '../helpers';
 import { useSignatureFetching } from './useSignatureFetching';
-import { usePendingAdditions } from './usePendingAdditions';
 import { usePendingDeletions } from './usePendingDeletions';
 import { UseSystemSignaturesDataProps } from './types';
 import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
@@ -25,24 +24,18 @@ export const useSystemSignaturesData = ({
  const [signatures, setSignatures, signaturesRef] = useRefState<ExtendedSystemSignature[]>([]);
  const [selectedSignatures, setSelectedSignatures] = useState<ExtendedSystemSignature[]>([]);

-  const { localPendingDeletions, setLocalPendingDeletions, processRemovedSignatures, clearPendingDeletions } =
-    usePendingDeletions({
-      systemId,
-      setSignatures,
-      deletionTiming,
-    });
-
-  const { pendingUndoAdditions, setPendingUndoAdditions, processAddedSignatures, clearPendingAdditions } =
-    usePendingAdditions({
-      setSignatures,
-      deletionTiming,
-    });
+  const { pendingDeletionMapRef, processRemovedSignatures, clearPendingDeletions } = usePendingDeletions({
+    systemId,
+    setSignatures,
+    deletionTiming,
+    onPendingChange,
+  });

  const { handleGetSignatures, handleUpdateSignatures } = useSignatureFetching({
    systemId,
    signaturesRef,
    setSignatures,
-    localPendingDeletions,
+    pendingDeletionMapRef,
  });

  const handlePaste = useCallback(
@@ -56,18 +49,16 @@ export const useSystemSignaturesData = ({

      const currentNonPending = lazyDeleteValue
        ? signaturesRef.current.filter(sig => !sig.pendingDeletion)
-        : signaturesRef.current.filter(sig => !sig.pendingDeletion && !sig.pendingAddition);
+        : signaturesRef.current.filter(sig => !sig.pendingDeletion || !sig.pendingAddition);

      const { added, updated, removed } = getActualSigs(currentNonPending, incomingSignatures, !lazyDeleteValue, true);

-      if (added.length > 0) {
-        processAddedSignatures(added);
-      }
-
      if (removed.length > 0) {
        await processRemovedSignatures(removed, added, updated);
-      } else {
-        const resp = await outCommand({
+      }
+
+      if (updated.length !== 0 || added.length !== 0) {
+        await outCommand({
          type: OutCommand.updateSignatures,
          data: {
            system_id: systemId,
@@ -76,16 +67,6 @@ export const useSystemSignaturesData = ({
            removed: [],
          },
        });
-
-        if (resp) {
-          const finalSigs = (resp.signatures ?? []) as SystemSignature[];
-          setSignatures(prev =>
-            mergeLocalPendingAdditions(
-              finalSigs.map(x => ({ ...x })),
-              prev,
-            ),
-          );
-        }
      }

      const keepLazy = settings[SETTINGS_KEYS.KEEP_LAZY_DELETE] as boolean;
@@ -93,16 +74,7 @@ export const useSystemSignaturesData = ({
        onLazyDeleteChange?.(false);
      }
    },
-    [
-      settings,
-      signaturesRef,
-      processAddedSignatures,
-      processRemovedSignatures,
-      outCommand,
-      systemId,
-      setSignatures,
-      onLazyDeleteChange,
-    ],
+    [settings, signaturesRef, processRemovedSignatures, outCommand, systemId, onLazyDeleteChange],
  );

  const handleDeleteSelected = useCallback(async () => {
@@ -112,7 +84,7 @@ export const useSystemSignaturesData = ({

    await handleUpdateSignatures(finalList, false, true);
    setSelectedSignatures([]);
-  }, [selectedSignatures, signatures, handleUpdateSignatures]);
+  }, [selectedSignatures, signatures]);

  const handleSelectAll = useCallback(() => {
    setSelectedSignatures(signatures);
@@ -120,42 +92,7 @@ export const useSystemSignaturesData = ({

  const undoPending = useCallback(() => {
    clearPendingDeletions();
-    clearPendingAdditions();
-    setSignatures(prev =>
-      prev.map(x => (x.pendingDeletion ? { ...x, pendingDeletion: false, pendingUntil: undefined } : x)),
-    );
-
-    if (pendingUndoAdditions.length) {
-      pendingUndoAdditions.forEach(async sig => {
-        await outCommand({
-          type: OutCommand.updateSignatures,
-          data: {
-            system_id: systemId,
-            added: [],
-            updated: [],
-            removed: [sig],
-          },
-        });
-      });
-      setSignatures(prev => prev.filter(x => !pendingUndoAdditions.some(u => u.eve_id === x.eve_id)));
-      setPendingUndoAdditions([]);
-    }
-    setLocalPendingDeletions([]);
-  }, [
-    clearPendingDeletions,
-    clearPendingAdditions,
-    pendingUndoAdditions,
-    setPendingUndoAdditions,
-    setLocalPendingDeletions,
-    setSignatures,
-    outCommand,
-    systemId,
-  ]);
-
-  useEffect(() => {
-    const combined = [...localPendingDeletions, ...pendingUndoAdditions];
-    onPendingChange?.(combined, undoPending);
-  }, [localPendingDeletions, pendingUndoAdditions, onPendingChange, undoPending]);
+  }, [clearPendingDeletions]);

  useMapEventListener(event => {
    if (event.name === Commands.signaturesUpdated && String(event.data) === String(systemId)) {
@@ -167,14 +104,15 @@ export const useSystemSignaturesData = ({
  useEffect(() => {
    if (!systemId) {
      setSignatures([]);
+      undoPending();
      return;
    }
    handleGetSignatures();
-  }, [systemId, handleGetSignatures, setSignatures]);
+  }, [systemId]);

  useEffect(() => {
    onCountChange?.(signatures.length);
-  }, [signatures, onCountChange]);
+  }, [signatures]);

  return {
    signatures,