Skip to content

Build your personal knowledge base with Trilium Notes

13.6 KB
Raw Blame
import type {
    BackupPassphraseChange,
    BackupPassphraseStatus,
    ElectronApi,
    ElectronContextMenuParams,
    NativeImportOptions,
    OneNoteLoginResult,
    RendererStartupMetric,
    TranscriptionState,
    TranscriptSource
} from "@triliumnext/commons";
import { contextBridge, ipcRenderer, webFrame, webUtils } from "electron";

contextBridge.exposeInMainWorld("electronApi", {
    window: {
        // Zoom
        setZoomFactor(factor: number) {
            webFrame.setZoomFactor(factor);
        },
        getZoomFactor(): number {
            return webFrame.getZoomFactor();
        },

        // Theme
        setNativeThemeSource(source: "system" | "light" | "dark") {
            ipcRenderer.send("set-native-theme-source", source);
        },

        // Title bar
        setTitleBarOverlay(options: { color: string; symbolColor: string; height?: number }) {
            ipcRenderer.send("set-title-bar-overlay", options);
        },
        setWindowButtonPosition(position: { x: number; y: number }) {
            ipcRenderer.send("set-window-button-position", position);
        },

        // Full screen
        onEnterFullScreen(callback: () => void) {
            ipcRenderer.on("enter-full-screen", () => callback());
        },
        onLeaveFullScreen(callback: () => void) {
            ipcRenderer.on("leave-full-screen", () => callback());
        },
        isFullScreen(): boolean {
            return ipcRenderer.sendSync("is-full-screen");
        },
        setFullScreen(enabled: boolean) {
            ipcRenderer.send("set-full-screen", enabled);
        },

        // Window state
        minimizeWindow() {
            ipcRenderer.send("minimize-window");
        },
        maximizeWindow() {
            ipcRenderer.send("maximize-window");
        },
        unmaximizeWindow() {
            ipcRenderer.send("unmaximize-window");
        },
        isMaximized(): boolean {
            return ipcRenderer.sendSync("is-maximized");
        },
        closeWindow() {
            ipcRenderer.send("close-window");
        },
        isAlwaysOnTop(): boolean {
            return ipcRenderer.sendSync("is-always-on-top");
        },
        setAlwaysOnTop(enabled: boolean) {
            ipcRenderer.send("set-always-on-top", enabled);
        },
        toggleDevTools() {
            ipcRenderer.send("toggle-dev-tools");
        },
        isDevToolsDocked(): boolean {
            return ipcRenderer.sendSync("is-dev-tools-docked");
        },

        // App lifecycle
        reloadAllWindows() {
            ipcRenderer.send("reload-all-windows");
        },
        restartApp() {
            ipcRenderer.send("restart-app");
        },
        toggleAllWindows() {
            ipcRenderer.send("toggle-all-windows");
        },
        clearCache(): Promise<void> {
            return ipcRenderer.invoke("clear-cache");
        },
        showWindow() {
            ipcRenderer.send("show-window");
        },
        reportStartupMetric(metric: RendererStartupMetric) {
            ipcRenderer.send("report-startup-metric", metric);
        },

        // Background effects
        setBackgroundMaterial(material: string) {
            ipcRenderer.send("set-background-material", material);
        },
        setVibrancy(vibrancy: string) {
            ipcRenderer.send("set-vibrancy", vibrancy);
        },

        // Main → renderer events
        onGlobalShortcut(callback: (actionName: string) => void) {
            ipcRenderer.on("globalShortcut", (_event, actionName) => callback(actionName));
        },
        onOpenInSameTab(callback: (noteId: string) => void) {
            ipcRenderer.on("openInSameTab", (_event, noteId) => callback(noteId));
        },
        onDevToolsDockChanged(callback: (docked: boolean) => void) {
            ipcRenderer.on("dev-tools-dock-changed", (_event, docked: boolean) => callback(docked));
        }
    },

    clipboard: {
        copyImageToClipboard(buffer: Uint8Array) {
            ipcRenderer.send("copy-image-to-clipboard", buffer);
        },
        readText() {
            return ipcRenderer.invoke("read-clipboard-text");
        },
        readHTML() {
            return ipcRenderer.invoke("read-clipboard-html");
        }
    },

    shell: {
        openExternal(url: string) {
            ipcRenderer.send("open-external", url);
        },
        openPath(path: string): Promise<string> {
            return ipcRenderer.invoke("open-path", path);
        },
        showItemInFolder(path: string) {
            ipcRenderer.send("show-item-in-folder", path);
        },
        openFileUrl(fileUrl: string): Promise<string> {
            return ipcRenderer.invoke("open-file-url", fileUrl);
        },
        downloadURL(url: string) {
            ipcRenderer.send("download-url", url);
        },
        openCustom(filePath: string): Promise<boolean> {
            return ipcRenderer.invoke("open-custom", filePath);
        }
    },

    contextMenu: {
        onContextMenu(callback: (params: ElectronContextMenuParams) => void) {
            ipcRenderer.on("context-menu", (_event, params: ElectronContextMenuParams) => callback(params));
        },
        webContentsAction(action: "cut" | "copy" | "paste" | "pasteAndMatchStyle" | "insertText", text?: string) {
            ipcRenderer.send("web-contents-action", action, text);
        }
    },

    spellcheck: {
        addWordToDictionary(word: string) {
            ipcRenderer.send("add-word-to-dictionary", word);
        },
        getAvailableSpellCheckerLanguages(): string[] {
            return ipcRenderer.sendSync("get-available-spellchecker-languages");
        },
        setSpellCheckerLanguages(languageCodes: string[]) {
            ipcRenderer.send("set-spellchecker-languages", languageCodes);
        },
        setSpellCheckerEnabled(enabled: boolean) {
            ipcRenderer.send("set-spellchecker-enabled", enabled);
        }
    },

    systemIntegration: {
        reloadTray() {
            ipcRenderer.send("reload-tray");
        },
        reapplyLaunchOnStartup() {
            ipcRenderer.send("reapply-launch-on-startup");
        }
    },

    printing: {
        sendPrintProgress(progress: number) {
            ipcRenderer.send("print-progress", progress);
        },
        onPrintProgress(callback: (data: { progress: number; action: string }) => void) {
            ipcRenderer.on("print-progress", (_event, data) => callback(data));
        },
        onPrintDone(callback: (printReport: unknown, liveJobId?: number) => void) {
            ipcRenderer.on("print-done", (_event, printReport, liveJobId) => callback(printReport, liveJobId));
        },
        removePrintListeners() {
            ipcRenderer.removeAllListeners("print-progress");
            ipcRenderer.removeAllListeners("print-done");
        },
        getPrinters(): Promise<unknown[]> {
            return ipcRenderer.invoke("get-printers");
        },
        exportAsPdfPreview(opts: Record<string, unknown>) {
            ipcRenderer.send("export-as-pdf-preview", opts);
        },
        onExportAsPdfPreviewResult(callback: (result: { buffer?: Uint8Array; error?: string; requestId?: number }) => void) {
            ipcRenderer.on("export-as-pdf-preview-result", (_event, result) => callback(result));
        },
        removeExportAsPdfPreviewResultListener() {
            ipcRenderer.removeAllListeners("export-as-pdf-preview-result");
        },
        savePdf(data: { title: string; buffer: Uint8Array }) {
            ipcRenderer.send("save-pdf", data);
        },
        printFromPreview(opts: Record<string, unknown>) {
            ipcRenderer.send("print-from-preview", opts);
        }
    },

    nativeExport: {
        exportSubtreeToFile(opts: { branchId: string; format: string; title: string; taskId: string }) {
            return ipcRenderer.invoke("export-subtree-to-file", opts);
        }
    },

    nativeImport: {
        pickFiles() {
            return ipcRenderer.invoke("import-pick-files");
        },
        grantDroppedFiles(files: File[]) {
            // Resolve each dropped File to its on-disk path here in the preload: getPathForFile returns a
            // real path only for a genuinely user-supplied file (empty for anything a script built), so the
            // File is the capability. Only the resolved paths cross to the main process — the path-accepting
            // channel is never exposed to the renderer, so a script can't smuggle in an arbitrary path.
            const paths = files.map((file) => webUtils.getPathForFile(file)).filter((path) => !!path);
            return ipcRenderer.invoke("import-grant-dropped", paths);
        },
        importFromToken(opts: { token: string; parentNoteId: string; taskId: string; options: NativeImportOptions; last: boolean; format?: string }) {
            return ipcRenderer.invoke("import-from-token", opts);
        }
    },

    dialog: {
        pickDirectory(opts?: { defaultPath?: string }) {
            return ipcRenderer.invoke("dialog-pick-directory", opts);
        },
        confirmStartOver(): Promise<boolean> {
            return ipcRenderer.invoke("dialog-confirm-start-over");
        }
    },

    restore: {
        pickBackup() {
            return ipcRenderer.invoke("restore-pick-backup");
        }
    },

    transcription: {
        isSupported() {
            return ipcRenderer.invoke("transcription-is-supported");
        },
        start(noteId: string) {
            return ipcRenderer.invoke("transcription-start", noteId);
        },
        stop() {
            return ipcRenderer.invoke("transcription-stop");
        },
        getState() {
            return ipcRenderer.invoke("transcription-get-state");
        },
        renameSpeaker(attachmentId: string, key: string, name: string) {
            return ipcRenderer.invoke("transcription-rename-speaker", attachmentId, key, name);
        },
        getRecordingsDirectory() {
            return ipcRenderer.invoke("transcription-get-recordings-directory");
        },
        onStateChanged(callback: (state: TranscriptionState) => void) {
            const listener = (_event: unknown, state: TranscriptionState) => callback(state);
            ipcRenderer.on("transcription-state", listener);
            return () => ipcRenderer.removeListener("transcription-state", listener);
        },
        onLevel(callback: (source: TranscriptSource, level: number) => void) {
            const listener = (_event: unknown, source: TranscriptSource, level: number) =>
                callback(source, level);
            ipcRenderer.on("transcription-level", listener);
            return () => ipcRenderer.removeListener("transcription-level", listener);
        }
    },

    ws: {
        // Renderer → main process. Mirror channel name with the server-side
        // IpcMessagingProvider constants.
        send(message: unknown) {
            ipcRenderer.send("trilium-ws-from-renderer", message);
        },
        onMessage(callback: (message: unknown) => void) {
            const listener = (_event: unknown, message: unknown) => callback(message);
            ipcRenderer.on("trilium-ws-message", listener);
            return () => ipcRenderer.removeListener("trilium-ws-message", listener);
        }
    },

    navigation: {
        clearNavigationHistory() {
            ipcRenderer.send("clear-navigation-history");
        },
        navigationCanGoBack(): boolean {
            return ipcRenderer.sendSync("navigation-history", "canGoBack");
        },
        navigationCanGoForward(): boolean {
            return ipcRenderer.sendSync("navigation-history", "canGoForward");
        },
        navigationGetAllEntries(): Array<{ url: string; title: string }> {
            return ipcRenderer.sendSync("navigation-history", "getAllEntries");
        },
        navigationGetActiveIndex(): number {
            return ipcRenderer.sendSync("navigation-history", "getActiveIndex");
        },
        navigationLength(): number {
            return ipcRenderer.sendSync("navigation-history", "length");
        },
        navigationGoToIndex(index: number) {
            ipcRenderer.send("navigation-history-go-to-index", index);
        },
        onDidNavigate(callback: () => void) {
            ipcRenderer.on("did-navigate", () => callback());
        },
        onDidNavigateInPage(callback: () => void) {
            ipcRenderer.on("did-navigate-in-page", () => callback());
        },
        removeDidNavigateListeners() {
            ipcRenderer.removeAllListeners("did-navigate");
            ipcRenderer.removeAllListeners("did-navigate-in-page");
        }
    },

    security: {
        setBackendScriptingEnabled(enabled: boolean): Promise<boolean> {
            return ipcRenderer.invoke("security-set-backend-scripting", enabled);
        },
        setSqlConsoleEnabled(enabled: boolean): Promise<boolean> {
            return ipcRenderer.invoke("security-set-sql-console", enabled);
        },
        setLanAccessEnabled(enabled: boolean): Promise<boolean> {
            return ipcRenderer.invoke("security-set-lan-access", enabled);
        }
    },

    backupPassphrase: {
        getStatus(): Promise<BackupPassphraseStatus> {
            return ipcRenderer.invoke("backup-passphrase-status");
        },
        // No getter by design: the plaintext passphrase never comes back to the renderer.
        set(passphrase: string): Promise<BackupPassphraseChange> {
            return ipcRenderer.invoke("backup-passphrase-set", passphrase);
        },
        clear(): Promise<BackupPassphraseChange> {
            return ipcRenderer.invoke("backup-passphrase-clear");
        }
    },

    onenote: {
        login(): Promise<OneNoteLoginResult> {
            return ipcRenderer.invoke("onenote-login");
        }
    }
} satisfies ElectronApi);