@moeru/eventa 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RainbowBird
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,286 @@
+# `eventa`
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+[![License][license-src]][license-href]
+
+Transport-aware events powering ergonomic RPC and streaming flows.
+
+> Heavily inspired by pragmatic RPC flows, but centred on pure events so transports stay swappable.
+
+> [!WARNING]
+> Eventa forwards whatever payload you emit. Validate data at the edges before sending it to untrusted peers.
+
+## Installation
+
+```sh
+npm install @moeru/eventa
+pnpm i @moeru/eventa
+bun i @moeru/eventa
+ni @moeru/eventa
+yarn add @moeru/eventa
+```
+
+## Getting Started
+
+### Event
+
+It's very simple:
+
+- `defineEventa`: all event should be defined with this util, it produces type safe constraints
+- `context`: a channel bridges to peers (Electron, Worker, WebSocket Peer, you name it)
+- `createContext`: to wrap any compatible event listener
+
+If you need only events without RPC mechanism, then use with `context.emit(...)` and `context.on(...)`
+
+```ts
+import { createContext, defineEventa } from '@moeru/eventa'
+
+const move = defineEventa<{ x: number, y: number }>()
+const ctx = createContext()
+
+ctx.emit(move, { x: 100, y: 200 })
+ctx.on(move, ({ body }) => console.log(body.x, body.y))
+```
+
+### RPC/Stream RPC
+
+Events can be seen as packets transferring in networks, so we can use pure event to form a RPC/Stream RPC like how gRPC and tRPC works.
+
+- `defineInvokeEventa`: define types of RPC/Stream RPC
+- `defineInvoke`: this produce a `function` returns `Promise` for your RPC call to be used later, you can store and use it everywhere you want
+- `defineInvokeHandler`: similar to how Nuxt, h3 defines their handler, we use `defineInvokeHandler` to hook a auto
+- `defineStreamInvokeHandler`: similar to gRPC, when one RPC invocation produces not only one response, but multiple intermediate events, you may want to use it
+
+#### Simple Example
+
+The most simple way to show how it works:
+
+```ts
+import { createContext, defineInvoke, defineInvokeEventa, defineInvokeHandler } from '@moeru/eventa'
+
+const ctx = createContext()
+const someMethodDefine = defineInvokeEventa<{ output: string }, { input: number }>('random name')
+defineInvokeHandler(ctx, someMethodDefine, ({ input }) => ({ output: String(input) }))
+
+const someMethod = defineInvoke(ctx, someMethodDefine)
+console.log(await someMethod(42)) // => { output: '42' }
+```
+
+### Adapters
+
+Eventa comes with various adapters for common use scenarios across browsers and Node.js, escalating the event orchestration in Electron, Web Workers, and WebSockets, etc.
+
+<details>
+  <summary>Electron</summary>
+
+  1. Create a shared events module:
+      ```ts
+      import { defineInvokeEventa } from '@moeru/eventa'
+
+      export const readdir = defineInvokeEventa<{ directories: string[] }, { cwd: string, target: string }>('rpc:node:fs/promise:readdir')
+      ```
+
+  2. In the main process, bridge the adapter to `ipcMain` and your `BrowserWindow` instance:
+     ```ts
+     import { createContext as createMainContext } from '@moeru/eventa/adapters/electron/main'
+     import { app, BrowserWindow, ipcMain } from 'electron'
+
+     import { readdir } from './events/readdir'
+
+     app.on('ready', () => {
+       // ... other code
+       const { context: mainCtx } = createMainContext(ipcMain, mainWindow.webContents)
+       defineInvokeHandler(mainCtx, readdir, async ({ cwd, target }) => {
+         const fs = await import('node:fs/promises')
+         const path = await import('node:path')
+         const fullPath = path.resolve(cwd, target)
+         const directories = await fs.readdir(fullPath, { withFileTypes: true })
+         return { directories: directories.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name) }
+       })
+     })
+     ```
+  3. In the renderer (not restricted to preload scripts, but recommended), bridge to `ipcRenderer` and expose a safe API:
+     ```ts
+     import { createContext as createRendererContext } from '@moeru/eventa/adapters/electron/renderer'
+     import { contextBridge, ipcRenderer } from 'electron'
+
+     import { defineInvoke, readdir } from './events/readdir'
+
+     const { context: rendererCtx } = createRendererContext(ipcRenderer)
+     const invokeReaddir = defineInvoke(rendererCtx, readdir)
+
+     document.addEventListener('DOMContentLoaded', () => {
+       invokeReaddir({ cwd: '/', target: 'usr' }).then((result) => {
+         console.log('directories', result.directories)
+       })
+     })
+     ```
+  4. The main and renderer contexts now share the invoke pipeline used throughout the examples in `src/adapters/electron/*.test.ts`.
+
+</details>
+
+<details>
+  <summary>Web Worker</summary>
+
+  1. Spawn the worker and wrap it with the main-thread adapter:
+      ```ts
+      import Worker from 'web-worker'
+
+      import { createContext, defineInvoke, defineInvokeEventa } from '@moeru/eventa/adapters/webworkers'
+
+      const worker = new Worker(new URL('./worker.js', import.meta.url), { type: 'module' })
+      const { context: mainCtx } = createContext(worker)
+
+      export const syncEvents = defineInvokeEventa<{ status: string }, { jobId: string }>('worker:sync')
+      export const invokeSync = defineInvoke(mainCtx, syncEvents)
+      ```
+  2. Inside the worker entry, create the worker context and register handlers:
+     ```ts
+     import { defineInvokeHandler } from '@moeru/eventa'
+     import { createContext } from '@moeru/eventa/adapters/webworkers/worker'
+
+     import { syncEvents } from '../sync'
+
+     const { context: workerCtx } = createContext()
+     defineInvokeHandler(workerCtx, syncEvents, ({ jobId }) => ({ status: `synced ${jobId}` }))
+     ```
+  3. The same pattern works for streaming handlers and for sending transferrable(s) by switching to `defineStreamInvoke` or `defineOutboundWorkerEventa` as shown in `src/adapters/webworkers/index.spec.ts`.
+
+</details>
+
+<details>
+  <summary>WebSocket (Client)</summary>
+
+  1. Open a `WebSocket` and wrap it with the native adapter:
+      ```ts
+      import { defineInvoke, defineInvokeEventa } from '@moeru/eventa'
+      import { createContext as createWsContext } from '@moeru/eventa/adapters/websocket/native'
+
+      const socket = new WebSocket('wss://example.com/ws')
+      const { context: wsCtx } = createWsContext(socket)
+
+      const chatEvents = defineInvokeEventa<{ message: string }, { text: string }>('chat:send')
+      export const sendChat = defineInvoke(wsCtx, chatEvents)
+      ```
+  2. Listen for connection lifecycle events to update UI state or retry logic:
+     ```ts
+     import { wsConnectedEvent, wsDisconnectedEvent } from '@moeru/eventa/adapters/websocket/native'
+
+     wsCtx.on(wsConnectedEvent, () => console.log('connected'))
+     wsCtx.on(wsDisconnectedEvent, () => console.log('disconnected'))
+     ```
+  3. Pair the client with either the H3 global or peer adapter on the server for a full RPC channel (`src/adapters/websocket/h3/*.test.ts`).
+
+</details>
+
+<details>
+  <summary>WebSocket (Server with H3)</summary>
+
+  ```ts
+  import { defineInvoke, defineInvokeHandler } from '@moeru/eventa'
+  // we support h3 by default, you can implement whatever you want, it's simple
+  import { createContext } from '@moeru/eventa/adapters/websocket/h3'
+
+  const chatEvents = defineInvokeEventa<{ message: string }, { text: string }>('chat:send')
+
+  const app = new H3()
+  const { untilLeastOneConnected, hooks } = createPeerHooks()
+  app.get('/ws', defineWebSocketHandler(hooks))
+
+  const { context } = await untilLeastOneConnected
+  defineInvokeHandler(context, chatEvents, ({ text: string }) => {
+    // you can safely throw any error you want, you can even make the error type safe when using `defineInvoke`
+    return { message: `Echo: ${text}` }
+  })
+  ```
+</details>
+
+### Advanced Usage
+
+#### Streaming RPC
+
+`defineInvokeHandler` is complemented by `defineStreamInvokeHandler` for long-running operations that need to report progress or intermediate results.
+
+```ts
+import { createContext, defineInvokeEventa, defineStreamInvoke, defineStreamInvokeHandler, toStreamHandler } from '@moeru/eventa'
+
+const ctx = createContext()
+const syncEvents = defineInvokeEventa<
+  { type: 'progress' | 'result', value: number },
+  { jobId: string }
+>('rpc:sync')
+
+// toStreamHelper converts an async function into an async generator
+// so you can use imperative code instead of a generator function.
+defineStreamInvokeHandler(ctx, syncEvents, toStreamHandler(async ({ payload, emit }) => {
+  emit({ type: 'progress', value: 0 })
+  for (let i = 1; i <= 5; i++) {
+    emit({ type: 'progress', value: i * 20 })
+  }
+  emit({ type: 'result', value: 100 })
+}))
+
+const sync = defineStreamInvoke(ctx, syncEvents)
+for await (const update of sync({ jobId: 'import' })) {
+  console.log(update.type, update.value)
+}
+```
+
+Both generator-style and imperative handlers are exercised in `src/stream.spec.ts:7`.
+
+#### Shorthands for `defineInvokeHandler` and `defineInvoke`
+
+When you have multiple invoke events to register handlers for, or to create invoke functions for, you can use `defineInvokeHandlers` and `defineInvokes` to do so in bulk.
+
+```ts
+const events = {
+  double: defineInvokeEventa<number, number>(),
+  append: defineInvokeEventa<string, string>(),
+}
+
+defineInvokeHandlers(ctx, events, {
+  double: input => input * 2,
+  append: input => `${input}!`,
+})
+
+const {
+  double: invokeDouble,
+  append: invokeAppend,
+} = defineInvokes(ctx, events)
+
+await invokeDouble(5) // 10
+await invokeAppend('test') // 'test!'
+```
+
+## Development
+
+```sh
+pnpm i
+pnpm test
+```
+
+> [!NOTE]
+> `pnpm test` runs Vitest interactively. Use `pnpm test:run` for a single pass.
+
+## Similar projects
+
+- [`birpc`](https://github.com/antfu-collective/birpc): We dislike the way the API designs, we want fully free sharable invok-able functions
+- [`async-call-rpc`](https://github.com/Jack-Works/async-call-rpc): it only works with JSON-RPC, but the DX is similar
+
+## License
+
+MIT
+
+[npm-version-src]: https://img.shields.io/npm/v/@moeru/eventa?style=flat&colorA=080f12&colorB=1fa669
+[npm-version-href]: https://npmjs.com/package/@moeru/eventa
+[npm-downloads-src]: https://img.shields.io/npm/dm/@moeru/eventa?style=flat&colorA=080f12&colorB=1fa669
+[npm-downloads-href]: https://npmjs.com/package/@moeru/eventa
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/@moeru/eventa?style=flat&colorA=080f12&colorB=1fa669&label=minzip
+[bundle-href]: https://bundlephobia.com/result?p=@moeru/eventa
+[license-src]: https://img.shields.io/github/license/moeru-ai/eventa.svg?style=flat&colorA=080f12&colorB=1fa669
+[license-href]: https://github.com/moeru-ai/eventa/blob/main/LICENSE
+[jsdocs-src]: https://img.shields.io/badge/jsdocs-reference-080f12?style=flat&colorA=080f12&colorB=1fa669
+[jsdocs-href]: https://www.jsdocs.io/package/@moeru/eventa

package/dist/adapters/electron/main.d.mts

@@ -0,0 +1,26 @@
+import "../../eventa-B2HPBK4S.mjs";
+import { EventContext } from "../../context-C_-MRU46.mjs";
+import "../../invoke-LTUFMmHi.mjs";
+import "../../index-BgaYNgPh.mjs";
+import { Payload, errorEvent } from "../../shared-DllZ3RPS.mjs";
+import { BrowserWindow, IpcMain, IpcMainEvent } from "electron";
+
+//#region src/adapters/electron/main.d.ts
+declare function createContext(ipcMain: IpcMain, window?: BrowserWindow, options?: {
+  onlySameWindow?: boolean;
+  messageEventName?: string | false;
+  errorEventName?: string | false;
+  extraListeners?: Record<string, (_: any, event: Event) => void | Promise<void>>;
+  throwIfFailedToSend?: boolean;
+}): {
+  context: EventContext<any, {
+    raw: {
+      ipcMainEvent: IpcMainEvent;
+      event: Event | unknown;
+    };
+  }>;
+  dispose: () => void;
+};
+//#endregion
+export { Payload, createContext, errorEvent };
+//# sourceMappingURL=main.d.mts.map

package/dist/adapters/electron/main.mjs

@@ -0,0 +1,67 @@
+import { EventaFlowDirection, and, createContext as createContext$1, defineInboundEventa, defineOutboundEventa, matchBy } from "../../context-C35Qku9U.mjs";
+import "../../src-Bb-vxm5k.mjs";
+import { errorEvent, generatePayload, parsePayload } from "../../shared-Da41l-vp.mjs";
+
+//#region src/adapters/electron/main.ts
+function withRemoval(ipcMain, type, listener) {
+	ipcMain.on(type, listener);
+	return { remove: () => {
+		ipcMain.off(type, listener);
+	} };
+}
+function createContext(ipcMain, window, options) {
+	const ctx = createContext$1();
+	const { messageEventName = "eventa-message", errorEventName = "eventa-error", extraListeners = {}, onlySameWindow = false } = options || {};
+	const cleanupRemoval = [];
+	ctx.on(and(matchBy("*"), matchBy((e) => e._flowDirection === EventaFlowDirection.Outbound || !e._flowDirection)), (event, options$1) => {
+		const eventBody = generatePayload(event.id, {
+			...defineOutboundEventa(event.type),
+			...event
+		});
+		if (messageEventName !== false) try {
+			if (window != null) {
+				if (window.isDestroyed()) return;
+				if (onlySameWindow) {
+					if (window.webContents.id === options$1?.raw.ipcMainEvent.sender.id) window?.webContents?.send(messageEventName, eventBody);
+				} else window?.webContents?.send(messageEventName, eventBody);
+			} else {
+				if (options$1?.raw.ipcMainEvent.sender.isDestroyed()) return;
+				options$1?.raw.ipcMainEvent.sender.send(messageEventName, eventBody);
+			}
+		} catch (error) {
+			if (!(error instanceof Error) || error?.message !== "Object has been destroyed") throw error;
+		}
+	});
+	if (messageEventName) cleanupRemoval.push(withRemoval(ipcMain, messageEventName, (ipcMainEvent, event) => {
+		try {
+			const { type, payload } = parsePayload(event);
+			ctx.emit(defineInboundEventa(type), payload.body, { raw: {
+				ipcMainEvent,
+				event
+			} });
+		} catch (error) {
+			console.error("Failed to parse IpcMain message:", error);
+			ctx.emit(errorEvent, { error }, { raw: {
+				ipcMainEvent,
+				event
+			} });
+		}
+	}));
+	if (errorEventName) cleanupRemoval.push(withRemoval(ipcMain, errorEventName, (ipcMainEvent, error) => {
+		ctx.emit(errorEvent, { error }, { raw: {
+			ipcMainEvent,
+			event: error
+		} });
+	}));
+	for (const [eventName, listener] of Object.entries(extraListeners)) cleanupRemoval.push(withRemoval(ipcMain, eventName, listener));
+	return {
+		context: ctx,
+		dispose: () => {
+			cleanupRemoval.forEach((removal) => removal.remove());
+		}
+	};
+}
+
+//#endregion
+export { createContext };
+//# sourceMappingURL=main.mjs.map

package/dist/adapters/electron/main.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.mjs","names":["createBaseContext","cleanupRemoval: Array<{ remove: () => void }>","options"],"sources":["../../../src/adapters/electron/main.ts"],"sourcesContent":["import type { BrowserWindow, IpcMain, IpcMainEvent } from 'electron'\n\nimport type { EventContext } from '../../context'\nimport type { DirectionalEventa, Eventa } from '../../eventa'\n\nimport { createContext as createBaseContext } from '../../context'\nimport { and, defineInboundEventa, defineOutboundEventa, EventaFlowDirection, matchBy } from '../../eventa'\nimport { generatePayload, parsePayload } from './internal'\nimport { errorEvent } from './shared'\n\nfunction withRemoval(ipcMain: IpcMain, type: string, listener: Parameters<IpcMain['on']>[1]) {\n  ipcMain.on(type, listener)\n\n  return {\n    remove: () => {\n      ipcMain.off(type, listener)\n    },\n  }\n}\n\nexport function createContext(ipcMain: IpcMain, window?: BrowserWindow, options?: {\n  onlySameWindow?: boolean\n  messageEventName?: string | false\n  errorEventName?: string | false\n  extraListeners?: Record<string, (_, event: Event) => void | Promise<void>>\n  throwIfFailedToSend?: boolean\n}) {\n  const ctx = createBaseContext() as EventContext<any, { raw: { ipcMainEvent: IpcMainEvent, event: Event | unknown } }>\n\n  const {\n    messageEventName = 'eventa-message',\n    errorEventName = 'eventa-error',\n    extraListeners = {},\n    onlySameWindow = false,\n  } = options || {}\n\n  const cleanupRemoval: Array<{ remove: () => void }> = []\n\n  ctx.on(and(\n    matchBy('*'),\n    matchBy((e: DirectionalEventa<any>) => e._flowDirection === EventaFlowDirection.Outbound || !e._flowDirection),\n  ), (event, options) => {\n    const eventBody = generatePayload(event.id, { ...defineOutboundEventa(event.type), ...event })\n    if (messageEventName !== false) {\n      try {\n        if (window != null) {\n          if (window.isDestroyed()) {\n            return\n          }\n\n          if (onlySameWindow) {\n            if (window.webContents.id === options?.raw.ipcMainEvent.sender.id) {\n              window?.webContents?.send(messageEventName, eventBody)\n            }\n          }\n          else {\n            window?.webContents?.send(messageEventName, eventBody)\n          }\n        }\n        else {\n          if (options?.raw.ipcMainEvent.sender.isDestroyed()) {\n            return\n          }\n\n          options?.raw.ipcMainEvent.sender.send(messageEventName, eventBody)\n        }\n      }\n      catch (error) {\n        // NOTICE: Electron may throw if the window is closed before sending\n        // ignore the error if it's about destroyed object\n        if (!(error instanceof Error) || error?.message !== 'Object has been destroyed') {\n          throw error\n        }\n      }\n    }\n  })\n\n  if (messageEventName) {\n    cleanupRemoval.push(withRemoval(ipcMain, messageEventName, (ipcMainEvent, event: Event | unknown) => {\n      try {\n        const { type, payload } = parsePayload<Eventa<any>>(event)\n        ctx.emit(defineInboundEventa(type), payload.body, { raw: { ipcMainEvent, event } })\n      }\n      catch (error) {\n        console.error('Failed to parse IpcMain message:', error)\n        ctx.emit(errorEvent, { error }, { raw: { ipcMainEvent, event } })\n      }\n    }))\n  }\n\n  if (errorEventName) {\n    cleanupRemoval.push(withRemoval(ipcMain, errorEventName, (ipcMainEvent, error: Event | unknown) => {\n      ctx.emit(errorEvent, { error }, { raw: { ipcMainEvent, event: error } })\n    }))\n  }\n\n  for (const [eventName, listener] of Object.entries(extraListeners)) {\n    cleanupRemoval.push(withRemoval(ipcMain, eventName, listener))\n  }\n\n  return {\n    context: ctx,\n    dispose: () => {\n      cleanupRemoval.forEach(removal => removal.remove())\n    },\n  }\n}\n\nexport type * from './shared'\n"],"mappings":";;;;;AAUA,SAAS,YAAY,SAAkB,MAAc,UAAwC;AAC3F,SAAQ,GAAG,MAAM,SAAS;AAE1B,QAAO,EACL,cAAc;AACZ,UAAQ,IAAI,MAAM,SAAS;IAE9B;;AAGH,SAAgB,cAAc,SAAkB,QAAwB,SAMrE;CACD,MAAM,MAAMA,iBAAmB;CAE/B,MAAM,EACJ,mBAAmB,kBACnB,iBAAiB,gBACjB,iBAAiB,EAAE,EACnB,iBAAiB,UACf,WAAW,EAAE;CAEjB,MAAMC,iBAAgD,EAAE;AAExD,KAAI,GAAG,IACL,QAAQ,IAAI,EACZ,SAAS,MAA8B,EAAE,mBAAmB,oBAAoB,YAAY,CAAC,EAAE,eAAe,CAC/G,GAAG,OAAO,cAAY;EACrB,MAAM,YAAY,gBAAgB,MAAM,IAAI;GAAE,GAAG,qBAAqB,MAAM,KAAK;GAAE,GAAG;GAAO,CAAC;AAC9F,MAAI,qBAAqB,MACvB,KAAI;AACF,OAAI,UAAU,MAAM;AAClB,QAAI,OAAO,aAAa,CACtB;AAGF,QAAI,gBACF;SAAI,OAAO,YAAY,OAAOC,WAAS,IAAI,aAAa,OAAO,GAC7D,SAAQ,aAAa,KAAK,kBAAkB,UAAU;UAIxD,SAAQ,aAAa,KAAK,kBAAkB,UAAU;UAGrD;AACH,QAAIA,WAAS,IAAI,aAAa,OAAO,aAAa,CAChD;AAGF,eAAS,IAAI,aAAa,OAAO,KAAK,kBAAkB,UAAU;;WAG/D,OAAO;AAGZ,OAAI,EAAE,iBAAiB,UAAU,OAAO,YAAY,4BAClD,OAAM;;GAIZ;AAEF,KAAI,iBACF,gBAAe,KAAK,YAAY,SAAS,mBAAmB,cAAc,UAA2B;AACnG,MAAI;GACF,MAAM,EAAE,MAAM,YAAY,aAA0B,MAAM;AAC1D,OAAI,KAAK,oBAAoB,KAAK,EAAE,QAAQ,MAAM,EAAE,KAAK;IAAE;IAAc;IAAO,EAAE,CAAC;WAE9E,OAAO;AACZ,WAAQ,MAAM,oCAAoC,MAAM;AACxD,OAAI,KAAK,YAAY,EAAE,OAAO,EAAE,EAAE,KAAK;IAAE;IAAc;IAAO,EAAE,CAAC;;GAEnE,CAAC;AAGL,KAAI,eACF,gBAAe,KAAK,YAAY,SAAS,iBAAiB,cAAc,UAA2B;AACjG,MAAI,KAAK,YAAY,EAAE,OAAO,EAAE,EAAE,KAAK;GAAE;GAAc,OAAO;GAAO,EAAE,CAAC;GACxE,CAAC;AAGL,MAAK,MAAM,CAAC,WAAW,aAAa,OAAO,QAAQ,eAAe,CAChE,gBAAe,KAAK,YAAY,SAAS,WAAW,SAAS,CAAC;AAGhE,QAAO;EACL,SAAS;EACT,eAAe;AACb,kBAAe,SAAQ,YAAW,QAAQ,QAAQ,CAAC;;EAEtD"}

package/dist/adapters/electron/renderer.d.mts

@@ -0,0 +1,24 @@
+import "../../eventa-B2HPBK4S.mjs";
+import { EventContext } from "../../context-C_-MRU46.mjs";
+import "../../invoke-LTUFMmHi.mjs";
+import "../../index-BgaYNgPh.mjs";
+import { Payload, errorEvent } from "../../shared-DllZ3RPS.mjs";
+import { IpcRenderer, IpcRendererListener } from "@electron-toolkit/preload";
+
+//#region src/adapters/electron/renderer.d.ts
+declare function createContext(ipcRenderer: IpcRenderer, options?: {
+  messageEventName?: string | false;
+  errorEventName?: string | false;
+  extraListeners?: Record<string, IpcRendererListener>;
+}): {
+  context: EventContext<any, {
+    raw: {
+      ipcRendererEvent: Electron.IpcRendererEvent;
+      event: Event | unknown;
+    };
+  }>;
+  dispose: () => void;
+};
+//#endregion
+export { Payload, createContext, errorEvent };
+//# sourceMappingURL=renderer.d.mts.map

package/dist/adapters/electron/renderer.mjs

@@ -0,0 +1,53 @@
+import { EventaFlowDirection, and, createContext as createContext$1, defineInboundEventa, defineOutboundEventa, matchBy } from "../../context-C35Qku9U.mjs";
+import "../../src-Bb-vxm5k.mjs";
+import { errorEvent, generatePayload, parsePayload } from "../../shared-Da41l-vp.mjs";
+
+//#region src/adapters/electron/renderer.ts
+function createContext(ipcRenderer, options) {
+	const ctx = createContext$1();
+	const { messageEventName = "eventa-message", errorEventName = "eventa-error", extraListeners = {} } = options || {};
+	const cleanupRemoval = [];
+	ctx.on(and(matchBy((e) => e._flowDirection === EventaFlowDirection.Outbound || !e._flowDirection), matchBy("*")), (event) => {
+		const eventBody = generatePayload(event.id, {
+			...defineOutboundEventa(event.type),
+			...event
+		});
+		if (messageEventName !== false) try {
+			ipcRenderer.send(messageEventName, eventBody);
+		} catch (error) {
+			if (!(error instanceof Error) || error?.message !== "Object has been destroyed") throw error;
+		}
+	});
+	if (messageEventName) ipcRenderer.on(messageEventName, (ipcRendererEvent, event) => {
+		try {
+			const { type, payload } = parsePayload(event);
+			ctx.emit(defineInboundEventa(type), payload.body, { raw: {
+				ipcRendererEvent,
+				event
+			} });
+		} catch (error) {
+			console.error("Failed to parse IpcRenderer message:", error);
+			ctx.emit(errorEvent, { error }, { raw: {
+				ipcRendererEvent,
+				event
+			} });
+		}
+	});
+	if (errorEventName) ipcRenderer.on(errorEventName, (ipcRendererEvent, error) => {
+		ctx.emit(errorEvent, { error }, { raw: {
+			ipcRendererEvent,
+			event: error
+		} });
+	});
+	for (const [eventName, listener] of Object.entries(extraListeners)) ipcRenderer.on(eventName, listener);
+	return {
+		context: ctx,
+		dispose: () => {
+			cleanupRemoval.forEach((removal) => removal.remove());
+		}
+	};
+}
+
+//#endregion
+export { createContext };
+//# sourceMappingURL=renderer.mjs.map

package/dist/adapters/electron/renderer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.mjs","names":["createBaseContext","cleanupRemoval: Array<{ remove: () => void }>"],"sources":["../../../src/adapters/electron/renderer.ts"],"sourcesContent":["import type { IpcRenderer, IpcRendererListener } from '@electron-toolkit/preload'\n\nimport type { EventContext } from '../../context'\nimport type { DirectionalEventa, Eventa } from '../../eventa'\n\nimport { createContext as createBaseContext } from '../../context'\nimport { and, defineInboundEventa, defineOutboundEventa, EventaFlowDirection, matchBy } from '../../eventa'\nimport { generatePayload, parsePayload } from './internal'\nimport { errorEvent } from './shared'\n\nexport function createContext(ipcRenderer: IpcRenderer, options?: {\n  messageEventName?: string | false\n  errorEventName?: string | false\n  extraListeners?: Record<string, IpcRendererListener>\n}) {\n  const ctx = createBaseContext() as EventContext<any, { raw: { ipcRendererEvent: Electron.IpcRendererEvent, event: Event | unknown } }>\n\n  const {\n    messageEventName = 'eventa-message',\n    errorEventName = 'eventa-error',\n    extraListeners = {},\n  } = options || {}\n\n  const cleanupRemoval: Array<{ remove: () => void }> = []\n\n  ctx.on(and(\n    matchBy((e: DirectionalEventa<any>) => e._flowDirection === EventaFlowDirection.Outbound || !e._flowDirection),\n    matchBy('*'),\n  ), (event) => {\n    const eventBody = generatePayload(event.id, { ...defineOutboundEventa(event.type), ...event })\n    if (messageEventName !== false) {\n      try {\n        ipcRenderer.send(messageEventName, eventBody)\n      }\n      catch (error) {\n        if (!(error instanceof Error) || error?.message !== 'Object has been destroyed') {\n          throw error\n        }\n      }\n    }\n  })\n\n  if (messageEventName) {\n    ipcRenderer.on(messageEventName, (ipcRendererEvent, event) => {\n      try {\n        const { type, payload } = parsePayload<Eventa<any>>(event)\n        ctx.emit(defineInboundEventa(type), payload.body, { raw: { ipcRendererEvent, event } })\n      }\n      catch (error) {\n        console.error('Failed to parse IpcRenderer message:', error)\n        ctx.emit(errorEvent, { error }, { raw: { ipcRendererEvent, event } })\n      }\n    })\n  }\n\n  if (errorEventName) {\n    ipcRenderer.on(errorEventName, (ipcRendererEvent, error) => {\n      ctx.emit(errorEvent, { error }, { raw: { ipcRendererEvent, event: error } })\n    })\n  }\n\n  for (const [eventName, listener] of Object.entries(extraListeners)) {\n    ipcRenderer.on(eventName, listener)\n  }\n\n  return {\n    context: ctx,\n    dispose: () => {\n      cleanupRemoval.forEach(removal => removal.remove())\n    },\n  }\n}\n\nexport type * from './shared'\n"],"mappings":";;;;;AAUA,SAAgB,cAAc,aAA0B,SAIrD;CACD,MAAM,MAAMA,iBAAmB;CAE/B,MAAM,EACJ,mBAAmB,kBACnB,iBAAiB,gBACjB,iBAAiB,EAAE,KACjB,WAAW,EAAE;CAEjB,MAAMC,iBAAgD,EAAE;AAExD,KAAI,GAAG,IACL,SAAS,MAA8B,EAAE,mBAAmB,oBAAoB,YAAY,CAAC,EAAE,eAAe,EAC9G,QAAQ,IAAI,CACb,GAAG,UAAU;EACZ,MAAM,YAAY,gBAAgB,MAAM,IAAI;GAAE,GAAG,qBAAqB,MAAM,KAAK;GAAE,GAAG;GAAO,CAAC;AAC9F,MAAI,qBAAqB,MACvB,KAAI;AACF,eAAY,KAAK,kBAAkB,UAAU;WAExC,OAAO;AACZ,OAAI,EAAE,iBAAiB,UAAU,OAAO,YAAY,4BAClD,OAAM;;GAIZ;AAEF,KAAI,iBACF,aAAY,GAAG,mBAAmB,kBAAkB,UAAU;AAC5D,MAAI;GACF,MAAM,EAAE,MAAM,YAAY,aAA0B,MAAM;AAC1D,OAAI,KAAK,oBAAoB,KAAK,EAAE,QAAQ,MAAM,EAAE,KAAK;IAAE;IAAkB;IAAO,EAAE,CAAC;WAElF,OAAO;AACZ,WAAQ,MAAM,wCAAwC,MAAM;AAC5D,OAAI,KAAK,YAAY,EAAE,OAAO,EAAE,EAAE,KAAK;IAAE;IAAkB;IAAO,EAAE,CAAC;;GAEvE;AAGJ,KAAI,eACF,aAAY,GAAG,iBAAiB,kBAAkB,UAAU;AAC1D,MAAI,KAAK,YAAY,EAAE,OAAO,EAAE,EAAE,KAAK;GAAE;GAAkB,OAAO;GAAO,EAAE,CAAC;GAC5E;AAGJ,MAAK,MAAM,CAAC,WAAW,aAAa,OAAO,QAAQ,eAAe,CAChE,aAAY,GAAG,WAAW,SAAS;AAGrC,QAAO;EACL,SAAS;EACT,eAAe;AACb,kBAAe,SAAQ,YAAW,QAAQ,QAAQ,CAAC;;EAEtD"}

package/dist/adapters/event-emitter/index.d.mts

@@ -0,0 +1,35 @@
+import { EventTag, EventaType } from "../../eventa-B2HPBK4S.mjs";
+import { EventContext } from "../../context-C_-MRU46.mjs";
+import "../../invoke-LTUFMmHi.mjs";
+import "../../index-BgaYNgPh.mjs";
+
+//#region src/adapters/event-emitter/shared.d.ts
+interface Payload<T> {
+  id: string;
+  type: EventTag<any, any>;
+  payload: T;
+}
+declare const errorEvent: {
+  body?: {
+    error: unknown;
+  } | undefined;
+  id: string;
+  type?: EventaType.Event | undefined;
+};
+//#endregion
+//#region src/adapters/event-emitter/index.d.ts
+declare function createContext(eventTarget: NodeJS.EventEmitter, options?: {
+  messageEventName?: string | false;
+  errorEventName?: string | false;
+  extraListeners?: Record<string, (event: Event) => void | Promise<void>>;
+}): {
+  context: EventContext<any, {
+    raw: {
+      event: CustomEvent | Event | unknown;
+    };
+  }>;
+  dispose: () => void;
+};
+//#endregion
+export { Payload, createContext, errorEvent };
+//# sourceMappingURL=index.d.mts.map

package/dist/adapters/event-emitter/index.mjs

@@ -0,0 +1,62 @@
+import { EventaFlowDirection, and, createContext as createContext$1, defineEventa, defineInboundEventa, defineOutboundEventa, matchBy, nanoid } from "../../context-C35Qku9U.mjs";
+import "../../src-Bb-vxm5k.mjs";
+
+//#region src/adapters/event-emitter/internal.ts
+function generatePayload(type, payload) {
+	return {
+		id: nanoid(),
+		type,
+		payload
+	};
+}
+function parsePayload(data) {
+	return data;
+}
+
+//#endregion
+//#region src/adapters/event-emitter/shared.ts
+const errorEvent = { ...defineEventa() };
+
+//#endregion
+//#region src/adapters/event-emitter/index.ts
+function withRemoval(eventTarget, type, listener) {
+	eventTarget.on(type, listener);
+	return { remove: () => {
+		eventTarget.off(type, listener);
+	} };
+}
+function createContext(eventTarget, options) {
+	const ctx = createContext$1();
+	const { messageEventName = "message", errorEventName = "error", extraListeners = {} } = options || {};
+	const cleanupRemoval = [];
+	ctx.on(and(matchBy((e) => e._flowDirection === EventaFlowDirection.Outbound || !e._flowDirection), matchBy("*")), (event) => {
+		const detail = generatePayload(event.id, {
+			...defineOutboundEventa(event.type),
+			...event
+		});
+		eventTarget.emit(event.id, detail);
+	});
+	if (messageEventName) cleanupRemoval.push(withRemoval(eventTarget, messageEventName, (event) => {
+		try {
+			const { type, payload } = parsePayload(event.detail);
+			ctx.emit(defineInboundEventa(type), payload.body, { raw: { event } });
+		} catch (error) {
+			console.error("Failed to parse EventEmitter message:", error);
+			ctx.emit(errorEvent, { error }, { raw: { event } });
+		}
+	}));
+	if (errorEventName) cleanupRemoval.push(withRemoval(eventTarget, errorEventName, (error) => {
+		ctx.emit(errorEvent, { error }, { raw: { event: error } });
+	}));
+	for (const [eventName, listener] of Object.entries(extraListeners)) cleanupRemoval.push(withRemoval(eventTarget, eventName, listener));
+	return {
+		context: ctx,
+		dispose: () => {
+			cleanupRemoval.forEach((removal) => removal.remove());
+		}
+	};
+}
+
+//#endregion
+export { createContext };
+//# sourceMappingURL=index.mjs.map

package/dist/adapters/event-emitter/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["createBaseContext","cleanupRemoval: Array<{ remove: () => void }>"],"sources":["../../../src/adapters/event-emitter/internal.ts","../../../src/adapters/event-emitter/shared.ts","../../../src/adapters/event-emitter/index.ts"],"sourcesContent":["import type { EventTag } from '../..'\nimport type { Payload as CustomEventDetailDetail } from './shared'\n\nimport { nanoid } from '../..'\n\nexport function generatePayload<T>(type: EventTag<any, any>, payload: T): CustomEventDetailDetail<T> {\n  return {\n    id: nanoid(),\n    type,\n    payload,\n  }\n}\n\nexport function parsePayload<T>(data: unknown): CustomEventDetailDetail<T> {\n  return data as CustomEventDetailDetail<T>\n}\n","import type { EventTag } from '../../eventa'\n\nimport { defineEventa } from '../../eventa'\n\nexport interface Payload<T> {\n  id: string\n  type: EventTag<any, any>\n  payload: T\n}\n\nexport const errorEvent = { ...defineEventa<{ error: unknown }>() }\n","import type { EventContext } from '../../context'\nimport type { DirectionalEventa, Eventa } from '../../eventa'\n\nimport { createContext as createBaseContext } from '../../context'\nimport { and, defineInboundEventa, defineOutboundEventa, EventaFlowDirection, matchBy } from '../../eventa'\nimport { generatePayload, parsePayload } from './internal'\nimport { errorEvent } from './shared'\n\nfunction withRemoval(eventTarget: NodeJS.EventEmitter, type: string, listener: Parameters<NodeJS.EventEmitter['on']>[1]) {\n  eventTarget.on(type, listener)\n\n  return {\n    remove: () => {\n      eventTarget.off(type, listener)\n    },\n  }\n}\n\nexport function createContext(eventTarget: NodeJS.EventEmitter, options?: {\n  messageEventName?: string | false\n  errorEventName?: string | false\n  extraListeners?: Record<string, (event: Event) => void | Promise<void>>\n}) {\n  const ctx = createBaseContext() as EventContext<any, { raw: { event: CustomEvent | Event | unknown } }>\n\n  const {\n    messageEventName = 'message',\n    errorEventName = 'error',\n    extraListeners = {},\n  } = options || {}\n\n  const cleanupRemoval: Array<{ remove: () => void }> = []\n\n  ctx.on(and(\n    matchBy((e: DirectionalEventa<any>) => e._flowDirection === EventaFlowDirection.Outbound || !e._flowDirection),\n    matchBy('*'),\n  ), (event) => {\n    const detail = generatePayload(event.id, { ...defineOutboundEventa(event.type), ...event })\n    eventTarget.emit(event.id, detail)\n  })\n\n  if (messageEventName) {\n    cleanupRemoval.push(withRemoval(eventTarget, messageEventName, (event) => {\n      try {\n        const { type, payload } = parsePayload<Eventa<any>>((event as CustomEvent).detail)\n        ctx.emit(defineInboundEventa(type), payload.body, { raw: { event } })\n      }\n      catch (error) {\n        console.error('Failed to parse EventEmitter message:', error)\n        ctx.emit(errorEvent, { error }, { raw: { event } })\n      }\n    }))\n  }\n\n  if (errorEventName) {\n    cleanupRemoval.push(withRemoval(eventTarget, errorEventName, (error) => {\n      ctx.emit(errorEvent, { error }, { raw: { event: error } })\n    }))\n  }\n\n  for (const [eventName, listener] of Object.entries(extraListeners)) {\n    cleanupRemoval.push(withRemoval(eventTarget, eventName, listener))\n  }\n\n  return {\n    context: ctx,\n    dispose: () => {\n      cleanupRemoval.forEach(removal => removal.remove())\n    },\n  }\n}\n\nexport type * from './shared'\n"],"mappings":";;;;AAKA,SAAgB,gBAAmB,MAA0B,SAAwC;AACnG,QAAO;EACL,IAAI,QAAQ;EACZ;EACA;EACD;;AAGH,SAAgB,aAAgB,MAA2C;AACzE,QAAO;;;;;ACJT,MAAa,aAAa,EAAE,GAAG,cAAkC,EAAE;;;;ACFnE,SAAS,YAAY,aAAkC,MAAc,UAAoD;AACvH,aAAY,GAAG,MAAM,SAAS;AAE9B,QAAO,EACL,cAAc;AACZ,cAAY,IAAI,MAAM,SAAS;IAElC;;AAGH,SAAgB,cAAc,aAAkC,SAI7D;CACD,MAAM,MAAMA,iBAAmB;CAE/B,MAAM,EACJ,mBAAmB,WACnB,iBAAiB,SACjB,iBAAiB,EAAE,KACjB,WAAW,EAAE;CAEjB,MAAMC,iBAAgD,EAAE;AAExD,KAAI,GAAG,IACL,SAAS,MAA8B,EAAE,mBAAmB,oBAAoB,YAAY,CAAC,EAAE,eAAe,EAC9G,QAAQ,IAAI,CACb,GAAG,UAAU;EACZ,MAAM,SAAS,gBAAgB,MAAM,IAAI;GAAE,GAAG,qBAAqB,MAAM,KAAK;GAAE,GAAG;GAAO,CAAC;AAC3F,cAAY,KAAK,MAAM,IAAI,OAAO;GAClC;AAEF,KAAI,iBACF,gBAAe,KAAK,YAAY,aAAa,mBAAmB,UAAU;AACxE,MAAI;GACF,MAAM,EAAE,MAAM,YAAY,aAA2B,MAAsB,OAAO;AAClF,OAAI,KAAK,oBAAoB,KAAK,EAAE,QAAQ,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;WAEhE,OAAO;AACZ,WAAQ,MAAM,yCAAyC,MAAM;AAC7D,OAAI,KAAK,YAAY,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;;GAErD,CAAC;AAGL,KAAI,eACF,gBAAe,KAAK,YAAY,aAAa,iBAAiB,UAAU;AACtE,MAAI,KAAK,YAAY,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,OAAO,EAAE,CAAC;GAC1D,CAAC;AAGL,MAAK,MAAM,CAAC,WAAW,aAAa,OAAO,QAAQ,eAAe,CAChE,gBAAe,KAAK,YAAY,aAAa,WAAW,SAAS,CAAC;AAGpE,QAAO;EACL,SAAS;EACT,eAAe;AACb,kBAAe,SAAQ,YAAW,QAAQ,QAAQ,CAAC;;EAEtD"}

package/dist/adapters/event-target/index.d.mts

@@ -0,0 +1,35 @@
+import { EventTag, EventaType } from "../../eventa-B2HPBK4S.mjs";
+import { EventContext } from "../../context-C_-MRU46.mjs";
+import "../../invoke-LTUFMmHi.mjs";
+import "../../index-BgaYNgPh.mjs";
+
+//#region src/adapters/event-target/shared.d.ts
+interface CustomEventDetail<T> {
+  id: string;
+  type: EventTag<any, any>;
+  payload: T;
+}
+declare const workerErrorEvent: {
+  body?: {
+    error: unknown;
+  } | undefined;
+  id: string;
+  type?: EventaType.Event | undefined;
+};
+//#endregion
+//#region src/adapters/event-target/index.d.ts
+declare function createContext(eventTarget: EventTarget, options?: {
+  messageEventName?: string | false;
+  errorEventName?: string | false;
+  extraListeners?: Record<string, (event: Event) => void | Promise<void>>;
+}): {
+  context: EventContext<any, {
+    raw: {
+      event: CustomEvent | Event | unknown;
+    };
+  }>;
+  dispose: () => void;
+};
+//#endregion
+export { CustomEventDetail, createContext, workerErrorEvent };
+//# sourceMappingURL=index.d.mts.map