@neosjs/electron-toolkit/dist/renderer/index.js

neosjs electron toolkit

/*! 
* @neosjs/electron-toolkit
* Version: 1.0.1
* Copyright (c) 2021-PRESENT NeosJS
* ReleaseTime: 2025/5/1 16:45:38
*/

import {
  ipcUpdaterEvents,
  isFunction,
  version
} from "../chunk-2MRZ2BGU.js";
import {
  init_esm_shims
} from "../chunk-QTDD3S3N.js";

// src/renderer/index.ts
init_esm_shims();
import logger from "electron-log";

// src/renderer/core/DownloadManager.ts
init_esm_shims();

// src/renderer/electron.ts
init_esm_shims();
var { ipcRenderer } = window.electron || window.electronApi;

// src/renderer/core/EmitterManager.ts
init_esm_shims();
var NeosEmitter = class {
  events = /* @__PURE__ */ new Map();
  // 事件监听
  constructor() {
    this.destroy();
  }
  /**
   * 订阅/监听事件
   *
   * @param type
   * @param handler
   */
  on(type, handler) {
    if (typeof type !== "string" && typeof type !== "symbol") {
      throw new TypeError("Event type must be a string or symbol");
    }
    if (typeof handler !== "function") {
      throw new TypeError("Event handler must be a function");
    }
    const handlers = this.events.get(type);
    if (handlers) {
      handlers.push(handler);
    } else {
      this.events.set(type, [handler]);
    }
    return this;
  }
  /**
   * 监听一次事件
   *
   * @param type
   * @param handler
   */
  once(type, handler) {
    const wrapped = (data) => {
      handler(data);
      return this.off(type, wrapped);
    };
    return this.on(type, wrapped);
  }
  /**
   * 发布事件
   *
   * @param type
   * @param data
   */
  emit(type, data) {
    if (typeof type !== "string" && typeof type !== "symbol") {
      throw new TypeError("Event type must be a string or symbol");
    }
    let handlers = this.events.get(type);
    if (handlers) {
      handlers.slice().map((handler) => {
        return handler(data);
      });
    }
    handlers = this.events.get("*");
    if (handlers) {
      handlers.slice().map((handler) => {
        return handler(type, data);
      });
    }
    return this;
  }
  /**
   * 关闭事件监听
   *
   * @param type
   * @param handler
   */
  off(type, handler) {
    if (typeof type !== "string" && typeof type !== "symbol") {
      throw new TypeError("Event type must be a string or symbol");
    }
    const handlers = this.events.get(type);
    if (handlers) {
      if (handler) {
        handlers.splice(handlers.indexOf(handler) >>> 0, 1);
      } else {
        this.events.set(type, []);
      }
    }
    this.events.delete(type);
    return this;
  }
  /**
   * 销毁事件监听
   */
  destroy() {
    this.events.clear();
  }
};

// src/renderer/core/DownloadManager.ts
var DownloadManager = class _DownloadManager extends NeosEmitter {
  static instance = {};
  constructor() {
    super();
  }
  static getInstance() {
    if (Object.keys(this.instance).length === 0) {
      this.instance = new _DownloadManager();
    }
    return this.instance;
  }
  _emitEvents(downloadTask, options) {
    const _callbackMap = {
      // 开始
      start: (res) => {
        isFunction(options.onStart) && options.onStart(res);
      },
      // 进度
      progress: (res) => {
        isFunction(options.onProgress) && options.onProgress(res);
      },
      // 完成
      complete: (res) => {
        isFunction(options.onComplete) && options.onComplete(res);
        ipcRenderer.removeAllListeners(downloadTask);
      },
      // 失败
      fail: (res) => {
        isFunction(options.onFail) && options.onFail(res);
        ipcRenderer.removeAllListeners(downloadTask);
      },
      // 暂停下载
      pause: (res) => {
        isFunction(options.onPause) && options.onPause(res);
      },
      // 取消
      cancel: (res) => {
        isFunction(options.onCancel) && options.onCancel(res);
        ipcRenderer.removeAllListeners(downloadTask);
      },
      // 文件存在
      exists: (res) => {
        isFunction(options.onExists) && options.onExists(res);
        ipcRenderer.removeAllListeners(downloadTask);
      }
    };
    ipcRenderer.removeAllListeners(downloadTask);
    ipcRenderer.on(downloadTask, (_e, res, state) => {
      this.emit(downloadTask, { state, info: res });
      return _callbackMap[state](res);
    });
  }
  /**
   * 开始下载
   * @param {string} url 下载地址
   * @param {DownloadOptions} options 下载选项
   * @returns {Promise<any>} 下载任务
   */
  start = async (url, options) => {
    if (!url) return Promise.reject(new Error("\u4E0B\u8F7D\u5730\u5740\u4E0D\u80FD\u4E3A\u7A7A"));
    const downloadTask = await ipcRenderer.invoke("START_DOWNLOAD" /* START_DOWNLOAD */, url, {
      saveAs: options.saveAs ?? false,
      directory: options.directory ?? null,
      filename: options.filename ?? null,
      errorTitle: options.errorTitle ?? null,
      errorMessage: options.errorMessage ?? null,
      showBadge: options.showBadge ?? true,
      showProgressBar: options.showProgressBar ?? true,
      unregisterWhenDone: options.unregisterWhenDone ?? true,
      openFolderWhenDone: options.openFolderWhenDone ?? false,
      overwrite: options.overwrite ?? true,
      dialogOptions: options.dialogOptions ?? {}
    });
    if (!downloadTask) return;
    this._emitEvents(downloadTask, options);
    return downloadTask;
  };
  /**
   * 暂停下载
   * @param {string} fileUrl 下载地址
   * @returns {DownloadManager} 下载管理器
   */
  pause = (fileUrl) => {
    ipcRenderer.send("PAUSE_DOWNLOAD" /* PAUSE_DOWNLOAD */, fileUrl);
    return this;
  };
  /**
   * 取消下载
   * @param {string} fileUrl 下载地址
   * @returns {DownloadManager} 下载管理器
   */
  cancel = (fileUrl) => {
    ipcRenderer.send("CANCEL_DOWNLOAD" /* CANCEL_DOWNLOAD */, fileUrl);
    return this;
  };
  /**
   * 恢复下载
   * @param {string} fileUrl 下载地址
   * @returns {DownloadManager} 下载管理器
   */
  resume = (fileUrl) => {
    ipcRenderer.send("RESUME_DOWNLOAD" /* RESUME_DOWNLOAD */, fileUrl);
    return this;
  };
  /**
   * 移除所有监听
   * @returns {DownloadManager} 下载管理器
   */
  destroy = () => {
    super.destroy();
    ipcRenderer.invoke("DESTROY" /* DESTROY */);
  };
  // public removeAllListeners(): DownloadManager {
  //   this.destroy()
  //   return this
  // }
};

// src/renderer/core/FileManager.ts
init_esm_shims();
var FileManager = class _FileManager {
  static instance = {};
  constructor() {
  }
  static getInstance() {
    if (Object.keys(this.instance).length === 0) {
      this.instance = new _FileManager();
    }
    return this.instance;
  }
  /**
   * 打开文件或文件夹
   * @param {string} path - 文件或文件夹路径
   */
  openPath = (path) => {
    if (!path) return new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A");
    ipcRenderer.send("OPEN_PATH_SYNC" /* OPEN_PATH_SYNC */, path);
  };
  /**
   * 打开文件或文件夹(异步)
   * @param {string} path - 文件或文件夹路径
   */
  openPathAsync = (path) => {
    if (!path) return Promise.reject(new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A"));
    return ipcRenderer.invoke("OPEN_PATH_ASYNC" /* OPEN_PATH_ASYNC */, path);
  };
  /**
   * 路径是否存在
   * @param {string} path - 文件或文件夹路径
   */
  pathExists = (path) => {
    if (!path) return Promise.reject(new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A"));
    return ipcRenderer.sendSync("PATH_EXISTS" /* PATH_EXISTS */, path);
  };
  /**
   * 清理目录
   * @param {string} dir - 目录路径
   */
  cleanupDirectory = (dir) => {
    if (!dir) return Promise.reject(new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A"));
    return ipcRenderer.invoke("CLEANUP_DIRECTORY" /* CLEANUP_DIRECTORY */, dir);
  };
  /**
   * 删除用户数据
   * @param {string} name - 用户数据名称
   */
  deleteUserData = (name) => {
    if (!name) return Promise.reject(new Error("\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"));
    return ipcRenderer.invoke("DELETE_USER_DATA" /* DELETE_USER_DATA */, name);
  };
  /**
   * 保存文件
   * @param {string} filePath - 文件路径
   * @param {string} content - 文件内容
   */
  saveFile = (filePath, content) => {
    if (!filePath) return Promise.reject(new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A"));
    return ipcRenderer.invoke("SAVE_FILE" /* SAVE_FILE */, filePath, content);
  };
  /**
   * 删除文件
   * @param {string} filePath - 文件路径
   */
  removeFile = (filePath) => {
    if (!filePath) return Promise.reject(new Error("\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A"));
    return ipcRenderer.invoke("REMOVE_FILE" /* REMOVE_FILE */, filePath);
  };
};
var FileManager_default = FileManager;

// src/renderer/core/MediaManager.ts
init_esm_shims();
var MediaManager = class _MediaManager {
  static instance = {};
  constructor() {
  }
  static getInstance() {
    if (Object.keys(this.instance).length === 0) {
      this.instance = new _MediaManager();
    }
    return this.instance;
  }
  /**
   * 获取媒体访问权限状态
   * @param {MediaType} mediaType - 媒体类型
   * @returns {Promise<MediaAccessStatus>} 媒体访问权限状态
   */
  getMediaAccessStatus = (mediaType) => {
    return ipcRenderer.invoke("GET_MEDIA_ACCESS_STATUS" /* GET_MEDIA_ACCESS_STATUS */, mediaType);
  };
  /**
   * 请求媒体访问权限
   * @param {MediaType} mediaType - 媒体类型
   * @returns {Promise<boolean>} 是否请求成功
   */
  askForMediaAccess = (mediaType) => {
    return ipcRenderer.invoke("ASK_FOR_MEDIA_ACCESS" /* ASK_FOR_MEDIA_ACCESS */, mediaType);
  };
};
var MediaManager_default = MediaManager;

// src/renderer/core/StorageManager.ts
init_esm_shims();
var StorageManager = class _StorageManager {
  static instance = {};
  constructor() {
  }
  static getInstance() {
    if (Object.keys(this.instance).length === 0) {
      this.instance = new _StorageManager();
    }
    return this.instance;
  }
  /**
   * 清理系统缓存
   * @returns {Promise<void>} 清理系统缓存
   */
  clearCache = () => {
    return ipcRenderer.invoke("CLEAN_CACHE" /* CLEAN_CACHE */);
  };
  /**
   * 清理系统存储
   * @param {any} options 清理系统存储选项
   */
  cleanStorage = (options = {}) => {
    ipcRenderer.send("CLEAN_STORAGE" /* CLEAN_STORAGE */, options);
  };
};
var StorageManager_default = StorageManager;

// src/renderer/core/SystemManager.ts
init_esm_shims();
var SystemManager = class _SystemManager {
  static instance = {};
  constructor() {
  }
  static getInstance() {
    if (Object.keys(this.instance).length === 0) {
      this.instance = new _SystemManager();
    }
    return this.instance;
  }
  /**
   * 获取系统主题
   * @returns {Promise<Appearance>} 系统主题
   */
  getSystemTheme = () => {
    return ipcRenderer.invoke("GET_SYSTEM_THEME" /* GET_SYSTEM_THEME */);
  };
  /**
   * 获取系统信息
   * @returns {Promise<SystemInfo>} 系统信息
   */
  getSystemInfo = () => {
    return ipcRenderer.invoke("GET_SYSTEM_INFO" /* GET_SYSTEM_INFO */);
  };
  /**
   * 打开URL
   * @param {string} url - URL
   */
  openURL = (url) => {
    if (!url) return;
    ipcRenderer.invoke("OPEN_URL" /* OPEN_URL */, url);
  };
};
var SystemManager_default = SystemManager;

// src/renderer/core/UpdaterManager.ts
init_esm_shims();
var UpdaterManager = class _UpdaterManager extends NeosEmitter {
  static instance;
  constructor() {
    super();
    this.destroy();
    ipcUpdaterEvents.forEach((event) => {
      ipcRenderer.removeAllListeners(event);
      ipcRenderer.on(event, (_event, info) => {
        this.emit(event, info);
      });
    });
  }
  /**
   * 获取实例
   * @returns {UpdaterManager}
   */
  static getInstance() {
    if (!this.instance) {
      this.instance = new _UpdaterManager();
    }
    return this.instance;
  }
  /**
   * 自动更新
   * @returns {Promise<void>}
   */
  autoCheckForUpdates = (url) => {
    if (!url) return Promise.reject(new Error("\u66F4\u65B0\u6E90\u4E0D\u80FD\u4E3A\u7A7A"));
    return ipcRenderer.invoke("AUTO_CHECK_FOR_UPDATES" /* AUTO_CHECK_FOR_UPDATES */, url);
  };
  /**
   * 检查更新
   * @param {string} url 更新源
   * @returns {Promise<void>}
   */
  checkForUpdates = (url) => {
    if (!url) return Promise.reject(new Error("\u66F4\u65B0\u6E90\u4E0D\u80FD\u4E3A\u7A7A"));
    return ipcRenderer.invoke("CHECK_FOR_UPDATES" /* CHECK_FOR_UPDATES */, url);
  };
  /**
   * 下载更新
   * @returns {Promise<void>}
   */
  downloadUpdate = () => {
    return ipcRenderer.invoke("DOWNLOAD_UPDATE" /* DOWNLOAD_UPDATE */);
  };
  /**
   * 安装更新
   * @returns {Promise<void>}
   */
  installUpdate = () => {
    return ipcRenderer.invoke("INSTALL_UPDATE" /* INSTALL_UPDATE */);
  };
  /**
   * 销毁
   */
  destroy = () => {
    super.destroy();
  };
};
var UpdaterManager_default = UpdaterManager;

// src/renderer/core/WindowManager.ts
init_esm_shims();
var WindowManager = class _WindowManager {
  static instance = {};
  constructor() {
  }
  static getInstance() {
    if (Object.keys(this.instance).length === 0) {
      this.instance = new _WindowManager();
    }
    return this.instance;
  }
  /**
   * 设置窗口大小
   * @param {number} width - 宽度
   * @param {number} height - 高度
   */
  setSize = (width, height) => {
    if (!width || !height) return;
    ipcRenderer.send("SET_WINDOW_SIZE" /* SET_WINDOW_SIZE */, { width, height });
  };
  /**
   * 设置窗口可操作
   * @param {string} type - 类型
   * @param {boolean} flag - 标志
   * @param {BrowserWindow} win - 窗口
   */
  setAble = (type, flag = true, win) => {
    if (!type) return false;
    ipcRenderer.send("SET_WINDOW_ABLE" /* SET_WINDOW_ABLE */, {
      type,
      flag,
      win
    });
    return true;
  };
  /**
   * 设置窗口居中
   */
  center = () => {
    ipcRenderer.send("invoke" /* INVOKE */, "center");
  };
  /**
   * 设置窗口最大化
   */
  maximize = () => {
    ipcRenderer.send("invoke" /* INVOKE */, "max");
  };
  /**
   * 设置窗口最小化
   */
  minimize = () => {
    ipcRenderer.send("invoke" /* INVOKE */, "min");
  };
  /**
   * 设置窗口关闭
   */
  closeWindow = () => {
    ipcRenderer.send("invoke" /* INVOKE */, "close");
  };
  /**
   * 设置窗口全屏
   */
  fullscreen = () => {
    ipcRenderer.send("invoke" /* INVOKE */, "fullScreen");
  };
  /**
   * 设置窗口退出全屏
   */
  exitFullscreen = () => {
    ipcRenderer.send("invoke" /* INVOKE */, "exitFullscreen");
  };
};

// src/renderer/index.ts
var RendererManager = class _RendererManager {
  version = version;
  static instance = {};
  // 单例实例
  logger;
  // 日志实例
  downloadManager;
  // 下载实例
  storageManager;
  // 存储实例
  windowManager;
  // 窗口实例
  systemManager;
  // 系统实例
  mediaManager;
  // 媒体实例
  fileManager;
  // 文件实例
  updaterManager;
  // 更新实例
  emitter;
  // 事件实例
  // 私有构造函数, 防止外部实例化
  constructor() {
    this.logger = logger;
    this.downloadManager = DownloadManager.getInstance();
    this.storageManager = StorageManager_default.getInstance();
    this.windowManager = WindowManager.getInstance();
    this.systemManager = SystemManager_default.getInstance();
    this.mediaManager = MediaManager_default.getInstance();
    this.fileManager = FileManager_default.getInstance();
    this.updaterManager = UpdaterManager_default.getInstance();
    this.emitter = new NeosEmitter();
  }
  // 获取唯一的实例
  static getInstance() {
    if (Object.keys(this.instance).length === 0) {
      _RendererManager.instance = new _RendererManager();
    }
    return _RendererManager.instance;
  }
};
var rendererManager = RendererManager.getInstance();
var renderer_default = rendererManager;
export {
  renderer_default as default
};