sailfork / t3code-github / apps/ desktop/ src/ electron/ ElectronApp.ts

import * as HostProcess from "@t3tools/shared/HostProcess";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";

import * as Electron from "electron";

export interface ElectronAppMetadata {
  readonly appVersion: string;
  readonly appPath: string;
  readonly isPackaged: boolean;
  readonly resourcesPath: string;
  readonly runningUnderArm64Translation: boolean;
}

export class ElectronAppMetadataReadError extends Schema.TaggedError<ElectronAppMetadataReadError>()(
  "ElectronAppMetadataReadError",
  {
    property: Schema.Literals(["app-version", "app-path"]),
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `Failed to read Electron app metadata property "${this.property}".`;
  }
}

export class ElectronAppWhenReadyError extends Schema.TaggedError<ElectronAppWhenReadyError>()(
  "ElectronAppWhenReadyError",
  {
    isPackaged: Schema.Boolean,
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `Failed to wait for the Electron app to become ready (packaged: ${this.isPackaged}).`;
  }
}

export class ElectronApp extends Context.Service<
  ElectronApp,
  {
    readonly metadata: Effect.Effect<ElectronAppMetadata, ElectronAppMetadataReadError>;
    readonly name: Effect.Effect<string>;
    /** Packaged builds ship only en-US; app.getLocale() and Intl defaults do not reflect the OS locale. */
    readonly systemLocale: Effect.Effect<string>;
    readonly whenReady: Effect.Effect<void, ElectronAppWhenReadyError>;
    readonly requestSingleInstanceLock: Effect.Effect<boolean>;
    readonly quit: Effect.Effect<void>;
    readonly exit: (code: number) => Effect.Effect<void>;
    readonly relaunch: (options: Electron.RelaunchOptions) => Effect.Effect<void>;
    readonly setPath: (
      name: Parameters<Electron.App["setPath"]>[0],
      path: string,
    ) => Effect.Effect<void>;
    readonly setName: (name: string) => Effect.Effect<void>;
    readonly setAboutPanelOptions: (
      options: Electron.AboutPanelOptionsOptions,
    ) => Effect.Effect<void>;
    readonly setAppUserModelId: (id: string) => Effect.Effect<void>;
    readonly getAppMetrics: Effect.Effect<ReadonlyArray<Electron.ProcessMetric>>;
    readonly setAsDefaultProtocolClient: (
      protocol: string,
      path?: string,
      args?: readonly string[],
    ) => Effect.Effect<boolean>;
    readonly setDesktopName: (desktopName: string) => Effect.Effect<void>;
    readonly setDockIcon: (iconPath: string) => Effect.Effect<void>;
    readonly appendCommandLineSwitch: (switchName: string, value?: string) => Effect.Effect<void>;
    readonly onBeforeQuitForUpdate: (
      listener: () => void,
    ) => Effect.Effect<void, never, Scope.Scope>;
    readonly removeCommandLineSwitch: (switchName: string) => Effect.Effect<void>;
    readonly on: <Args extends ReadonlyArray<unknown>>(
      eventName: string,
      listener: (...args: Args) => void,
    ) => Effect.Effect<void, never, Scope.Scope>;
  }
>()("@t3tools/desktop/electron/ElectronApp") {}

const addScopedAppListener = <Args extends ReadonlyArray<unknown>>(
  eventName: string,
  listener: (...args: Args) => void,
): Effect.Effect<void, never, Scope.Scope> =>
  Effect.acquireRelease(
    Effect.sync(() => {
      Electron.app.on(eventName as any, listener as any);
    }),
    () =>
      Effect.sync(() => {
        Electron.app.removeListener(eventName as any, listener as any);
      }),
  ).pipe(Effect.asVoid);

export function toSystemLocaleTag(identifier: string, hourCycle?: "h12" | "h23"): string {
  const [base = "", keywords = ""] = identifier.split("@");
  const languageTag = base.replace(/_/g, "-");
  // Intl ignores rg extensions, so the macOS region override must replace the region subtag.
  const region = /(?:^|;)rg=([a-z]{2}|\d{3})zzzz(?:;|$)/i.exec(keywords)?.[1]?.toUpperCase();
  try {
    return new Intl.Locale(languageTag, {
      ...(region ? { region } : {}),
      ...(hourCycle ? { hourCycle } : {}),
    }).toString();
  } catch {
    return languageTag;
  }
}

/** @public */
export const make = ElectronApp.of({
  metadata: Effect.gen(function* () {
    const appVersion = yield* Effect.try({
      try: () => Electron.app.getVersion(),
      catch: (cause) =>
        new ElectronAppMetadataReadError({
          property: "app-version",
          cause,
        }),
    });
    const appPath = yield* Effect.try({
      try: () => Electron.app.getAppPath(),
      catch: (cause) =>
        new ElectronAppMetadataReadError({
          property: "app-path",
          cause,
        }),
    });

    return {
      appVersion,
      appPath,
      isPackaged: Electron.app.isPackaged,
      resourcesPath: process.resourcesPath,
      runningUnderArm64Translation: Electron.app.runningUnderARM64Translation === true,
    };
  }),
  name: Effect.sync(() => Electron.app.name),
  systemLocale: Effect.gen(function* () {
    const platform = yield* HostProcess.Platform;
    let identifier = Electron.app.getSystemLocale();
    let hourCycle: "h12" | "h23" | undefined;
    if (platform === "linux") {
      const env = yield* HostProcess.Environment;
      const timeLocale = (env.LC_ALL || env.LC_TIME || env.LANG)?.split(".")[0];
      if (timeLocale && timeLocale !== "C" && timeLocale !== "POSIX") identifier = timeLocale;
    } else if (platform === "darwin") {
      if (Electron.systemPreferences.getUserDefault("AppleICUForce24HourTime", "boolean")) {
        hourCycle = "h23";
      } else if (Electron.systemPreferences.getUserDefault("AppleICUForce12HourTime", "boolean")) {
        hourCycle = "h12";
      }
    }
    return toSystemLocaleTag(identifier, hourCycle);
  }),
  whenReady: Effect.gen(function* () {
    const isPackaged = Electron.app.isPackaged;
    yield* Effect.tryPromise({
      try: () => Electron.app.whenReady(),
      catch: (cause) => new ElectronAppWhenReadyError({ isPackaged, cause }),
    });
  }),
  requestSingleInstanceLock: Effect.sync(() => Electron.app.requestSingleInstanceLock()),
  quit: Effect.sync(() => {
    Electron.app.quit();
  }),
  exit: Effect.fn("ElectronApp.exit")(function (code) {
    return Effect.sync(() => {
      Electron.app.exit(code);
    });
  }),
  relaunch: Effect.fn("ElectronApp.relaunch")(function (options) {
    return Effect.sync(() => {
      Electron.app.relaunch(options);
    });
  }),
  setPath: Effect.fn("ElectronApp.setPath")(function (name, path) {
    return Effect.sync(() => {
      Electron.app.setPath(name, path);
    });
  }),
  setName: Effect.fn("ElectronApp.setName")(function (name) {
    return Effect.sync(() => {
      Electron.app.setName(name);
    });
  }),
  setAboutPanelOptions: Effect.fn("ElectronApp.setAboutPanelOptions")(function (options) {
    return Effect.sync(() => {
      Electron.app.setAboutPanelOptions(options);
    });
  }),
  setAppUserModelId: Effect.fn("ElectronApp.setAppUserModelId")(function (id) {
    return Effect.sync(() => {
      Electron.app.setAppUserModelId(id);
    });
  }),
  getAppMetrics: Effect.sync(() => Electron.app.getAppMetrics()),
  setAsDefaultProtocolClient: Effect.fn("ElectronApp.setAsDefaultProtocolClient")(
    function (protocol, path, args) {
      return Effect.sync(() => {
        if (path === undefined) {
          return Electron.app.setAsDefaultProtocolClient(protocol);
        }
        return Electron.app.setAsDefaultProtocolClient(protocol, path, [...(args ?? [])]);
      });
    },
  ),
  setDesktopName: Effect.fn("ElectronApp.setDesktopName")(function (desktopName) {
    return Effect.sync(() => {
      const linuxApp = Electron.app as Electron.App & {
        setDesktopName?: (desktopName: string) => void;
      };
      linuxApp.setDesktopName?.(desktopName);
    });
  }),
  setDockIcon: Effect.fn("ElectronApp.setDockIcon")(function (iconPath) {
    return Effect.sync(() => {
      Electron.app.dock?.setIcon(iconPath);
    });
  }),
  appendCommandLineSwitch: Effect.fn("ElectronApp.appendCommandLineSwitch")(
    function (switchName, value) {
      return Effect.sync(() => {
        if (value === undefined) {
          Electron.app.commandLine.appendSwitch(switchName);
          return;
        }
        Electron.app.commandLine.appendSwitch(switchName, value);
      });
    },
  ),
  onBeforeQuitForUpdate: Effect.fn("ElectronApp.onBeforeQuitForUpdate")(function (listener) {
    return Effect.acquireRelease(
      Effect.sync(() => {
        Electron.autoUpdater.on("before-quit-for-update", listener);
      }),
      () =>
        Effect.sync(() => {
          Electron.autoUpdater.removeListener("before-quit-for-update", listener);
        }),
    ).pipe(Effect.asVoid);
  }),
  removeCommandLineSwitch: Effect.fn("ElectronApp.removeCommandLineSwitch")(function (switchName) {
    return Effect.sync(() => {
      Electron.app.commandLine.removeSwitch(switchName);
    });
  }),
  on: addScopedAppListener,
});

export const layer = Layer.succeed(ElectronApp, make);