backsplash-app/src/preload.ts

An AI powered wallpaper app.

import { contextBridge, ipcRenderer, IpcRendererEvent } from "electron";

const versions: Record<string, unknown> = {};

// Process versions
for (const type of ["chrome", "node", "electron"]) {
  versions[type] = process.versions[type];
}

function validateIPC(channel: string) {
  if (!channel) {
    throw new Error(`Unsupported event IPC channel '${channel}'`);
  }

  return true;
}

export type RendererListener = (event: IpcRendererEvent, ...args: unknown[]) => void;

const platform = process.platform;

export const globals = {
  /** Processes versions **/
  versions,

  /** Current platform **/
  platform,

  /**
   * A minimal set of methods exposed from Electron's `ipcRenderer`
   * to support communication to main process.
   */
  ipcRenderer: {
    send(channel: string, ...args: unknown[]) {
      if (validateIPC(channel)) {
        ipcRenderer.send(channel, ...args);
      }
    },

    invoke(channel: string, ...args: unknown[]) {
      if (validateIPC(channel)) {
        return ipcRenderer.invoke(channel, ...args);
      }
    },

    on(channel: string, listener: RendererListener) {
      if (validateIPC(channel)) {
        ipcRenderer.on(channel, listener);

        return this;
      }
    },

    once(channel: string, listener: RendererListener) {
      if (validateIPC(channel)) {
        ipcRenderer.once(channel, listener);

        return this;
      }
    },

    removeListener(channel: string, listener: RendererListener) {
      if (validateIPC(channel)) {
        ipcRenderer.removeListener(channel, listener);

        return this;
      }
    },
  },

  /**
   * Electron-store API exposed via IPC
   */
  store: {
    get: (key: string) => {
      return ipcRenderer.invoke("store:get", key);
    },
    set: (key: string, value: unknown) => {
      return ipcRenderer.invoke("store:set", key, value);
    },
    has: (key: string) => {
      return ipcRenderer.invoke("store:has", key);
    },
    delete: (key: string) => {
      return ipcRenderer.invoke("store:delete", key);
    },
    clear: () => {
      return ipcRenderer.invoke("store:clear");
    },
  },

  /**
   * Auto-launch API exposed via IPC
   */
  autoLaunch: {
    get: () => {
      return ipcRenderer.invoke("auto-launch:get");
    },
    set: (enabled: boolean) => {
      return ipcRenderer.invoke("auto-launch:set", enabled);
    },
  },

  /**
   * License API exposed via IPC
   */
  license: {
    getLicenseInfo: () => {
      return ipcRenderer.invoke("license:get-info");
    },
    validateLicense: (licenseKey: string, clientId?: string) => {
      return ipcRenderer.invoke("license:validate", licenseKey, clientId);
    },
    clearLicense: () => {
      return ipcRenderer.invoke("license:clear");
    },
    openExternalUrl: (url: string) => {
      return ipcRenderer.invoke("license:open-external-url", url);
    },
  },
};

/** Create a safe, bidirectional, synchronous bridge across isolated contexts
 *  When contextIsolation is enabled in your webPreferences, your preload scripts run in an "Isolated World".
 */
contextBridge.exposeInMainWorld("electron", globals);