@easy-electron/preload 1.0.1-alpha.1

package/dist/runtime-entry.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const index = require('./shared/preload.OqYa61Ym.cjs');
+require('@easy-electron/utils');
+
+
+
+exports.EVENT_MODULE_KEY = index.EVENT_MODULE_KEY;
+exports.IPC_MODULE_KEY = index.IPC_MODULE_KEY;
+exports.defineEvents = index.defineEvents;
+exports.defineIpc = index.defineIpc;

package/dist/runtime-entry.d.cts

@@ -0,0 +1,106 @@
+import { IpcMainInvokeEvent } from 'electron';
+
+/**
+ * defineIpc 返回值上附加模块名的 Symbol 键
+ * 与 core 包的 IpcManager 共享，用于自动提取模块名
+ */
+declare const IPC_MODULE_KEY: unique symbol;
+/**
+ * defineEvents 返回值上附加模块名的 Symbol 键
+ * 与 core 包的 EventManager 共享，用于自动提取模块名
+ */
+declare const EVENT_MODULE_KEY: unique symbol;
+/**
+ * IPC 处理器类型 — 标准 invoke/handle 模式
+ */
+type IpcHandleFunction = (event: IpcMainInvokeEvent, ...args: any[]) => any | Promise<any>;
+/**
+ * IPC 处理器类型 — on 模式（单向通信，不返回值）
+ */
+type IpcOnFunction = (event: IpcMainInvokeEvent, ...args: any[]) => void;
+/**
+ * 单个 IPC 处理器的配置项
+ */
+interface IpcHandlerConfig {
+    /** 处理器类型 */
+    type: 'handle' | 'on' | 'handleOnce' | 'once';
+    /** 处理器函数 */
+    handler: IpcHandleFunction | IpcOnFunction;
+}
+/**
+ * defineIpc 可以接收的处理器值类型
+ */
+type IpcHandlerValue = IpcHandleFunction | IpcOnFunction | IpcHandlerConfig;
+/**
+ * IPC 处理器映射对象类型
+ */
+type IpcHandlerMap = Record<string, IpcHandlerValue>;
+/**
+ * 定义 IPC 处理器（编译时标记 + 运行时标识返回）
+ *
+ * 编译时：EasyPreloadGenerator 通过 AST 解析此调用，提取处理器名称、参数类型、返回类型
+ * 运行时：原样返回 handlers 对象，供 IpcManager.registerHandlers() 批量注册
+ *
+ * @example 无模块名 — 直接定义处理器
+ * ```ts
+ * export default defineIpc({
+ *   ping: async () => 'pong',
+ *   setUser(_event, user: UserInfo) { ... }
+ * })
+ * ```
+ *
+ * @example 有模块名 — 嵌套在模块下
+ * ```ts
+ * export default defineIpc('test', {
+ *   getData: async (_event, id: string): Promise<Data> => { ... }
+ * })
+ * ```
+ */
+declare function defineIpc<T extends IpcHandlerMap>(handlers: T): T;
+declare function defineIpc<T extends IpcHandlerMap>(moduleName: string, handlers: T): T;
+/**
+ * 事件处理器配置项
+ */
+interface EventHandlerConfig {
+    /** 事件数据类型范例 — 只用于类型推断，不会在运行时执行 */
+    sample: (data: any) => any;
+    /** 是否只监听一次 */
+    once?: boolean;
+    /** remove 方法类型 */
+    remove?: 'single' | 'all' | 'both' | false;
+}
+/**
+ * 事件处理器映射对象类型
+ */
+type EventHandlerMap = Record<string, ((data: any) => any) | EventHandlerConfig>;
+/**
+ * 定义事件处理器（编译时标记 + 运行时标识返回）
+ *
+ * 编译时：EasyPreloadGenerator 通过 AST 解析此调用，提取事件名、数据类型、remove 模式等
+ * 运行时：原样返回 events 对象，供 EventManager 批量注册
+ *
+ * @example 无模块名
+ * ```ts
+ * export default defineEvents({
+ *   onDownloadProgress: {
+ *     handler: (data: DownloadProgressData) => data,
+ *     remove: 'single'
+ *   }
+ * })
+ * ```
+ *
+ * @example 有模块名
+ * ```ts
+ * export default defineEvents('notification', {
+ *   onMessage: {
+ *     handler: (data: MessageData) => data,
+ *     remove: 'both'
+ *   }
+ * })
+ * ```
+ */
+declare function defineEvents<T extends EventHandlerMap>(handlers: T): T;
+declare function defineEvents<T extends EventHandlerMap>(moduleName: string, handlers: T): T;
+
+export { EVENT_MODULE_KEY, IPC_MODULE_KEY, defineEvents, defineIpc };
+export type { EventHandlerConfig, EventHandlerMap, IpcHandleFunction, IpcHandlerConfig, IpcHandlerMap, IpcHandlerValue, IpcOnFunction };

package/dist/runtime-entry.d.mts

@@ -0,0 +1,106 @@
+import { IpcMainInvokeEvent } from 'electron';
+
+/**
+ * defineIpc 返回值上附加模块名的 Symbol 键
+ * 与 core 包的 IpcManager 共享，用于自动提取模块名
+ */
+declare const IPC_MODULE_KEY: unique symbol;
+/**
+ * defineEvents 返回值上附加模块名的 Symbol 键
+ * 与 core 包的 EventManager 共享，用于自动提取模块名
+ */
+declare const EVENT_MODULE_KEY: unique symbol;
+/**
+ * IPC 处理器类型 — 标准 invoke/handle 模式
+ */
+type IpcHandleFunction = (event: IpcMainInvokeEvent, ...args: any[]) => any | Promise<any>;
+/**
+ * IPC 处理器类型 — on 模式（单向通信，不返回值）
+ */
+type IpcOnFunction = (event: IpcMainInvokeEvent, ...args: any[]) => void;
+/**
+ * 单个 IPC 处理器的配置项
+ */
+interface IpcHandlerConfig {
+    /** 处理器类型 */
+    type: 'handle' | 'on' | 'handleOnce' | 'once';
+    /** 处理器函数 */
+    handler: IpcHandleFunction | IpcOnFunction;
+}
+/**
+ * defineIpc 可以接收的处理器值类型
+ */
+type IpcHandlerValue = IpcHandleFunction | IpcOnFunction | IpcHandlerConfig;
+/**
+ * IPC 处理器映射对象类型
+ */
+type IpcHandlerMap = Record<string, IpcHandlerValue>;
+/**
+ * 定义 IPC 处理器（编译时标记 + 运行时标识返回）
+ *
+ * 编译时：EasyPreloadGenerator 通过 AST 解析此调用，提取处理器名称、参数类型、返回类型
+ * 运行时：原样返回 handlers 对象，供 IpcManager.registerHandlers() 批量注册
+ *
+ * @example 无模块名 — 直接定义处理器
+ * ```ts
+ * export default defineIpc({
+ *   ping: async () => 'pong',
+ *   setUser(_event, user: UserInfo) { ... }
+ * })
+ * ```
+ *
+ * @example 有模块名 — 嵌套在模块下
+ * ```ts
+ * export default defineIpc('test', {
+ *   getData: async (_event, id: string): Promise<Data> => { ... }
+ * })
+ * ```
+ */
+declare function defineIpc<T extends IpcHandlerMap>(handlers: T): T;
+declare function defineIpc<T extends IpcHandlerMap>(moduleName: string, handlers: T): T;
+/**
+ * 事件处理器配置项
+ */
+interface EventHandlerConfig {
+    /** 事件数据类型范例 — 只用于类型推断，不会在运行时执行 */
+    sample: (data: any) => any;
+    /** 是否只监听一次 */
+    once?: boolean;
+    /** remove 方法类型 */
+    remove?: 'single' | 'all' | 'both' | false;
+}
+/**
+ * 事件处理器映射对象类型
+ */
+type EventHandlerMap = Record<string, ((data: any) => any) | EventHandlerConfig>;
+/**
+ * 定义事件处理器（编译时标记 + 运行时标识返回）
+ *
+ * 编译时：EasyPreloadGenerator 通过 AST 解析此调用，提取事件名、数据类型、remove 模式等
+ * 运行时：原样返回 events 对象，供 EventManager 批量注册
+ *
+ * @example 无模块名
+ * ```ts
+ * export default defineEvents({
+ *   onDownloadProgress: {
+ *     handler: (data: DownloadProgressData) => data,
+ *     remove: 'single'
+ *   }
+ * })
+ * ```
+ *
+ * @example 有模块名
+ * ```ts
+ * export default defineEvents('notification', {
+ *   onMessage: {
+ *     handler: (data: MessageData) => data,
+ *     remove: 'both'
+ *   }
+ * })
+ * ```
+ */
+declare function defineEvents<T extends EventHandlerMap>(handlers: T): T;
+declare function defineEvents<T extends EventHandlerMap>(moduleName: string, handlers: T): T;
+
+export { EVENT_MODULE_KEY, IPC_MODULE_KEY, defineEvents, defineIpc };
+export type { EventHandlerConfig, EventHandlerMap, IpcHandleFunction, IpcHandlerConfig, IpcHandlerMap, IpcHandlerValue, IpcOnFunction };

package/dist/runtime-entry.d.ts

@@ -0,0 +1,106 @@
+import { IpcMainInvokeEvent } from 'electron';
+
+/**
+ * defineIpc 返回值上附加模块名的 Symbol 键
+ * 与 core 包的 IpcManager 共享，用于自动提取模块名
+ */
+declare const IPC_MODULE_KEY: unique symbol;
+/**
+ * defineEvents 返回值上附加模块名的 Symbol 键
+ * 与 core 包的 EventManager 共享，用于自动提取模块名
+ */
+declare const EVENT_MODULE_KEY: unique symbol;
+/**
+ * IPC 处理器类型 — 标准 invoke/handle 模式
+ */
+type IpcHandleFunction = (event: IpcMainInvokeEvent, ...args: any[]) => any | Promise<any>;
+/**
+ * IPC 处理器类型 — on 模式（单向通信，不返回值）
+ */
+type IpcOnFunction = (event: IpcMainInvokeEvent, ...args: any[]) => void;
+/**
+ * 单个 IPC 处理器的配置项
+ */
+interface IpcHandlerConfig {
+    /** 处理器类型 */
+    type: 'handle' | 'on' | 'handleOnce' | 'once';
+    /** 处理器函数 */
+    handler: IpcHandleFunction | IpcOnFunction;
+}
+/**
+ * defineIpc 可以接收的处理器值类型
+ */
+type IpcHandlerValue = IpcHandleFunction | IpcOnFunction | IpcHandlerConfig;
+/**
+ * IPC 处理器映射对象类型
+ */
+type IpcHandlerMap = Record<string, IpcHandlerValue>;
+/**
+ * 定义 IPC 处理器（编译时标记 + 运行时标识返回）
+ *
+ * 编译时：EasyPreloadGenerator 通过 AST 解析此调用，提取处理器名称、参数类型、返回类型
+ * 运行时：原样返回 handlers 对象，供 IpcManager.registerHandlers() 批量注册
+ *
+ * @example 无模块名 — 直接定义处理器
+ * ```ts
+ * export default defineIpc({
+ *   ping: async () => 'pong',
+ *   setUser(_event, user: UserInfo) { ... }
+ * })
+ * ```
+ *
+ * @example 有模块名 — 嵌套在模块下
+ * ```ts
+ * export default defineIpc('test', {
+ *   getData: async (_event, id: string): Promise<Data> => { ... }
+ * })
+ * ```
+ */
+declare function defineIpc<T extends IpcHandlerMap>(handlers: T): T;
+declare function defineIpc<T extends IpcHandlerMap>(moduleName: string, handlers: T): T;
+/**
+ * 事件处理器配置项
+ */
+interface EventHandlerConfig {
+    /** 事件数据类型范例 — 只用于类型推断，不会在运行时执行 */
+    sample: (data: any) => any;
+    /** 是否只监听一次 */
+    once?: boolean;
+    /** remove 方法类型 */
+    remove?: 'single' | 'all' | 'both' | false;
+}
+/**
+ * 事件处理器映射对象类型
+ */
+type EventHandlerMap = Record<string, ((data: any) => any) | EventHandlerConfig>;
+/**
+ * 定义事件处理器（编译时标记 + 运行时标识返回）
+ *
+ * 编译时：EasyPreloadGenerator 通过 AST 解析此调用，提取事件名、数据类型、remove 模式等
+ * 运行时：原样返回 events 对象，供 EventManager 批量注册
+ *
+ * @example 无模块名
+ * ```ts
+ * export default defineEvents({
+ *   onDownloadProgress: {
+ *     handler: (data: DownloadProgressData) => data,
+ *     remove: 'single'
+ *   }
+ * })
+ * ```
+ *
+ * @example 有模块名
+ * ```ts
+ * export default defineEvents('notification', {
+ *   onMessage: {
+ *     handler: (data: MessageData) => data,
+ *     remove: 'both'
+ *   }
+ * })
+ * ```
+ */
+declare function defineEvents<T extends EventHandlerMap>(handlers: T): T;
+declare function defineEvents<T extends EventHandlerMap>(moduleName: string, handlers: T): T;
+
+export { EVENT_MODULE_KEY, IPC_MODULE_KEY, defineEvents, defineIpc };
+export type { EventHandlerConfig, EventHandlerMap, IpcHandleFunction, IpcHandlerConfig, IpcHandlerMap, IpcHandlerValue, IpcOnFunction };

package/dist/runtime-entry.mjs

@@ -0,0 +1,2 @@
+export { E as EVENT_MODULE_KEY, I as IPC_MODULE_KEY, d as defineEvents, a as defineIpc } from './shared/preload.CkLc48BZ.mjs';
+import '@easy-electron/utils';

package/dist/shared/preload.CkLc48BZ.mjs

@@ -0,0 +1,24 @@
+import { ipcRegistry } from '@easy-electron/utils';
+
+const IPC_MODULE_KEY = Symbol.for("easy-electron:ipc-module");
+const EVENT_MODULE_KEY = Symbol.for("easy-electron:event-module");
+function defineIpc(moduleNameOrHandlers, maybeHandlers) {
+  if (typeof moduleNameOrHandlers === "string") {
+    maybeHandlers[IPC_MODULE_KEY] = moduleNameOrHandlers;
+    ipcRegistry.add(maybeHandlers, moduleNameOrHandlers);
+    return maybeHandlers;
+  }
+  ipcRegistry.add(moduleNameOrHandlers);
+  return moduleNameOrHandlers;
+}
+function defineEvents(moduleNameOrHandlers, maybeHandlers) {
+  if (typeof moduleNameOrHandlers === "string") {
+    maybeHandlers[EVENT_MODULE_KEY] = moduleNameOrHandlers;
+    ipcRegistry.add(maybeHandlers, moduleNameOrHandlers);
+    return maybeHandlers;
+  }
+  ipcRegistry.add(moduleNameOrHandlers);
+  return moduleNameOrHandlers;
+}
+
+export { EVENT_MODULE_KEY as E, IPC_MODULE_KEY as I, defineIpc as a, defineEvents as d };

package/dist/shared/preload.OqYa61Ym.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const utils = require('@easy-electron/utils');
+
+const IPC_MODULE_KEY = Symbol.for("easy-electron:ipc-module");
+const EVENT_MODULE_KEY = Symbol.for("easy-electron:event-module");
+function defineIpc(moduleNameOrHandlers, maybeHandlers) {
+  if (typeof moduleNameOrHandlers === "string") {
+    maybeHandlers[IPC_MODULE_KEY] = moduleNameOrHandlers;
+    utils.ipcRegistry.add(maybeHandlers, moduleNameOrHandlers);
+    return maybeHandlers;
+  }
+  utils.ipcRegistry.add(moduleNameOrHandlers);
+  return moduleNameOrHandlers;
+}
+function defineEvents(moduleNameOrHandlers, maybeHandlers) {
+  if (typeof moduleNameOrHandlers === "string") {
+    maybeHandlers[EVENT_MODULE_KEY] = moduleNameOrHandlers;
+    utils.ipcRegistry.add(maybeHandlers, moduleNameOrHandlers);
+    return maybeHandlers;
+  }
+  utils.ipcRegistry.add(moduleNameOrHandlers);
+  return moduleNameOrHandlers;
+}
+
+exports.EVENT_MODULE_KEY = EVENT_MODULE_KEY;
+exports.IPC_MODULE_KEY = IPC_MODULE_KEY;
+exports.defineEvents = defineEvents;
+exports.defineIpc = defineIpc;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@easy-electron/preload",
+  "version": "1.0.1-alpha.1",
+  "description": "A framework that makes using Electron easier.",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "typings": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./runtime": {
+      "require": "./dist/runtime-entry.cjs",
+      "import": "./dist/runtime-entry.mjs",
+      "types": "./dist/runtime-entry.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "electron",
+    "easy"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "fast-glob": "^3.3.3",
+    "@easy-electron/logger": "1.0.1-alpha.1",
+    "@easy-electron/utils": "1.0.1-alpha.1",
+    "@easy-electron/ts-parser": "1.0.1-alpha.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "electron": ">=28.0.0"
+  },
+  "peerDependenciesMeta": {
+    "electron": {
+      "optional": false
+    }
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "start": "node dist/index.cjs",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}