@e-xi/xion 0.0.6

package/dist/chunk-files/chunk-IH3R2NDR.js

@@ -0,0 +1,230 @@
+import {
+  FileAssociationUtil
+} from "./chunk-VGDNICVG.js";
+
+// src/main/file-association/file-association-handlers-abstract.ts
+var FileAssociationHandlersAbstract = class {
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+};
+
+// src/main/file-association/handlers/app-file-association-handlers.ts
+var AppFileAssociationHandlers = class extends FileAssociationHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoFileAssociation.HandlerMap}
+   */
+  handlerMap() {
+    return {
+      // // 示例
+      // // .xion 文件
+      // xion: async (context: XoFileAssociation.Context) => {
+      //     // 文件关联处理上下文
+      //     console.log('AppFileAssociationHandlers.handlerMap.xion', context)
+      //     // 文件完整绝对路径
+      //     console.log('filePath', context.filePath)
+      //     // 文件扩展名（不带点）
+      //     // 与当前处理器的键一致：xion
+      //     console.log('extension', context.extension)
+      //     // 显示主窗口
+      //     await this.xoApp.showMainWindow()
+      // },
+    };
+  }
+};
+
+// src/main/file-association/file-association-manager-abstract.ts
+var FileAssociationManagerAbstract = class {
+  /** 是否已初始化 */
+  initialized = false;
+  /** 是否可以处理关联文件 */
+  ready = false;
+  /** 文件处理队列 */
+  pendingFiles = [];
+  /** 文件处理任务队列 */
+  processingPromise = Promise.resolve();
+  /** 已注册处理器类 */
+  registeredHandlerClasses = /* @__PURE__ */ new Set();
+  /** 已注册文件扩展名 */
+  registeredExtensions = /* @__PURE__ */ new Set();
+  /** 文件关联处理器映射 */
+  handlerMap = /* @__PURE__ */ new Map();
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+  /**
+   * 初始化文件关联处理器
+   * @returns {boolean}
+   */
+  initialize() {
+    if (this.initialized) {
+      return false;
+    }
+    this.initialized = true;
+    const handlerClasses = [
+      // 内置应用处理器类
+      AppFileAssociationHandlers,
+      // 自定义处理器类
+      ...this.handlers()
+    ];
+    for (const HandlerClass of handlerClasses) {
+      if (this.registeredHandlerClasses.has(HandlerClass)) {
+        throw new Error(`\u6587\u4EF6\u5173\u8054\u5904\u7406\u5668\u91CD\u590D\u6CE8\u518C: ${HandlerClass.name}`);
+      }
+      this.registeredHandlerClasses.add(HandlerClass);
+      this.registerHandlerMap(new HandlerClass(this.xoApp).handlerMap());
+    }
+    return true;
+  }
+  /**
+   * 注册处理器映射
+   * @param {XoFileAssociation.HandlerMap} handlers 处理器映射
+   * @returns {void}
+   * @private
+   */
+  registerHandlerMap(handlers) {
+    for (const [rawExtension, handler] of Object.entries(handlers)) {
+      if (!handler) continue;
+      const normalizedExtension = FileAssociationUtil.normalizeExtension(rawExtension);
+      if (!FileAssociationUtil.isValidExtension(normalizedExtension)) {
+        throw new Error(`\u65E0\u6548\u7684\u6587\u4EF6\u5173\u8054\u5904\u7406\u5668\u6269\u5C55\u540D: ${rawExtension}`);
+      }
+      const [extension] = FileAssociationUtil.getRuntimeExtensions([normalizedExtension]);
+      if (this.registeredExtensions.has(extension)) {
+        throw new Error(`\u6587\u4EF6\u5173\u8054\u5904\u7406\u5668\u6269\u5C55\u540D\u91CD\u590D\u6CE8\u518C: ${extension}`);
+      }
+      this.registeredExtensions.add(extension);
+      this.handlerMap.set(extension, handler);
+    }
+  }
+  /**
+   * 文件处理就绪
+   * @returns {Promise<void>}
+   */
+  async setReady() {
+    this.ready = true;
+    await this.processPendingFiles();
+  }
+  /**
+   * 处理启动参数
+   * @param {readonly string[]} argv 启动参数
+   * @returns {Promise<boolean>} 是否处理了关联文件
+   */
+  async handleArgv(argv) {
+    let handled = false;
+    for (const value of argv) {
+      if (await this.handleFile(value)) {
+        handled = true;
+      }
+    }
+    return handled;
+  }
+  /**
+   * 处理关联文件
+   * @param {string} value 文件路径
+   * @returns {Promise<boolean>}
+   */
+  async handleFile(value) {
+    const context = this.parseFile(value);
+    if (!context || this.pendingFiles.includes(context.filePath)) {
+      return false;
+    }
+    this.pendingFiles.push(context.filePath);
+    await this.processPendingFiles();
+    return true;
+  }
+  /**
+   * 解析关联文件
+   * @param {string} value 文件路径
+   * @returns {XoFileAssociation.Context | undefined}
+   * @private
+   */
+  parseFile(value) {
+    const filePath = FileAssociationUtil.resolveFilePath(value);
+    if (!filePath) {
+      return void 0;
+    }
+    const extension = FileAssociationUtil.getExtension(filePath);
+    const supportedExtensions = FileAssociationUtil.getRuntimeExtensions(this.xoApp.getAppConfig()?.eletronAppConfig?.fileAssociationExtensions);
+    return supportedExtensions.includes(extension) ? { filePath, extension } : void 0;
+  }
+  /**
+   * 处理当前等待队列
+   * @returns {Promise<void>}
+   * @private
+   */
+  async processPendingFiles() {
+    if (!this.ready) {
+      return;
+    }
+    this.processingPromise = this.processingPromise.catch(() => void 0).then(async () => {
+      while (this.pendingFiles.length > 0) {
+        const filePath = this.pendingFiles.shift();
+        await this.dispatch(filePath);
+      }
+    });
+    await this.processingPromise;
+  }
+  /**
+   * 分发关联文件
+   * @param {string} filePath 文件路径
+   * @returns {Promise<void>}
+   * @private
+   */
+  async dispatch(filePath) {
+    const context = this.parseFile(filePath);
+    if (!context) {
+      return;
+    }
+    const handler = this.handlerMap.get(context.extension);
+    if (!handler) {
+      this.xoApp.appLog.warn("\u672A\u627E\u5230\u6587\u4EF6\u5173\u8054\u5904\u7406\u5668", context);
+      return;
+    }
+    try {
+      await handler(context);
+    } catch (error) {
+      await this.xoApp.dispatchAppError({ source: `FileAssociationHandler:${context.extension}`, error });
+    }
+  }
+};
+
+// src/main/file-association/file-association-manager.ts
+var FileAssociationManager = class extends FileAssociationManagerAbstract {
+  /**
+   * 自定义处理器列表
+   * @returns {XoFileAssociation.HandlersConstructor[]}
+   * @protected
+   */
+  handlers() {
+    return [];
+  }
+};
+
+export {
+  FileAssociationHandlersAbstract,
+  AppFileAssociationHandlers,
+  FileAssociationManagerAbstract,
+  FileAssociationManager
+};

package/dist/chunk-files/chunk-IMGYTSWY.js

@@ -0,0 +1,261 @@
+import {
+  ProtocolUtil
+} from "./chunk-KFK47PDH.js";
+
+// src/main/protocol/consts/protocol-keys.ts
+var ProtocolKeys = class {
+  /** 打开主窗口 */
+  static openMainWindow = ProtocolUtil.key("app/v1/main/open");
+  /** 打开设置窗口 */
+  static openSettingWindow = ProtocolUtil.key("app/v1/settings/open");
+};
+
+// src/main/protocol/protocol-handlers-abstract.ts
+var ProtocolHandlersAbstract = class {
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+};
+
+// src/main/protocol/handlers/app-protocol-handlers.ts
+var AppProtocolHandlers = class extends ProtocolHandlersAbstract {
+  /**
+   * 处理器映射
+   * @returns {XoProtocol.HandlerMap}
+   */
+  handlerMap() {
+    return {
+      /** 打开主窗口 */
+      [ProtocolKeys.openMainWindow]: async () => {
+        await this.xoApp.showMainWindow();
+      },
+      /** 打开设置窗口 */
+      [ProtocolKeys.openSettingWindow]: async () => {
+        await this.xoApp.showSettingWindow();
+      }
+      /** 示例 */
+      // [ProtocolHandlerKeys.actionName]: async ({url}) => {
+      //     // 获取协议名
+      //     const protocol = ProtocolUtil.getProtocolName(url)
+      //
+      //     // 获取参数
+      //     const id         = url.searchParams.get('id')      // 单个参数
+      //     const ids        = url.searchParams.getAll('ids')  // 重复参数
+      //     const hasPreview = url.searchParams.has('preview') // 是否存在
+      //
+      //     // 按不同协议名处理
+      //     if (protocol === 'eassistant') {
+      //         // 生产协议处理
+      //     } else if (protocol === 'eassistant-dev') {
+      //         // 开发协议处理
+      //     } else if (protocol === 'ea') {
+      //         // 短协议处理
+      //     }
+      // },
+    };
+  }
+};
+
+// src/main/protocol/protocol-manager-abstract.ts
+import { app } from "electron";
+import path from "node:path";
+var ProtocolManagerAbstract = class {
+  /** 是否已初始化 */
+  initialized = false;
+  /** 是否可以处理协议 URL */
+  ready = false;
+  /** 协议处理队列 */
+  pendingUrls = [];
+  /** 协议处理任务队列 */
+  processingPromise = Promise.resolve();
+  /** 已注册处理器类 */
+  registeredHandlerClasses = /* @__PURE__ */ new Set();
+  /** 已注册处理器键 */
+  registeredHandlerKeys = /* @__PURE__ */ new Set();
+  /** 协议处理器映射 */
+  handlerMap = /* @__PURE__ */ new Map();
+  /**
+   * Xion 应用
+   * @type {XoAppAbstract}
+   * @protected
+   */
+  xoApp;
+  /**
+   * 构造函数
+   * @param {XoAppAbstract} xoApp Xion 应用
+   */
+  constructor(xoApp) {
+    this.xoApp = xoApp;
+  }
+  /**
+   * 初始化协议处理器
+   * @returns {boolean}
+   */
+  initialize() {
+    if (this.initialized) {
+      return false;
+    }
+    this.initialized = true;
+    const handlerClasses = [
+      // 应用处理器类
+      AppProtocolHandlers,
+      // 自定义处理器类
+      ...this.handlers()
+    ];
+    for (const HandlerClass of handlerClasses) {
+      if (this.registeredHandlerClasses.has(HandlerClass)) {
+        throw new Error(`\u534F\u8BAE\u5904\u7406\u5668\u91CD\u590D\u6CE8\u518C: ${HandlerClass.name}`);
+      }
+      this.registeredHandlerClasses.add(HandlerClass);
+      const handlers = new HandlerClass(this.xoApp).handlerMap();
+      for (const [key, handler] of Object.entries(handlers)) {
+        if (!handler) continue;
+        if (this.registeredHandlerKeys.has(key)) {
+          throw new Error(`\u534F\u8BAE\u5904\u7406\u5668\u952E\u91CD\u590D\u6CE8\u518C: ${key}`);
+        }
+        this.registeredHandlerKeys.add(key);
+        this.handlerMap.set(key, handler);
+      }
+    }
+    return true;
+  }
+  /**
+   * 注册默认协议客户端
+   */
+  registerClients() {
+    const protocols = ProtocolUtil.getRuntimeProtocols(this.xoApp.getAppConfig()?.eletronAppConfig?.protocols);
+    const isDefaultApp = ProtocolUtil.isDefaultApp();
+    const args = isDefaultApp ? [path.resolve(process.argv[1])] : [];
+    for (const protocol of protocols) {
+      const registered = isDefaultApp ? app.isDefaultProtocolClient(protocol, process.execPath, args) : app.isDefaultProtocolClient(protocol);
+      if (registered) {
+        continue;
+      }
+      const success = isDefaultApp ? app.setAsDefaultProtocolClient(protocol, process.execPath, args) : app.setAsDefaultProtocolClient(protocol);
+      success || this.xoApp.appLog.warn("\u8BBE\u7F6E\u9ED8\u8BA4\u534F\u8BAE\u5BA2\u6237\u7AEF\u5931\u8D25", { protocol });
+    }
+  }
+  /**
+   * 协议处理就绪
+   * @returns {Promise<void>}
+   */
+  async setReady() {
+    this.ready = true;
+    await this.processPendingUrls();
+  }
+  /**
+   * 处理启动参数
+   * 参数仅如 'eassistant://app/v1/main/open?id=123' 格式时处理
+   * @param {readonly string[]} argv 启动参数
+   * @returns {Promise<boolean>} 是否处理了协议 URL
+   */
+  async handleArgv(argv) {
+    let handled = false;
+    for (const value of argv) {
+      if (await this.handleUrl(value)) {
+        handled = true;
+      }
+    }
+    return handled;
+  }
+  /**
+   * 处理协议 URL
+   * @param {string} value 外部输入
+   * @returns {Promise<boolean>}
+   */
+  async handleUrl(value) {
+    if (!this.parseUrl(value) || this.pendingUrls.includes(value)) {
+      return false;
+    }
+    this.pendingUrls.push(value);
+    await this.processPendingUrls();
+    return true;
+  }
+  /**
+   * 解析应用协议 URL
+   * @param {string} value 外部输入
+   * @returns {URL | undefined}
+   * @private
+   */
+  parseUrl(value) {
+    let url;
+    try {
+      url = new URL(value);
+    } catch {
+      return void 0;
+    }
+    const protocols = ProtocolUtil.getRuntimeProtocols(this.xoApp.getAppConfig()?.eletronAppConfig?.protocols);
+    const supported = protocols.includes(ProtocolUtil.getProtocolName(url));
+    return supported ? url : void 0;
+  }
+  /**
+   * 处理当前等待队列
+   * @returns {Promise<void>}
+   * @private
+   */
+  async processPendingUrls() {
+    if (!this.ready) {
+      return;
+    }
+    this.processingPromise = this.processingPromise.catch(() => void 0).then(async () => {
+      while (this.pendingUrls.length > 0) {
+        const rawUrl = this.pendingUrls.shift();
+        await this.dispatch(rawUrl);
+      }
+    });
+    await this.processingPromise;
+  }
+  /**
+   * 分发协议 URL
+   * @param {string} rawUrl 原始协议 URL
+   * @returns {Promise<void>}
+   * @private
+   */
+  async dispatch(rawUrl) {
+    const url = this.parseUrl(rawUrl);
+    const key = url && ProtocolUtil.getKey(url);
+    if (!url || !key) {
+      return;
+    }
+    const handler = this.handlerMap.get(key);
+    if (!handler) {
+      this.xoApp.appLog.warn("\u672A\u627E\u5230\u534F\u8BAE\u5904\u7406\u5668", { key, url: rawUrl });
+      return;
+    }
+    try {
+      await handler({ rawUrl, url, key });
+    } catch (error) {
+      await this.xoApp.dispatchAppError({ source: `ProtocolHandler:${key}`, error });
+    }
+  }
+};
+
+// src/main/protocol/protocol-manager.ts
+var ProtocolManager = class extends ProtocolManagerAbstract {
+  /**
+   * 自定义处理器列表
+   * @returns {XoProtocol.HandlersConstructor[]}
+   * @protected
+   */
+  handlers() {
+    return [];
+  }
+};
+
+export {
+  ProtocolKeys,
+  ProtocolHandlersAbstract,
+  AppProtocolHandlers,
+  ProtocolManagerAbstract,
+  ProtocolManager
+};

package/dist/chunk-files/chunk-J34MOWJP.js

@@ -0,0 +1,26 @@
+// src/main/auth/jwt-auth-session-changed-error.ts
+var JwtAuthSessionChangedError = class extends Error {
+  /**
+   * 构造函数
+   * @param {string} message 错误信息
+   */
+  constructor(message = "\u8BA4\u8BC1\u4F1A\u8BDD\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u8BD5\u8BF7\u6C42") {
+    super(message);
+    this.name = "JwtAuthSessionChangedError";
+  }
+};
+
+// src/main/remote-service/consts/remote-service-methods.ts
+var RemoteServiceAllowedRequestMethods = /* @__PURE__ */ new Set([
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE"
+]);
+
+export {
+  JwtAuthSessionChangedError,
+  RemoteServiceAllowedRequestMethods
+};

package/dist/chunk-files/chunk-KFK47PDH.js

@@ -0,0 +1,77 @@
+// src/main/utils/protocol-util.ts
+var ProtocolUtil = class _ProtocolUtil {
+  /**
+   * 是否为默认 Electron 应用启动模式
+   * @returns {boolean}
+   */
+  static isDefaultApp() {
+    return Boolean(process.defaultApp && process.argv[1]);
+  }
+  /**
+   * 是否为有效的协议名
+   * @param {string} protocol 协议名
+   * @returns {boolean}
+   */
+  static isValidProtocol(protocol) {
+    return /^[a-z][a-z0-9+.-]*$/.test(protocol);
+  }
+  /**
+   * 获取运行时协议
+   * @param {readonly string[]} protocols 协议
+   * @returns {string[]}
+   */
+  static getRuntimeProtocols(protocols) {
+    const values = protocols ?? [];
+    return _ProtocolUtil.isDefaultApp() ? values.map((protocol) => `${protocol}-dev`) : [...values];
+  }
+  /**
+   * 获取 URL 中的协议名称
+   * @param {URL} url 协议 URL
+   * @returns {string}
+   */
+  static getProtocolName(url) {
+    return url.protocol.slice(0, -1).toLowerCase();
+  }
+  /**
+   * 启动参数中是否包含运行时协议 URL
+   * @param {readonly string[]} argv      启动参数
+   * @param {readonly string[]} protocols 协议
+   * @returns {boolean}
+   */
+  static hasProtocolUrl(argv, protocols) {
+    const runtimeProtocols = _ProtocolUtil.getRuntimeProtocols(protocols);
+    return argv.some((value) => {
+      try {
+        const url = new URL(value);
+        const protocol = _ProtocolUtil.getProtocolName(url);
+        return runtimeProtocols.includes(protocol);
+      } catch {
+        return false;
+      }
+    });
+  }
+  /**
+   * 定义协议处理器键
+   * @template T 协议处理器键类型
+   * @param {T} key 协议处理器键
+   * @returns {T}
+   */
+  static key(key) {
+    return key;
+  }
+  /**
+   * 获取协议处理器键
+   * @param {URL} url 协议 URL
+   * @returns {XoProtocol.Key | undefined}
+   */
+  static getKey(url) {
+    if (!url.hostname || !url.pathname.startsWith("/")) {
+      return void 0;
+    }
+    return `${url.hostname.toLowerCase()}${url.pathname}`;
+  }
+};
+
+export {
+  ProtocolUtil
+};

package/dist/chunk-files/chunk-KFV4GXVE.js

@@ -0,0 +1,11 @@
+import {
+  WindowSharedUtil
+} from "./chunk-OUFO3LM4.js";
+
+// src/shared/window/identity/main-window-identity.ts
+var windowTypeName = "main";
+var MainWindowIdentity = WindowSharedUtil.identity("main", windowTypeName, "/index.html");
+
+export {
+  MainWindowIdentity
+};