refactor: clean repetitive boilerplate code at project entrypoint

src/core/types/cleanupPositions.ts

@@ -0,0 +1,24 @@
+export enum CleanupPositions {
+  RemoveUnhandledRejectionEventListener,
+  RemoveErrorEventListener,
+  StopWatermarkRemover,
+  DestroyFolderManagerInstance,
+  DestroyPromptManagerInstance,
+  DestroySlashPromptFeatureInstance,
+  CleanupQuoteReply,
+  CleanupInputVimMode,
+  CleanupSendBehavior,
+  CleanupDraftSave,
+  CleanupFork,
+  CleanupGemsSidebar,
+  CleanupResponseCompleteNotification,
+  CleanupEdgeFinalVersionNotice,
+  CleanupPluginHost,
+  CleanupBrandTheme,
+  CleanupRemoteAnnouncements,
+  CleanupStorageQuotaWarning,
+  CleanupAccountContextBridge,
+  CleanupCodeBlockCollapse,
+  CleanupUsageStatus,
+  RemoveStorageOnChangedListener,
+}

src/core/utils/__tests__/cleanupManager.test.ts

@@ -0,0 +1,119 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CleanupManager } from '@/core/utils/cleanupManager';
+
+enum Sequence {
+  First,
+  Second,
+  Third,
+}
+
+describe('willCleanUp tests module', () => {
+  let cleanupManager: CleanupManager;
+
+  beforeEach(() => {
+    cleanupManager = new CleanupManager();
+  });
+
+  it('can store registered cleanup functions', () => {
+    const function1 = () => {};
+    const function2 = () => {};
+
+    cleanupManager.registerCleanupFunction(function1);
+    cleanupManager.registerCleanupFunction(function2);
+    cleanupManager.registerCleanupFunction(function2); // won't store duplicate functions
+
+    expect(cleanupManager.list()).toEqual([
+      {
+        pos: -1,
+        func: function1,
+      },
+      {
+        pos: -1,
+        func: function2,
+      },
+    ]);
+  });
+
+  it('can return registered functions as-is', () => {
+    const function1 = () => {};
+
+    expect(cleanupManager.registerCleanupFunctionAndReturnIt(function1)).toBe(function1);
+  });
+
+  it('can execute registered cleanup functions at correct time', () => {
+    const function1 = vi.fn();
+
+    cleanupManager.registerCleanupFunction(function1);
+
+    expect(function1).not.toHaveBeenCalled();
+
+    cleanupManager.executeCleanups();
+
+    expect(function1).toHaveBeenCalled();
+    expect(function1).toHaveBeenCalledTimes(1);
+
+    cleanupManager.executeCleanups(); // no duplicate call
+
+    expect(function1).toHaveBeenCalledTimes(1);
+  });
+
+  it('can release stored cleanup functions at correct time', () => {
+    const function1 = () => {};
+
+    cleanupManager.registerCleanupFunction(function1);
+
+    expect(cleanupManager.list()).not.toEqual([]);
+
+    cleanupManager.executeCleanups();
+
+    expect(cleanupManager.list()).toEqual([]);
+  });
+
+  it('can safely handle cleanup functions that throws an error', () => {
+    const function1 = () => {
+      throw Error();
+    };
+    const function2 = vi.fn();
+
+    cleanupManager.registerCleanupFunction(function1);
+    cleanupManager.registerCleanupFunction(function2);
+
+    expect(() => cleanupManager.executeCleanups()).toThrow();
+
+    expect(function2).toHaveBeenCalled();
+    expect(function2).toHaveBeenCalledTimes(1);
+    expect(cleanupManager.list()).toEqual([]);
+  });
+
+  it('can call functions in correct sequence', () => {
+    const function1 = vi.fn();
+    const function2 = vi.fn();
+    const function3 = vi.fn();
+
+    cleanupManager.registerCleanupFunction(function3, Sequence.Third);
+    cleanupManager.registerCleanupFunction(function2, Sequence.Second);
+    cleanupManager.registerCleanupFunction(function1, Sequence.First);
+
+    cleanupManager.executeCleanups();
+
+    expect(function2).toHaveBeenCalledAfter(function1);
+    expect(function3).toHaveBeenCalledAfter(function2);
+  });
+
+  it('can withdraw functions by position number', () => {
+    const function1 = vi.fn();
+    const function2 = vi.fn();
+    const function3 = vi.fn();
+
+    cleanupManager.registerCleanupFunction(function3, Sequence.Third);
+    cleanupManager.registerCleanupFunction(function2, Sequence.Second);
+    cleanupManager.registerCleanupFunction(function1, Sequence.First);
+
+    cleanupManager.withdrawCleanupFunctionsByPositionNumber(Sequence.Second);
+
+    expect(cleanupManager.list().some((cleanups) => cleanups.func === function1)).toBe(true);
+    expect(cleanupManager.list().some((cleanups) => cleanups.func === function2)).toBe(false);
+    expect(cleanupManager.list().some((cleanups) => cleanups.func === function3)).toBe(true);
+  });
+});

src/core/utils/cleanupManager.ts

@@ -0,0 +1,78 @@
+/**
+ * A class that manages and executes cleanup functions in code entrypoint.
+ */
+export class CleanupManager {
+  private cleanups: Array<Cleanup> = [];
+
+  constructor() {}
+
+  /**
+   * Register a cleanup function waited to be called.
+   * @param func A function that does cleanup operation when called.
+   * @param pos A number (preferably defined by Enum) that indicates the position of the
+   *            cleanup function. The lower the number, the earlier the function would be called.
+   */
+  registerCleanupFunction(func: () => void, pos: number = -1): void {
+    if (this.cleanups.some((cleanup) => cleanup.func === func)) return;
+    this.cleanups.push({
+      pos: pos,
+      func: func,
+    });
+  }
+
+  /**
+   * Register a cleanup function, and return the function as-is.
+   * @param func
+   * @param pos
+   */
+  registerCleanupFunctionAndReturnIt(func: () => void, pos: number = -1): () => void {
+    this.registerCleanupFunction(func, pos);
+    return func;
+  }
+
+  /**
+   * Remove any cleanup functions associated with the given position number.
+   * @param pos Position number for functions which will be removed.
+   */
+  withdrawCleanupFunctionsByPositionNumber(pos: number): void {
+    this.cleanups = this.cleanups.filter((cleanup) => cleanup.pos != pos);
+  }
+
+  /**
+   * [debug] return a readonly list containing stored cleanup functions.
+   */
+  list(): Array<Cleanup> {
+    return [...this.cleanups] as const;
+  }
+
+  /**
+   * Call all functions registered by `registerCleanupFunction` functions,
+   * and clear their references.
+   *
+   * If any cleanup functions throws an error, other functions will execute normally.
+   * Then, the last recorded error will be re-thrown.
+   */
+  executeCleanups(): void {
+    let error: unknown = null;
+
+    this.cleanups
+      .sort((a, b) => {
+        return a.pos - b.pos;
+      })
+      .forEach((it) => {
+        try {
+          it.func();
+        } catch (e) {
+          error = e;
+        }
+      });
+    this.cleanups = [];
+
+    if (error) throw error;
+  }
+}
+
+interface Cleanup {
+  pos: number;
+  func: () => void;
+}