fontastic 1.3.1 → 1.4.0

package/app/package.json

@@ -5,19 +5,17 @@
     "name": "Tom Shaw",
     "email": ""
   },
-  "version": "1.3.1",
+  "version": "1.4.0",
   "main": "main.js",
   "private": true,
   "dependencies": {
-    "electron-log": "^4.4.8",
+    "electron-log": "^5.4.4",
     "electron-store": "^8.2.0",
     "mime": "^3.0.0",
-    "node-fetch": "^2.7.0",
     "node-machine-id": "^1.1.12",
     "fontkit": "^2.0.4",
     "pretty-bytes": "^5.6.0",
-    "better-sqlite3": "^12.6.2",
-    "sudo-prompt": "^9.2.1",
-    "typeorm": "^0.3.20"
+    "better-sqlite3": "^12.11.1",
+    "typeorm": "^1.0.0"
   }
 }

package/app/preload.js

@@ -0,0 +1,51 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+// NOTE: This file runs in the sandboxed preload context. It must stay
+// self-contained — sandboxed preloads cannot require local modules, so the
+// scan-progress channel name is duplicated here rather than imported.
+const SCAN_PROGRESS_PORT_CHANNEL = 'IPC_SCAN_PROGRESS_PORT';
+let nextSubscriptionId = 0;
+const subscriptions = new Map();
+// MessagePorts cannot cross the context bridge directly; forward them into
+// the isolated world through window.postMessage, which supports transferables.
+electron_1.ipcRenderer.on(SCAN_PROGRESS_PORT_CHANNEL, (event) => {
+    window.postMessage({ type: SCAN_PROGRESS_PORT_CHANNEL }, '*', event.ports);
+});
+electron_1.contextBridge.exposeInMainWorld('fontastic', {
+    versions: {
+        app: '',
+        electron: (_a = process.versions.electron) !== null && _a !== void 0 ? _a : '',
+        chrome: (_b = process.versions.chrome) !== null && _b !== void 0 ? _b : '',
+        node: (_c = process.versions.node) !== null && _c !== void 0 ? _c : '',
+    },
+    invoke: (channel, args) => electron_1.ipcRenderer.invoke(channel, args),
+    send: (channel, args) => electron_1.ipcRenderer.send(channel, args),
+    once: (channel, listener) => {
+        electron_1.ipcRenderer.once(channel, (_event, ...args) => listener(...args));
+    },
+    on: (channel, listener) => {
+        const wrapped = (_event, ...args) => listener(...args);
+        const id = ++nextSubscriptionId;
+        subscriptions.set(id, { channel, wrapped });
+        electron_1.ipcRenderer.on(channel, wrapped);
+        return id;
+    },
+    off: (subscriptionId) => {
+        const sub = subscriptions.get(subscriptionId);
+        if (sub) {
+            electron_1.ipcRenderer.removeListener(sub.channel, sub.wrapped);
+            subscriptions.delete(subscriptionId);
+        }
+    },
+    removeAllListeners: (channel) => {
+        for (const [id, sub] of subscriptions) {
+            if (sub.channel === channel) {
+                subscriptions.delete(id);
+            }
+        }
+        electron_1.ipcRenderer.removeAllListeners(channel);
+    },
+});
+//# sourceMappingURL=preload.js.map

package/app/preload.ts

@@ -0,0 +1,59 @@
+import { contextBridge, ipcRenderer, IpcRendererEvent } from 'electron';
+
+// NOTE: This file runs in the sandboxed preload context. It must stay
+// self-contained — sandboxed preloads cannot require local modules, so the
+// scan-progress channel name is duplicated here rather than imported.
+const SCAN_PROGRESS_PORT_CHANNEL = 'IPC_SCAN_PROGRESS_PORT';
+
+type Listener = (...args: unknown[]) => void;
+
+let nextSubscriptionId = 0;
+const subscriptions = new Map<number, { channel: string; wrapped: (event: IpcRendererEvent, ...args: unknown[]) => void }>();
+
+// MessagePorts cannot cross the context bridge directly; forward them into
+// the isolated world through window.postMessage, which supports transferables.
+ipcRenderer.on(SCAN_PROGRESS_PORT_CHANNEL, (event) => {
+  window.postMessage({ type: SCAN_PROGRESS_PORT_CHANNEL }, '*', event.ports);
+});
+
+contextBridge.exposeInMainWorld('fontastic', {
+  versions: {
+    app: '',
+    electron: process.versions.electron ?? '',
+    chrome: process.versions.chrome ?? '',
+    node: process.versions.node ?? '',
+  },
+
+  invoke: (channel: string, args?: unknown): Promise<unknown> => ipcRenderer.invoke(channel, args),
+
+  send: (channel: string, args?: unknown): void => ipcRenderer.send(channel, args),
+
+  once: (channel: string, listener: Listener): void => {
+    ipcRenderer.once(channel, (_event, ...args) => listener(...args));
+  },
+
+  on: (channel: string, listener: Listener): number => {
+    const wrapped = (_event: IpcRendererEvent, ...args: unknown[]) => listener(...args);
+    const id = ++nextSubscriptionId;
+    subscriptions.set(id, { channel, wrapped });
+    ipcRenderer.on(channel, wrapped);
+    return id;
+  },
+
+  off: (subscriptionId: number): void => {
+    const sub = subscriptions.get(subscriptionId);
+    if (sub) {
+      ipcRenderer.removeListener(sub.channel, sub.wrapped);
+      subscriptions.delete(subscriptionId);
+    }
+  },
+
+  removeAllListeners: (channel: string): void => {
+    for (const [id, sub] of subscriptions) {
+      if (sub.channel === channel) {
+        subscriptions.delete(id);
+      }
+    }
+    ipcRenderer.removeAllListeners(channel);
+  },
+});

package/app/types/Bridge.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Bridge.js.map

package/app/types/Bridge.ts

@@ -0,0 +1,19 @@
+/**
+ * The typed API exposed to the renderer by app/preload.ts via contextBridge.
+ * Available in the renderer as `window.fontastic`.
+ */
+export interface FontasticBridge {
+  versions: {
+    app: string;
+    electron: string;
+    chrome: string;
+    node: string;
+  };
+  invoke<T = unknown>(channel: string, args?: unknown): Promise<T>;
+  send(channel: string, args?: unknown): void;
+  once(channel: string, listener: (...args: any[]) => void): void;
+  /** Subscribes and returns a subscription id for `off()`. */
+  on(channel: string, listener: (...args: any[]) => void): number;
+  off(subscriptionId: number): void;
+  removeAllListeners(channel: string): void;
+}

package/app/types/index.js

@@ -27,4 +27,5 @@ __exportStar(require("./SmartCollection"), exports);
 __exportStar(require("./NativeThemeState"), exports);
 __exportStar(require("./SystemPreferencesState"), exports);
 __exportStar(require("./ScanProgress"), exports);
+__exportStar(require("./Bridge"), exports);
 //# sourceMappingURL=index.js.map

package/app/types/index.ts

@@ -11,3 +11,4 @@ export * from './SmartCollection';
 export * from './NativeThemeState';
 export * from './SystemPreferencesState';
 export * from './ScanProgress';
+export * from './Bridge';

package/knip.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://unpkg.com/knip@6/schema.json",
+  "entry": ["src/main.ts", "app/main.ts", "e2e/**/*.spec.ts", "scripts/*.js"],
+  "project": ["src/**/*.ts", "app/**/*.ts"],
+  "ignore": ["app/**/*.js"],
+  "ignoreDependencies": [
+    "@fontsource-variable/inter",
+    "material-icons",
+    "electron-debug",
+    "electron-reloader",
+    "@angular-eslint/schematics",
+    "@angular-eslint/builder",
+    "@angular/language-service",
+    "@vitest/browser-playwright",
+    "@vitest/coverage-v8",
+    "@vitest/ui"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fontastic",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Fontastic is an Electron-based font management and cataloging application built for organizing, browsing, and inspecting font libraries.",
   "homepage": "https://github.com/tomshaw/fontastic",
   "private": false,
@@ -12,7 +12,7 @@
     "angular",
     "angular 21",
     "electron",
-    "electron 40",
+    "electron 43",
     "nodejs",
     "typescript",
     "vitest",
@@ -51,72 +51,63 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@angular/cdk": "21.2.1",
-    "@angular/common": "21.2.0",
-    "@angular/compiler": "21.2.0",
-    "@angular/core": "21.2.0",
-    "@angular/forms": "21.2.0",
-    "@angular/language-service": "21.2.0",
-    "@angular/platform-browser": "21.2.0",
-    "@angular/platform-browser-dynamic": "21.2.0",
-    "@angular/router": "21.2.0",
+    "@angular/common": "21.2.17",
+    "@angular/compiler": "21.2.17",
+    "@angular/core": "21.2.17",
+    "@angular/forms": "21.2.17",
+    "@angular/platform-browser": "21.2.17",
+    "@angular/router": "21.2.17",
     "@fontsource-variable/inter": "5.2.8",
-    "electron-store": "11.0.2",
-    "fontkit": "2.0.4",
     "material-icons": "1.13.14",
     "rxjs": "7.8.2",
-    "tslib": "2.8.1",
-    "zone.js": "0.16.1"
+    "tslib": "2.8.1"
   },
   "devDependencies": {
-    "@angular-eslint/builder": "21.2.0",
-    "@angular-eslint/eslint-plugin": "21.2.0",
-    "@angular-eslint/eslint-plugin-template": "21.2.0",
-    "@angular-eslint/schematics": "21.2.0",
-    "@angular-eslint/template-parser": "21.2.0",
-    "@angular/build": "21.2.0",
-    "@angular/cli": "21.2.0",
-    "@angular/compiler-cli": "21.2.0",
-    "@ngx-translate/core": "17.0.0",
-    "@ngx-translate/http-loader": "17.0.0",
-    "@playwright/test": "1.58.2",
-    "@tailwindcss/postcss": "4.2.1",
-    "@types/node": "24.10.15",
-    "@typescript-eslint/eslint-plugin": "8.56.1",
-    "@typescript-eslint/parser": "8.56.1",
-    "@vitest/browser-playwright": "4.0.18",
-    "@vitest/coverage-v8": "4.0.18",
-    "@vitest/ui": "4.0.18",
-    "electron": "40.6.1",
-    "electron-builder": "26.8.1",
+    "@angular-eslint/builder": "21.4.0",
+    "@angular-eslint/eslint-plugin": "21.4.0",
+    "@angular-eslint/eslint-plugin-template": "21.4.0",
+    "@angular-eslint/schematics": "21.4.0",
+    "@angular-eslint/template-parser": "21.4.0",
+    "@angular/build": "21.2.18",
+    "@angular/cli": "21.2.18",
+    "@angular/compiler-cli": "21.2.17",
+    "@angular/language-service": "21.2.17",
+    "@eslint/js": "10.0.1",
+    "@ngx-translate/core": "18.0.0",
+    "@ngx-translate/http-loader": "18.0.0",
+    "@playwright/test": "1.61.1",
+    "@tailwindcss/postcss": "4.3.2",
+    "@types/node": "24.13.2",
+    "@typescript-eslint/eslint-plugin": "8.62.1",
+    "@typescript-eslint/parser": "8.62.1",
+    "@vitest/browser-playwright": "4.1.9",
+    "@vitest/coverage-v8": "4.1.9",
+    "@vitest/ui": "4.1.9",
+    "electron": "43.0.0",
+    "electron-builder": "26.15.3",
     "electron-debug": "4.1.0",
     "electron-reloader": "1.2.3",
-    "eslint": "9.39.1",
+    "eslint": "10.6.0",
     "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-jsdoc": "62.7.1",
-    "eslint-plugin-prefer-arrow": "1.2.3",
-    "globals": "17.4.0",
+    "globals": "17.7.0",
     "husky": "9.1.7",
-    "jsdom": "28.1.0",
-    "knip": "5.85.0",
-    "lint-staged": "16.3.2",
+    "jsdom": "29.1.1",
+    "knip": "6.24.0",
+    "lint-staged": "17.0.8",
     "npm-run-all": "4.1.5",
-    "playwright": "1.58.2",
-    "postcss": "8.5.7",
-    "prettier": "3.8.1",
-    "tailwindcss": "4.2.1",
-    "ts-node": "10.9.2",
+    "playwright": "1.61.1",
+    "postcss": "8.5.16",
+    "prettier": "3.9.4",
+    "tailwindcss": "4.3.2",
     "typescript": "5.9.3",
-    "vitest": "4.0.18",
-    "wait-on": "9.0.4",
-    "webdriver-manager": "13.0.2"
+    "vitest": "4.1.9",
+    "wait-on": "9.0.10"
   },
   "engines": {
     "node": ">= 22.12.0 || >= 24.0.0",
-    "typescript": ">= 5.8.0 < 5.9.0"
+    "typescript": ">= 5.9.0 < 6.0.0"
   },
   "browserslist": [
-    "chrome 140"
+    "chrome 150"
   ]
 }

package/src/app/app.component.spec.ts

@@ -1,6 +1,6 @@
 import { TestBed } from '@angular/core/testing';
 import { AppComponent } from './app.component';
-import { TranslateModule } from '@ngx-translate/core';
+import { provideTranslateService } from '@ngx-translate/core';
 import { ElectronService } from './core/services';
 import { provideRouter } from '@angular/router';
 
@@ -8,8 +8,8 @@ describe('AppComponent', () => {
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [],
-      imports: [AppComponent, TranslateModule.forRoot()],
-      providers: [provideRouter([]), ElectronService],
+      imports: [AppComponent],
+      providers: [provideRouter([]), provideTranslateService(), ElectronService],
     }).compileComponents();
   });
 

package/src/app/app.component.ts

@@ -1,6 +1,5 @@
 import { Component, afterNextRender, inject } from '@angular/core';
 import { ElectronService } from './core/services';
-import { TranslateService } from '@ngx-translate/core';
 import { APP_CONFIG } from '../environments/environment';
 import { RouterOutlet } from '@angular/router';
 
@@ -12,22 +11,10 @@ import { RouterOutlet } from '@angular/router';
 })
 export class AppComponent {
   private electronService = inject(ElectronService);
-  private translate = inject(TranslateService);
 
   constructor() {
-    const electronService = this.electronService;
-
-    this.translate.setDefaultLang('en');
-    console.log('APP_CONFIG', APP_CONFIG);
-
-    if (electronService.isElectron) {
-      console.log(process.env);
-      console.log('Run in electron');
-      console.log('Electron ipcRenderer', this.electronService.ipcRenderer);
-      console.log('NodeJS childProcess', this.electronService.childProcess);
-      void this.electronService.ipcRenderer.invoke('app:get-version').then((v) => console.log('App version:', v));
-    } else {
-      console.log('Run in browser');
+    if (!APP_CONFIG.production) {
+      console.log('APP_CONFIG', APP_CONFIG, this.electronService.isElectron ? 'Run in electron' : 'Run in browser');
     }
 
     afterNextRender(() => {

package/src/app/core/services/database/database.service.ts

@@ -93,6 +93,12 @@ export class DatabaseService {
     this.fetchCurrentPage();
   }
 
+  private static readonly filterWhereMap: Record<string, { key: string; value: number }[]> = {
+    all: [],
+    favorites: [{ key: 'store.favorite', value: 1 }],
+    system: [{ key: 'store.system', value: 1 }],
+  };
+
   selectFilter(filter: string) {
     this.parentId.set(null);
     this.collectionId.set(null);
@@ -101,13 +107,7 @@ export class DatabaseService {
     this.activeSmartCollectionId.set(null);
     this.currentPage.set(1);
 
-    const whereMap: Record<string, { key: string; value: number }[]> = {
-      all: [],
-      favorites: [{ key: 'store.favorite', value: 1 }],
-      system: [{ key: 'store.system', value: 1 }],
-    };
-
-    this.fetchCurrentPage({ where: whereMap[filter] ?? [] });
+    this.fetchCurrentPage({ where: DatabaseService.filterWhereMap[filter] ?? [] });
   }
 
   goToPage(page: number) {
@@ -161,12 +161,7 @@ export class DatabaseService {
     if (collectionId) {
       options.collectionId = collectionId;
     } else if (filter) {
-      const whereMap: Record<string, { key: string; value: number }[]> = {
-        all: [],
-        favorites: [{ key: 'store.favorite', value: 1 }],
-        system: [{ key: 'store.system', value: 1 }],
-      };
-      options.where = whereMap[filter] ?? [];
+      options.where = DatabaseService.filterWhereMap[filter] ?? [];
     }
 
     this.storeFetch(options);
@@ -185,7 +180,6 @@ export class DatabaseService {
 
       this.collections.set(collections);
       this.smartCollections.set(smartCollections);
-      console.log('System Boot:', collections);
 
       if (savedSortColumn) {
         this.sortColumn.set(savedSortColumn);
@@ -258,7 +252,6 @@ export class DatabaseService {
     return this.track(
       this.message.collectionCreate(args).then((result) => {
         this.collections.set(result);
-        console.log('Collection Created:', result);
         return result;
       }),
     );

package/src/app/core/services/electron/electron.service.ts

@@ -1,62 +1,21 @@
 import { Injectable } from '@angular/core';
-
-// If you import a module but never use any of the imported values other than as TypeScript types,
-// the resulting javascript file will look as if you never imported the module at all.
-import { ipcRenderer, webFrame } from 'electron';
-import * as childProcess from 'child_process';
-import * as fs from 'fs';
+import type { FontasticBridge } from '@main/types';
 
 @Injectable({
   providedIn: 'root',
 })
 export class ElectronService {
-  ipcRenderer!: typeof ipcRenderer;
-  webFrame!: typeof webFrame;
-  childProcess!: typeof childProcess;
-  fs!: typeof fs;
+  /** The typed IPC bridge exposed by the preload script, or undefined in a plain browser. */
+  readonly bridge?: FontasticBridge = (window as any).fontastic;
 
   /** Resolves when the main process signals that IPC handlers and DB are ready. */
   readonly ready: Promise<void>;
 
   constructor() {
-    if (this.isElectron) {
-      this.ipcRenderer = (window as any).require('electron').ipcRenderer;
-      this.webFrame = (window as any).require('electron').webFrame;
-
-      this.fs = (window as any).require('fs');
-
-      this.childProcess = (window as any).require('child_process');
-      this.childProcess.exec('node -v', (error, stdout, stderr) => {
-        if (error) {
-          console.error(`error: ${error.message}`);
-          return;
-        }
-        if (stderr) {
-          console.error(`stderr: ${stderr}`);
-          return;
-        }
-        console.log(`stdout:\n${stdout}`);
-      });
-
-      // Notes :
-      // * A NodeJS's dependency imported with 'window.require' MUST BE present in `dependencies` of both `app/package.json`
-      // and `package.json (root folder)` in order to make it work here in Electron's Renderer process (src folder)
-      // because it will loaded at runtime by Electron.
-      // * A NodeJS's dependency imported with TS module import (ex: import { Dropbox } from 'dropbox') CAN only be present
-      // in `dependencies` of `package.json (root folder)` because it is loaded during build phase and does not need to be
-      // in the final bundle. Reminder : only if not used in Electron's Main process (app folder)
-
-      // If you want to use a NodeJS 3rd party deps in Renderer process,
-      // ipcRenderer.invoke can serve many common use cases.
-      // https://www.electronjs.org/docs/latest/api/ipc-renderer#ipcrendererinvokechannel-args
-
-      this.ready = this.ipcRenderer.invoke('app:ready');
-    } else {
-      this.ready = Promise.resolve();
-    }
+    this.ready = this.bridge ? this.bridge.invoke<void>('app:ready') : Promise.resolve();
   }
 
   get isElectron(): boolean {
-    return !!(window && window.process && window.process.type);
+    return !!this.bridge;
   }
 }

package/src/app/core/services/font-loader/font-loader.service.ts

@@ -0,0 +1,60 @@
+import { Injectable } from '@angular/core';
+import type { Store } from '@main/database/entity/Store.schema';
+
+/**
+ * Registers font files with the document on demand. Elements are observed
+ * with a shared IntersectionObserver so a font is only fetched once its
+ * preview row is about to scroll into view.
+ */
+@Injectable({ providedIn: 'root' })
+export class FontLoaderService {
+  private registered = new Set<string>();
+  private pending = new WeakMap<Element, Store>();
+
+  private observer = new IntersectionObserver(
+    (entries) => {
+      for (const entry of entries) {
+        if (!entry.isIntersecting) continue;
+        const store = this.pending.get(entry.target);
+        this.unobserve(entry.target);
+        if (store) {
+          this.register(store);
+        }
+      }
+    },
+    { rootMargin: '200px' },
+  );
+
+  observe(element: Element, store: Store) {
+    if (this.registered.has(this.key(store))) return;
+    this.pending.set(element, store);
+    this.observer.observe(element);
+  }
+
+  unobserve(element: Element) {
+    this.observer.unobserve(element);
+    this.pending.delete(element);
+  }
+
+  register(store: Store) {
+    const key = this.key(store);
+    if (this.registered.has(key)) return;
+
+    const url = `font://${store.file_path}`;
+    const fontFace = new FontFace(store.full_name || store.font_family, `url('${url}')`);
+
+    fontFace
+      .load()
+      .then((loaded) => {
+        document.fonts.add(loaded);
+        this.registered.add(key);
+      })
+      .catch((err) => {
+        console.warn(`Failed to load font: ${store.file_name}`, err);
+      });
+  }
+
+  private key(store: Store): string {
+    return `${store.id}-${store.file_path}`;
+  }
+}

package/src/app/core/services/index.ts

@@ -1,4 +1,5 @@
 export * from './electron/electron.service';
+export * from './font-loader/font-loader.service';
 export * from './database/database.service';
 export * from './message/message.service';
 export * from './news/news.service';

package/src/app/core/services/message/message.service.ts

@@ -13,47 +13,43 @@ import type { SmartCollection } from '@main/database/entity/SmartCollection.sche
 export class MessageService {
   private electron = inject(ElectronService);
 
+  /** Maps registered listeners to their bridge subscription ids. */
+  private subscriptions = new Map<(...args: any[]) => void, number>();
+
   // Low-level IPC
 
-  on(channel: string, listener: (...args: any[]) => void): Electron.IpcRenderer | undefined {
-    if (this.electron.isElectron) {
-      return this.electron.ipcRenderer.on(channel, listener);
+  on(channel: string, listener: (...args: any[]) => void): void {
+    const id = this.electron.bridge?.on(channel, listener);
+    if (id !== undefined) {
+      this.subscriptions.set(listener, id);
     }
-    return undefined;
   }
 
-  once(channel: string, listener: (...args: any[]) => void): Electron.IpcRenderer | undefined {
-    if (this.electron.isElectron) {
-      return this.electron.ipcRenderer.once(channel, listener);
-    }
-    return undefined;
+  once(channel: string, listener: (...args: any[]) => void): void {
+    this.electron.bridge?.once(channel, listener);
   }
 
   send(channel: string, args?: any): void {
-    if (this.electron.isElectron) {
-      this.electron.ipcRenderer.send(channel, args);
-    }
+    this.electron.bridge?.send(channel, args);
   }
 
   invoke<T = any>(channel: string, args?: any): Promise<T> {
-    if (this.electron.isElectron) {
-      return this.electron.ipcRenderer.invoke(channel, args);
+    if (this.electron.bridge) {
+      return this.electron.bridge.invoke<T>(channel, args);
     }
     return Promise.reject('Not running in Electron');
   }
 
-  removeListener(channel: string, listener: (...args: any[]) => void): Electron.IpcRenderer | undefined {
-    if (this.electron.isElectron) {
-      return this.electron.ipcRenderer.removeListener(channel, listener);
+  removeListener(channel: string, listener: (...args: any[]) => void): void {
+    const id = this.subscriptions.get(listener);
+    if (id !== undefined) {
+      this.electron.bridge?.off(id);
+      this.subscriptions.delete(listener);
     }
-    return undefined;
   }
 
-  removeAllListeners(channel: string): Electron.IpcRenderer | undefined {
-    if (this.electron.isElectron) {
-      return this.electron.ipcRenderer.removeAllListeners(channel);
-    }
-    return undefined;
+  removeAllListeners(channel: string): void {
+    this.electron.bridge?.removeAllListeners(channel);
   }
 
   // System
@@ -104,10 +100,6 @@ export class MessageService {
 
   // Font Manager
 
-  exec(args: any): Promise<any> {
-    return this.invoke(ChannelType.IPC_EXEC_CMD, args);
-  }
-
   systemAuthenticate(args: any): Promise<any> {
     return this.invoke(ChannelType.IPC_AUTH_USER, args);
   }