@moeru/eventa 0.3.0

package/dist/context-C35Qku9U.mjs

@@ -0,0 +1,191 @@
+import isGlobMatch from "picomatch";
+import { customAlphabet } from "nanoid";
+
+//#region src/eventa.ts
+function nanoid() {
+	return customAlphabet("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 16)();
+}
+let EventaType = /* @__PURE__ */ function(EventaType$1) {
+	EventaType$1["Event"] = "event";
+	EventaType$1["MatchExpression"] = "matchExpression";
+	return EventaType$1;
+}({});
+let EventaFlowDirection = /* @__PURE__ */ function(EventaFlowDirection$1) {
+	EventaFlowDirection$1["Inbound"] = "inbound";
+	EventaFlowDirection$1["Outbound"] = "outbound";
+	return EventaFlowDirection$1;
+}({});
+function defineInboundEventa(id) {
+	return {
+		...defineEventa(id),
+		_flowDirection: EventaFlowDirection.Inbound
+	};
+}
+function defineOutboundEventa(id) {
+	return {
+		...defineEventa(id),
+		_flowDirection: EventaFlowDirection.Outbound
+	};
+}
+function defineEventa(id) {
+	if (!id) id = nanoid();
+	return {
+		id,
+		type: EventaType.Event
+	};
+}
+function and(...matchExpression) {
+	return {
+		id: nanoid(),
+		type: EventaType.MatchExpression,
+		matcher: (event) => {
+			return matchExpression.every((m) => m.matcher ? m.matcher(event) : false);
+		}
+	};
+}
+function or(...matchExpression) {
+	return {
+		id: nanoid(),
+		type: EventaType.MatchExpression,
+		matcher: (event) => {
+			return matchExpression.some((m) => m.matcher ? m.matcher(event) : false);
+		}
+	};
+}
+function matchBy(matchExpressionPossibleValues, inverted) {
+	const id = nanoid();
+	let matcher = () => false;
+	if (typeof matchExpressionPossibleValues === "string") matcher = (eventa) => {
+		return isGlobMatch(matchExpressionPossibleValues)(eventa.id);
+	};
+	else if (typeof matchExpressionPossibleValues === "object") {
+		if ("ids" in matchExpressionPossibleValues) matcher = (event) => {
+			if (inverted) return !matchExpressionPossibleValues.ids.includes(event.id);
+			return matchExpressionPossibleValues.ids.includes(event.id);
+		};
+		else if ("eventa" in matchExpressionPossibleValues) matcher = (event) => {
+			if (inverted) return !matchExpressionPossibleValues.eventa.some((e) => e.id === event.id);
+			return matchExpressionPossibleValues.eventa.some((e) => e.id === event.id);
+		};
+		else if ("types" in matchExpressionPossibleValues) matcher = (event) => {
+			if (typeof event.type === "undefined") return false;
+			if (inverted) return !matchExpressionPossibleValues.types.includes(event.type);
+			return matchExpressionPossibleValues.types.includes(event.type);
+		};
+	} else if (matchExpressionPossibleValues instanceof RegExp) matcher = (event) => {
+		if (inverted) return !matchExpressionPossibleValues.test(event.id);
+		return matchExpressionPossibleValues.test(event.id);
+	};
+	else if (typeof matchExpressionPossibleValues === "function") matcher = matchExpressionPossibleValues;
+	return {
+		id,
+		type: EventaType.MatchExpression,
+		matcher
+	};
+}
+
+//#endregion
+//#region src/context.ts
+function createContext(props = {}) {
+	const listeners = /* @__PURE__ */ new Map();
+	const onceListeners = /* @__PURE__ */ new Map();
+	const matchExpressions = /* @__PURE__ */ new Map();
+	const matchExpressionListeners = /* @__PURE__ */ new Map();
+	const matchExpressionOnceListeners = /* @__PURE__ */ new Map();
+	const hooks = props.adapter?.(emit).hooks;
+	function emit(event, payload, options) {
+		const emittingPayload = {
+			...event,
+			body: payload
+		};
+		for (const listener of listeners.get(event.id) || []) {
+			listener(emittingPayload, options);
+			hooks?.onReceived?.(event.id, emittingPayload);
+		}
+		for (const onceListener of onceListeners.get(event.id) || []) {
+			onceListener(emittingPayload, options);
+			hooks?.onReceived?.(event.id, emittingPayload);
+			onceListeners.get(event.id)?.delete(onceListener);
+		}
+		for (const matchExpression of matchExpressions.values()) if (matchExpression.matcher) {
+			if (!matchExpression.matcher(emittingPayload)) continue;
+			for (const listener of matchExpressionListeners.get(matchExpression.id) || []) {
+				listener(emittingPayload, options);
+				hooks?.onReceived?.(matchExpression.id, emittingPayload);
+			}
+			for (const onceListener of matchExpressionOnceListeners.get(matchExpression.id) || []) {
+				onceListener(emittingPayload, options);
+				hooks?.onReceived?.(matchExpression.id, emittingPayload);
+				matchExpressionOnceListeners.get(matchExpression.id)?.delete(onceListener);
+			}
+		}
+		hooks?.onSent(event.id, emittingPayload, options);
+	}
+	return {
+		get listeners() {
+			return listeners;
+		},
+		get onceListeners() {
+			return onceListeners;
+		},
+		emit,
+		on(eventOrMatchExpression, handler) {
+			if (eventOrMatchExpression.type === EventaType.Event) {
+				const event = eventOrMatchExpression;
+				if (!listeners.has(event.id)) listeners.set(event.id, /* @__PURE__ */ new Set());
+				listeners.get(event.id)?.add(handler);
+				return () => listeners.get(event.id)?.delete(handler);
+			}
+			if (eventOrMatchExpression.type === EventaType.MatchExpression) {
+				const matchExpression = eventOrMatchExpression;
+				if (!matchExpressions.has(matchExpression.id)) matchExpressions.set(matchExpression.id, matchExpression);
+				if (!matchExpressionListeners.has(matchExpression.id)) matchExpressionListeners.set(matchExpression.id, /* @__PURE__ */ new Set());
+				matchExpressionListeners.get(matchExpression.id)?.add(handler);
+				return () => matchExpressionListeners.get(matchExpression.id)?.delete(handler);
+			}
+			return () => void 0;
+		},
+		once(eventOrMatchExpression, handler) {
+			if (eventOrMatchExpression.type === EventaType.Event) {
+				const event = eventOrMatchExpression;
+				if (!onceListeners.has(event.id)) onceListeners.set(event.id, /* @__PURE__ */ new Set());
+				onceListeners.get(event.id)?.add(handler);
+				return () => onceListeners.get(event.id)?.delete(handler);
+			}
+			if (eventOrMatchExpression.type === EventaType.MatchExpression) {
+				const matchExpression = eventOrMatchExpression;
+				if (!matchExpressions.has(matchExpression.id)) matchExpressions.set(matchExpression.id, matchExpression);
+				if (!matchExpressionListeners.has(matchExpression.id)) matchExpressionListeners.set(matchExpression.id, /* @__PURE__ */ new Set());
+				matchExpressionOnceListeners.get(matchExpression.id)?.add(handler);
+				return () => matchExpressionOnceListeners.get(matchExpression.id)?.delete(handler);
+			}
+			return () => void 0;
+		},
+		off(eventOrMatchExpression, handler) {
+			switch (eventOrMatchExpression.type) {
+				case EventaType.Event:
+					if (handler !== void 0) {
+						listeners.get(eventOrMatchExpression.id)?.delete(handler);
+						onceListeners.get(eventOrMatchExpression.id)?.delete(handler);
+						break;
+					}
+					listeners.delete(eventOrMatchExpression.id);
+					onceListeners.delete(eventOrMatchExpression.id);
+					break;
+				case EventaType.MatchExpression:
+					if (handler !== void 0) {
+						matchExpressionListeners.get(eventOrMatchExpression.id)?.delete(handler);
+						matchExpressionOnceListeners.get(eventOrMatchExpression.id)?.delete(handler);
+						break;
+					}
+					matchExpressionListeners.delete(eventOrMatchExpression.id);
+					matchExpressionOnceListeners.delete(eventOrMatchExpression.id);
+					break;
+			}
+		}
+	};
+}
+
+//#endregion
+export { EventaFlowDirection, EventaType, and, createContext, defineEventa, defineInboundEventa, defineOutboundEventa, matchBy, nanoid, or };
+//# sourceMappingURL=context-C35Qku9U.mjs.map

package/dist/context-C35Qku9U.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-C35Qku9U.mjs","names":["matcher: (event: E) => boolean | Promise<boolean>"],"sources":["../src/eventa.ts","../src/context.ts"],"sourcesContent":["import isGlobMatch from 'picomatch'\n\nimport { customAlphabet } from 'nanoid'\n\nexport function nanoid() {\n  return customAlphabet('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', 16)()\n}\n\nexport interface InvokeEventConstraint<_Req, _Res> {}\n\nexport type EventTag<Res, Req> = string & InvokeEventConstraint<Req, Res>\n\nexport enum EventaType {\n  Event = 'event',\n  MatchExpression = 'matchExpression',\n}\n\nexport enum EventaFlowDirection {\n  Inbound = 'inbound',\n  Outbound = 'outbound',\n}\n\nexport interface DirectionalEventa<P, T = undefined> extends Eventa<P> {\n  _flowDirection: EventaFlowDirection | T\n}\n\nexport interface InboundEventa<T> extends DirectionalEventa<T> {\n  _flowDirection: EventaFlowDirection.Inbound\n}\n\nexport interface OutboundEventa<T> extends DirectionalEventa<T> {\n  _flowDirection: EventaFlowDirection.Outbound\n}\n\nexport function defineInboundEventa<T>(id?: string): InboundEventa<T> {\n  return {\n    ...defineEventa<T>(id),\n    _flowDirection: EventaFlowDirection.Inbound,\n  } as InboundEventa<T>\n}\n\nexport function defineOutboundEventa<T>(id?: string): OutboundEventa<T> {\n  return {\n    ...defineEventa<T>(id),\n    _flowDirection: EventaFlowDirection.Outbound,\n  } as OutboundEventa<T>\n}\n\n// type ServerInvokeHandlerEvent<Req, Res> = symbol & InvokeEventConstraint<Req, Res>\n// type ClientInvoke<Req> = symbol & InvokeEventConstraint<Req, null>\n\nexport interface EventaLike<_P = undefined, T extends EventaType = EventaType> {\n  id: string\n  type?: T\n}\n\nexport interface Eventa<P = unknown> extends EventaLike<P, EventaType.Event> {\n  body?: P\n}\n\nexport function defineEventa<P = undefined>(id?: string): Eventa<P> {\n  if (!id) {\n    id = nanoid()\n  }\n\n  return {\n    id,\n    type: EventaType.Event,\n  }\n}\n\nexport interface EventaMatchExpression<P = undefined> extends EventaLike<P, EventaType.MatchExpression> {\n  matcher?: (event: Eventa<P>) => boolean | Promise<boolean>\n}\n\nexport function and<P>(...matchExpression: Array<EventaMatchExpression<P>>): EventaMatchExpression<P> {\n  return {\n    id: nanoid(),\n    type: EventaType.MatchExpression,\n    matcher: (event: Eventa<P>) => {\n      return matchExpression.every(m => m.matcher ? m.matcher(event) : false)\n    },\n  }\n}\n\nexport function or<P>(...matchExpression: Array<EventaMatchExpression<P>>): EventaMatchExpression<P> {\n  return {\n    id: nanoid(),\n    type: EventaType.MatchExpression,\n    matcher: (event: Eventa<P>) => {\n      return matchExpression.some(m => m.matcher ? m.matcher(event) : false)\n    },\n  }\n}\n\nexport function matchBy<P = undefined>(glob: string, inverted?: boolean): EventaMatchExpression<P>\nexport function matchBy<P = undefined>(options: { ids: string[] }, inverted?: boolean): EventaMatchExpression<P>\nexport function matchBy<P = undefined>(options: { eventa: Eventa<P>[] }, inverted?: boolean): EventaMatchExpression<P>\nexport function matchBy<P = undefined>(options: { types: EventaType[] }, inverted?: boolean): EventaMatchExpression<P>\nexport function matchBy<P = undefined>(regExp: RegExp, inverted?: boolean): EventaMatchExpression<P>\nexport function matchBy<P = undefined, E extends Eventa<P> = Eventa<P>>(matcher: (event: E) => boolean | Promise<boolean>): EventaMatchExpression<P>\nexport function matchBy<P = undefined, E extends Eventa<P> = Eventa<P>>(\n  matchExpressionPossibleValues:\n    | string\n    | Eventa<any>\n    | { ids: string[] }\n    | { eventa: Eventa<P>[] }\n    | { types: EventaType[] }\n    | RegExp\n    | ((event: E) => boolean | Promise<boolean>),\n  inverted?: boolean,\n): EventaMatchExpression<P> {\n  const id = nanoid()\n\n  let matcher: (event: E) => boolean | Promise<boolean> = () => false\n  if (typeof matchExpressionPossibleValues === 'string') {\n    matcher = (eventa) => {\n      return isGlobMatch(matchExpressionPossibleValues)(eventa.id)\n    }\n  }\n  else if (typeof matchExpressionPossibleValues === 'object') {\n    if ('ids' in matchExpressionPossibleValues) {\n      matcher = (event: Eventa<P>) => {\n        if (inverted) {\n          return !matchExpressionPossibleValues.ids.includes(event.id)\n        }\n\n        return matchExpressionPossibleValues.ids.includes(event.id)\n      }\n    }\n    else if ('eventa' in matchExpressionPossibleValues) {\n      matcher = (event: Eventa<P>) => {\n        if (inverted) {\n          return !matchExpressionPossibleValues.eventa.some(e => e.id === event.id)\n        }\n\n        return matchExpressionPossibleValues.eventa.some(e => e.id === event.id)\n      }\n    }\n    else if ('types' in matchExpressionPossibleValues) {\n      matcher = (event: Eventa<P>) => {\n        if (typeof event.type === 'undefined') {\n          return false\n        }\n        if (inverted) {\n          return !matchExpressionPossibleValues.types.includes(event.type)\n        }\n\n        return matchExpressionPossibleValues.types.includes(event.type)\n      }\n    }\n  }\n  else if (matchExpressionPossibleValues instanceof RegExp) {\n    matcher = (event: Eventa<P>) => {\n      if (inverted) {\n        return !matchExpressionPossibleValues.test(event.id)\n      }\n\n      return matchExpressionPossibleValues.test(event.id)\n    }\n  }\n  else if (typeof matchExpressionPossibleValues === 'function') {\n    matcher = matchExpressionPossibleValues\n  }\n\n  return {\n    id,\n    type: EventaType.MatchExpression,\n    matcher,\n  } satisfies EventaMatchExpression<P>\n}\n","import type { EventaAdapter } from './context-hooks'\nimport type { Eventa, EventaMatchExpression, EventTag } from './eventa'\n\nimport { EventaType } from './eventa'\n\ninterface CreateContextProps<EmitOptions = any> {\n  adapter?: EventaAdapter<EmitOptions>\n}\n\nexport function createContext<Extensions = any, Options = { raw: any }>(props: CreateContextProps<Options> = {}): EventContext<Extensions, Options> {\n  const listeners = new Map<EventTag<any, any>, Set<(params: any, options?: Options) => any>>()\n  const onceListeners = new Map<EventTag<any, any>, Set<(params: any, options?: Options) => any>>()\n\n  const matchExpressions = new Map<string, EventaMatchExpression<any>>()\n  const matchExpressionListeners = new Map<string, Set<(params: any, options?: Options) => any>>()\n  const matchExpressionOnceListeners = new Map<string, Set<(params: any, options?: Options) => any>>()\n\n  const hooks = props.adapter?.(emit).hooks\n\n  function emit<P>(event: Eventa<P>, payload: P, options?: Options) {\n    const emittingPayload = { ...event, body: payload }\n\n    for (const listener of listeners.get(event.id) || []) {\n      listener(emittingPayload, options)\n      hooks?.onReceived?.(event.id, emittingPayload)\n    }\n\n    for (const onceListener of onceListeners.get(event.id) || []) {\n      onceListener(emittingPayload, options)\n      hooks?.onReceived?.(event.id, emittingPayload)\n      onceListeners.get(event.id)?.delete(onceListener)\n    }\n\n    for (const matchExpression of matchExpressions.values()) {\n      if (matchExpression.matcher) {\n        const match = matchExpression.matcher(emittingPayload)\n        if (!match) {\n          continue\n        }\n\n        for (const listener of matchExpressionListeners.get(matchExpression.id) || []) {\n          listener(emittingPayload, options)\n          hooks?.onReceived?.(matchExpression.id, emittingPayload)\n        }\n        for (const onceListener of matchExpressionOnceListeners.get(matchExpression.id) || []) {\n          onceListener(emittingPayload, options)\n          hooks?.onReceived?.(matchExpression.id, emittingPayload)\n          matchExpressionOnceListeners.get(matchExpression.id)?.delete(onceListener)\n        }\n      }\n    }\n\n    hooks?.onSent(event.id, emittingPayload, options)\n  }\n\n  return {\n    get listeners() {\n      return listeners\n    },\n\n    get onceListeners() {\n      return onceListeners\n    },\n\n    emit,\n\n    on<P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler: (payload: Eventa<P>, options?: Options) => void): () => void {\n      if (eventOrMatchExpression.type === EventaType.Event) {\n        const event = eventOrMatchExpression as Eventa<P>\n        if (!listeners.has(event.id)) {\n          listeners.set(event.id, new Set())\n        }\n\n        listeners.get(event.id)?.add(handler)\n\n        return () => listeners.get(event.id)?.delete(handler)\n      }\n\n      if (eventOrMatchExpression.type === EventaType.MatchExpression) {\n        const matchExpression = eventOrMatchExpression as EventaMatchExpression<P>\n        if (!matchExpressions.has(matchExpression.id)) {\n          matchExpressions.set(matchExpression.id, matchExpression as EventaMatchExpression<P>)\n        }\n        if (!matchExpressionListeners.has(matchExpression.id)) {\n          matchExpressionListeners.set(matchExpression.id, new Set())\n        }\n\n        matchExpressionListeners.get(matchExpression.id)?.add(handler)\n\n        return () => matchExpressionListeners.get(matchExpression.id)?.delete(handler)\n      }\n\n      return () => void 0\n    },\n\n    once<P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler: (payload: Eventa<P>, options?: Options) => void): () => void {\n      if (eventOrMatchExpression.type === EventaType.Event) {\n        const event = eventOrMatchExpression as Eventa<P>\n        if (!onceListeners.has(event.id)) {\n          onceListeners.set(event.id, new Set())\n        }\n\n        onceListeners.get(event.id)?.add(handler)\n\n        return () => onceListeners.get(event.id)?.delete(handler)\n      }\n\n      if (eventOrMatchExpression.type === EventaType.MatchExpression) {\n        const matchExpression = eventOrMatchExpression as EventaMatchExpression<P>\n        if (!matchExpressions.has(matchExpression.id)) {\n          matchExpressions.set(matchExpression.id, matchExpression as EventaMatchExpression<P>)\n        }\n        if (!matchExpressionListeners.has(matchExpression.id)) {\n          matchExpressionListeners.set(matchExpression.id, new Set())\n        }\n\n        matchExpressionOnceListeners.get(matchExpression.id)?.add(handler)\n\n        return () => matchExpressionOnceListeners.get(matchExpression.id)?.delete(handler)\n      }\n\n      return () => void 0\n    },\n\n    off<P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler?: (payload: Eventa<P>, options?: Options) => void) {\n      switch (eventOrMatchExpression.type) {\n        case EventaType.Event:\n          if (handler !== undefined) {\n            listeners.get(eventOrMatchExpression.id)?.delete(handler)\n            onceListeners.get(eventOrMatchExpression.id)?.delete(handler)\n            break\n          }\n\n          listeners.delete(eventOrMatchExpression.id)\n          onceListeners.delete(eventOrMatchExpression.id)\n          break\n        case EventaType.MatchExpression:\n          if (handler !== undefined) {\n            matchExpressionListeners.get(eventOrMatchExpression.id)?.delete(handler)\n            matchExpressionOnceListeners.get(eventOrMatchExpression.id)?.delete(handler)\n            break\n          }\n\n          matchExpressionListeners.delete(eventOrMatchExpression.id)\n          matchExpressionOnceListeners.delete(eventOrMatchExpression.id)\n          break\n      }\n    },\n  }\n}\n\nexport interface EventContext<Extensions = undefined, EmitOptions = undefined> {\n  listeners: Map<EventTag<any, any>, Set<(params: any) => any>>\n  onceListeners: Map<EventTag<any, any>, Set<(params: any) => any>>\n\n  emit: <P>(event: Eventa<P>, payload: P, options?: EmitOptions) => void\n  on: <P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler: (payload: Eventa<P>, options?: EmitOptions) => void) => () => void\n  once: <P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler: (payload: Eventa<P>, options?: EmitOptions) => void) => () => void\n  off: <P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler?: (payload: Eventa<P>, options?: EmitOptions) => void) => void\n\n  /**\n   * Extensions\n   */\n  extensions?: Extensions\n}\n\nexport type EventContextEmitFn = EventContext['emit']\n"],"mappings":"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"}

package/dist/context-C_-MRU46.d.mts

@@ -0,0 +1,41 @@
+import { EventTag, Eventa, EventaMatchExpression } from "./eventa-B2HPBK4S.mjs";
+
+//#region src/context-hooks.d.ts
+interface EventaAdapterProps<EmitOptions = any> {
+  cleanup: () => void;
+  hooks: {
+    /**
+     * When `ctx.on`, `ctx.once` called, call `onReceived`
+     */
+    onReceived: <Req, Res>(tag: EventTag<Req, Res>, payload: Req) => void;
+    /**
+     * When `ctx.emit` called, call `onSent`
+     */
+    onSent: <Req, Res>(tag: EventTag<Req, Res>, payload: Req, options?: EmitOptions) => void;
+  };
+}
+type EventaAdapter<EmitOptions = any> = <P>(emit: (event: Eventa<P>, payload: P, options?: EmitOptions) => void) => EventaAdapterProps;
+//#endregion
+//#region src/context.d.ts
+interface CreateContextProps<EmitOptions = any> {
+  adapter?: EventaAdapter<EmitOptions>;
+}
+declare function createContext<Extensions = any, Options = {
+  raw: any;
+}>(props?: CreateContextProps<Options>): EventContext<Extensions, Options>;
+interface EventContext<Extensions = undefined, EmitOptions = undefined> {
+  listeners: Map<EventTag<any, any>, Set<(params: any) => any>>;
+  onceListeners: Map<EventTag<any, any>, Set<(params: any) => any>>;
+  emit: <P>(event: Eventa<P>, payload: P, options?: EmitOptions) => void;
+  on: <P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler: (payload: Eventa<P>, options?: EmitOptions) => void) => () => void;
+  once: <P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler: (payload: Eventa<P>, options?: EmitOptions) => void) => () => void;
+  off: <P>(eventOrMatchExpression: Eventa<P> | EventaMatchExpression<P>, handler?: (payload: Eventa<P>, options?: EmitOptions) => void) => void;
+  /**
+   * Extensions
+   */
+  extensions?: Extensions;
+}
+type EventContextEmitFn = EventContext['emit'];
+//#endregion
+export { EventContext, EventContextEmitFn, createContext };
+//# sourceMappingURL=context-C_-MRU46.d.mts.map

package/dist/eventa-B2HPBK4S.d.mts

@@ -0,0 +1,51 @@
+//#region src/eventa.d.ts
+declare function nanoid(): string;
+interface InvokeEventConstraint<_Req, _Res> {}
+type EventTag<Res, Req> = string & InvokeEventConstraint<Req, Res>;
+declare enum EventaType {
+  Event = "event",
+  MatchExpression = "matchExpression",
+}
+declare enum EventaFlowDirection {
+  Inbound = "inbound",
+  Outbound = "outbound",
+}
+interface DirectionalEventa<P, T = undefined> extends Eventa<P> {
+  _flowDirection: EventaFlowDirection | T;
+}
+interface InboundEventa<T> extends DirectionalEventa<T> {
+  _flowDirection: EventaFlowDirection.Inbound;
+}
+interface OutboundEventa<T> extends DirectionalEventa<T> {
+  _flowDirection: EventaFlowDirection.Outbound;
+}
+declare function defineInboundEventa<T>(id?: string): InboundEventa<T>;
+declare function defineOutboundEventa<T>(id?: string): OutboundEventa<T>;
+interface EventaLike<_P = undefined, T extends EventaType = EventaType> {
+  id: string;
+  type?: T;
+}
+interface Eventa<P = unknown> extends EventaLike<P, EventaType.Event> {
+  body?: P;
+}
+declare function defineEventa<P = undefined>(id?: string): Eventa<P>;
+interface EventaMatchExpression<P = undefined> extends EventaLike<P, EventaType.MatchExpression> {
+  matcher?: (event: Eventa<P>) => boolean | Promise<boolean>;
+}
+declare function and<P>(...matchExpression: Array<EventaMatchExpression<P>>): EventaMatchExpression<P>;
+declare function or<P>(...matchExpression: Array<EventaMatchExpression<P>>): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(glob: string, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(options: {
+  ids: string[];
+}, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(options: {
+  eventa: Eventa<P>[];
+}, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(options: {
+  types: EventaType[];
+}, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined>(regExp: RegExp, inverted?: boolean): EventaMatchExpression<P>;
+declare function matchBy<P = undefined, E extends Eventa<P> = Eventa<P>>(matcher: (event: E) => boolean | Promise<boolean>): EventaMatchExpression<P>;
+//#endregion
+export { DirectionalEventa, EventTag, Eventa, EventaFlowDirection, EventaLike, EventaMatchExpression, EventaType, InboundEventa, InvokeEventConstraint, OutboundEventa, and, defineEventa, defineInboundEventa, defineOutboundEventa, matchBy, nanoid, or };
+//# sourceMappingURL=eventa-B2HPBK4S.d.mts.map

package/dist/index-BgaYNgPh.d.mts

@@ -0,0 +1,24 @@
+import { EventContext } from "./context-C_-MRU46.mjs";
+import { InvokeEventa } from "./invoke-LTUFMmHi.mjs";
+
+//#region src/stream.d.ts
+declare function defineStreamInvoke<Res, Req = undefined, ResErr = Error, ReqErr = Error, E = any, EO = any>(clientCtx: EventContext<E, EO>, event: InvokeEventa<Res, Req, ResErr, ReqErr>): (req: Req) => ReadableStream<Res>;
+type StreamHandler<Res, Req = any, RawEventOptions = unknown> = (payload: Req, options?: {
+  /**
+   * TODO: Support aborting invoke handlers
+   */
+  abortController?: AbortController;
+} & RawEventOptions) => AsyncGenerator<Res, void, unknown>;
+declare function defineStreamInvokeHandler<Res, Req = undefined, ResErr = Error, ReqErr = Error, E = any, EO extends {
+  raw?: any;
+} = any>(serverCtx: EventContext<E, EO>, event: InvokeEventa<Res, Req, ResErr, ReqErr>, fn: StreamHandler<Res, Req, EO>): void;
+declare function toStreamHandler<Req, Res, EO extends {
+  raw?: any;
+} = any>(handler: (context: {
+  payload: Req;
+  options?: EO;
+  emit: (data: Res) => void;
+}) => Promise<void>): StreamHandler<Res, Req, EO>;
+//#endregion
+export { defineStreamInvoke, defineStreamInvokeHandler, toStreamHandler };
+//# sourceMappingURL=index-BgaYNgPh.d.mts.map

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { DirectionalEventa, EventTag, Eventa, EventaFlowDirection, EventaLike, EventaMatchExpression, EventaType, InboundEventa, InvokeEventConstraint, OutboundEventa, and, defineEventa, defineInboundEventa, defineOutboundEventa, matchBy, nanoid, or } from "./eventa-B2HPBK4S.mjs";
+import { EventContext, EventContextEmitFn, createContext } from "./context-C_-MRU46.mjs";
+import { ExtendableInvokeResponse, Handler, HandlerMap, InvocableEventContext, InvokeEventType, InvokeEventa, InvokeFunction, InvokeFunctionMap, ReceiveEvent, ReceiveEventError, ReceiveEventStreamEnd, SendEvent, SendEventError, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, isExtendableInvokeResponseLike, isInvokeEventa, isReceiveEvent, isSendEvent, undefineInvokeHandler } from "./invoke-LTUFMmHi.mjs";
+import { defineStreamInvoke, defineStreamInvokeHandler, toStreamHandler } from "./index-BgaYNgPh.mjs";
+export { DirectionalEventa, EventContext, EventContextEmitFn, EventTag, Eventa, EventaFlowDirection, EventaLike, EventaMatchExpression, EventaType, ExtendableInvokeResponse, Handler, HandlerMap, InboundEventa, InvocableEventContext, InvokeEventConstraint, InvokeEventType, InvokeEventa, InvokeFunction, InvokeFunctionMap, OutboundEventa, ReceiveEvent, ReceiveEventError, ReceiveEventStreamEnd, SendEvent, SendEventError, and, createContext, defineEventa, defineInboundEventa, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineOutboundEventa, defineStreamInvoke, defineStreamInvokeHandler, isExtendableInvokeResponseLike, isInvokeEventa, isReceiveEvent, isSendEvent, matchBy, nanoid, or, toStreamHandler, undefineInvokeHandler };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { EventaFlowDirection, EventaType, and, createContext, defineEventa, defineInboundEventa, defineOutboundEventa, matchBy, nanoid, or } from "./context-C35Qku9U.mjs";
+import { InvokeEventType, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineStreamInvoke, defineStreamInvokeHandler, isExtendableInvokeResponseLike, isInvokeEventa, isReceiveEvent, isSendEvent, toStreamHandler, undefineInvokeHandler } from "./src-Bb-vxm5k.mjs";
+
+export { EventaFlowDirection, EventaType, InvokeEventType, and, createContext, defineEventa, defineInboundEventa, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, defineOutboundEventa, defineStreamInvoke, defineStreamInvokeHandler, isExtendableInvokeResponseLike, isInvokeEventa, isReceiveEvent, isSendEvent, matchBy, nanoid, or, toStreamHandler, undefineInvokeHandler };

package/dist/internal-DjiAQtsa.mjs

@@ -0,0 +1,18 @@
+import { nanoid } from "./context-C35Qku9U.mjs";
+
+//#region src/adapters/websocket/internal.ts
+function generateWebsocketPayload(type, payload) {
+	return {
+		id: nanoid(),
+		type,
+		payload,
+		timestamp: Date.now()
+	};
+}
+function parseWebsocketPayload(data) {
+	return JSON.parse(data);
+}
+
+//#endregion
+export { generateWebsocketPayload, parseWebsocketPayload };
+//# sourceMappingURL=internal-DjiAQtsa.mjs.map

package/dist/internal-DjiAQtsa.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-DjiAQtsa.mjs","names":[],"sources":["../src/adapters/websocket/internal.ts"],"sourcesContent":["import type { EventTag } from '../../eventa'\nimport type { WebsocketPayload } from './shared'\n\nimport { nanoid } from '../../eventa'\n\nexport function generateWebsocketPayload<T>(type: EventTag<any, any>, payload: T): WebsocketPayload<T> {\n  return {\n    id: nanoid(),\n    type,\n    payload,\n    timestamp: Date.now(),\n  }\n}\n\nexport function parseWebsocketPayload<T>(data: string): WebsocketPayload<T> {\n  return JSON.parse(data) as WebsocketPayload<T>\n}\n"],"mappings":";;;AAKA,SAAgB,yBAA4B,MAA0B,SAAiC;AACrG,QAAO;EACL,IAAI,QAAQ;EACZ;EACA;EACA,WAAW,KAAK,KAAK;EACtB;;AAGH,SAAgB,sBAAyB,MAAmC;AAC1E,QAAO,KAAK,MAAM,KAAK"}

package/dist/invoke-LTUFMmHi.d.mts

@@ -0,0 +1,137 @@
+import { EventTag, Eventa } from "./eventa-B2HPBK4S.mjs";
+import { EventContext } from "./context-C_-MRU46.mjs";
+
+//#region src/invoke-shared.d.ts
+declare enum InvokeEventType {
+  SendEvent = 0,
+  SendEventError = 1,
+  ReceiveEvent = 2,
+  ReceiveEventError = 3,
+  ReceiveEventStreamEnd = 4,
+}
+interface SendEvent<Res, Req = undefined, _ = undefined, __ = undefined> extends Eventa<{
+  invokeId: string;
+  content: Req;
+}> {
+  id: EventTag<Res, Req>;
+  invokeType: InvokeEventType.SendEvent;
+}
+interface SendEventError<Res, Req = undefined, _ = undefined, ReqErr = Error> extends Eventa<{
+  invokeId: string;
+  content: ReqErr;
+}> {
+  id: EventTag<Res, Req>;
+  invokeType: InvokeEventType.SendEventError;
+}
+interface ReceiveEvent<Res, Req = undefined, _ = undefined, __ = undefined> extends Eventa<{
+  invokeId: string;
+  content: Res;
+}> {
+  id: EventTag<Res, Req>;
+  invokeType: InvokeEventType.ReceiveEvent;
+}
+interface ReceiveEventError<Res, Req = undefined, ResErr = undefined, _ = undefined> extends Eventa<{
+  invokeId: string;
+  content: {
+    error: ResErr;
+  };
+}> {
+  id: EventTag<Res, Req>;
+  invokeType: InvokeEventType.ReceiveEventError;
+}
+interface ReceiveEventStreamEnd<Res, Req = undefined, _ = undefined, __ = undefined> extends Eventa<{
+  invokeId: string;
+  content: undefined;
+}> {
+  id: EventTag<Res, Req>;
+  invokeType: InvokeEventType.ReceiveEventStreamEnd;
+}
+interface InvokeEventa<Res, Req = undefined, ResErr = Error, ReqErr = Error> {
+  sendEvent: SendEvent<Res, Req, ResErr, ReqErr>;
+  sendEventError: SendEventError<Res, Req, ResErr, ReqErr>;
+  receiveEvent: ReceiveEvent<Res, Req, ResErr, ReqErr>;
+  receiveEventError: ReceiveEventError<Res, Req, ResErr, ReqErr>;
+  receiveEventStreamEnd: ReceiveEventStreamEnd<Res, Req, ResErr, ReqErr>;
+}
+declare function defineInvokeEventa<Res, Req = undefined, ResErr = Error, ReqErr = Error>(tag?: string): {
+  sendEvent: SendEvent<Res, Req, ResErr, ReqErr>;
+  sendEventError: SendEventError<Res, Req, ResErr, ReqErr>;
+  receiveEvent: ReceiveEvent<Res, Req, ResErr, ReqErr>;
+  receiveEventError: ReceiveEventError<Res, Req, ResErr, ReqErr>;
+  receiveEventStreamEnd: ReceiveEventStreamEnd<Res, Req, ResErr, ReqErr>;
+};
+declare function isInvokeEventa(event: Eventa<any>): event is SendEvent<any, any, any, any> | SendEventError<any, any, any, any> | ReceiveEvent<any, any, any, any> | ReceiveEventError<any, any, any, any> | ReceiveEventStreamEnd<any, any, any, any>;
+declare function isSendEvent(event: Eventa<any>): event is SendEvent<any, any, any, any> | SendEventError<any, any, any, any>;
+declare function isReceiveEvent(event: Eventa<any>): event is ReceiveEvent<any, any, any, any> | ReceiveEventError<any, any, any, any> | ReceiveEventStreamEnd<any, any, any, any>;
+//#endregion
+//#region src/invoke.d.ts
+type IsInvokeRequestOptional<EC extends EventContext<any, any>> = EC extends EventContext<infer E, any> ? E extends {
+  invokeRequest: any;
+} ? undefined extends E['invokeRequest'] ? true : false : E extends {
+  invokeRequest?: any;
+} ? undefined extends E['invokeRequest'] ? true : false : true : true;
+type ExtractInvokeRequest<EC extends EventContext<any, any>> = EC extends EventContext<infer E, any> ? E extends {
+  invokeRequest: infer IR;
+} ? IR : E extends {
+  invokeRequest?: infer IR;
+} ? IR : undefined : undefined;
+type ExtractInvokeResponse<EC extends EventContext<any, any>> = EC extends EventContext<infer E, any> ? E extends {
+  invokeResponse: infer IR;
+} ? IR : E extends {
+  invokeResponse?: infer IR;
+} ? IR : undefined : undefined;
+type InvokeFunction<Res, Req, EC extends EventContext<any, any>> = Req extends undefined ? IsInvokeRequestOptional<EC> extends true ? (req?: Req, invokeRequest?: ExtractInvokeRequest<EC>) => Promise<Res> : (req: Req, invokeRequest: ExtractInvokeRequest<EC>) => Promise<Res> : IsInvokeRequestOptional<EC> extends true ? (req: Req, invokeRequest?: ExtractInvokeRequest<EC>) => Promise<Res> : (req: Req, invokeRequest: ExtractInvokeRequest<EC>) => Promise<Res>;
+type InvokeFunctionMap<EventMap extends Record<string, InvokeEventa<any, any, any, any>>, EC extends EventContext<any, any>> = { [K in keyof EventMap]: EventMap[K] extends InvokeEventa<infer Res, infer Req, any, any> ? InvokeFunction<Res, Req, EC> : never };
+type ExtendableInvokeResponse<Res, EC extends EventContext<any, any>> = Promise<Res> | Res | Promise<{
+  response: Res;
+  invokeResponse?: ExtractInvokeResponse<EC>;
+}> | {
+  response: Res;
+  invokeResponse?: ExtractInvokeResponse<EC>;
+};
+declare function isExtendableInvokeResponseLike<Res, EC extends EventContext<any, any>>(value: Eventa<unknown> | ReceiveEvent<{
+  response: Res;
+  invokeResponse?: unknown;
+}>): value is ReceiveEvent<{
+  response: Res;
+  invokeResponse?: ExtractInvokeResponse<EC>;
+}>;
+type Handler<Res, Req = any, EC extends EventContext<any, any> = EventContext<any, any>, RawEventOptions = unknown> = (payload: Req, options?: {
+  /**
+   * TODO: Support aborting invoke handlers
+   */
+  abortController?: AbortController;
+} & RawEventOptions) => ExtendableInvokeResponse<Res, EC>;
+type InternalInvokeHandler<Res, Req = any, ResErr = Error, ReqErr = Error, EO = any> = (params: InvokeEventa<Res, Req, ResErr, ReqErr>['sendEvent'], eventOptions?: EO) => void;
+type HandlerMap<EventMap extends Record<string, InvokeEventa<any, any, any, any>>, EO = any, EC extends EventContext<any, any> = EventContext<any, any>> = { [K in keyof EventMap]: EventMap[K] extends InvokeEventa<infer Res, infer Req, any, any> ? Handler<Res, Req, EC, EO> : never };
+interface InvocableEventContext<E, EO> extends EventContext<E, EO> {
+  invokeHandlers?: Map<string, Map<Handler<any>, InternalInvokeHandler<any>>>;
+}
+declare function defineInvoke<Res, Req = undefined, ResErr = Error, ReqErr = Error, CtxExt = any, EOpts = any, ECtx extends EventContext<CtxExt, EOpts> = EventContext<CtxExt, EOpts>>(ctx: ECtx, event: InvokeEventa<Res, Req, ResErr, ReqErr>): InvokeFunction<Res, Req, ECtx>;
+declare function defineInvokes<EK extends string, EventMap extends Record<EK, InvokeEventa<any, any, any, any>>, CtxExt = any, EOpts = any, ECtx extends EventContext<CtxExt, EOpts> = EventContext<CtxExt, EOpts>>(ctx: ECtx, events: EventMap): InvokeFunctionMap<EventMap, ECtx>;
+/**
+ * Define an invoke handler for a specific invoke event.
+ *
+ * @param ctx The event context in which to define the invoke handler.
+ * @param event The invoke event for which the handler is to be defined.
+ * @param handler The handler function to be invoked when the event is triggered.
+ * @returns A function that can be called to remove the invoke handler.
+ */
+declare function defineInvokeHandler<Res, Req = undefined, ResErr = Error, ReqErr = Error, CtxExt = any, EOpts extends {
+  raw?: any;
+} = any>(ctx: InvocableEventContext<CtxExt, EOpts>, event: InvokeEventa<Res, Req, ResErr, ReqErr>, handler: Handler<Res, Req, InvocableEventContext<CtxExt, EOpts>, EOpts>): () => void;
+declare function defineInvokeHandlers<EK extends string, EventMap extends Record<EK, InvokeEventa<any, any, any, any>>, CtxExt = any, EOpts extends {
+  raw?: any;
+} = any>(ctx: InvocableEventContext<CtxExt, EOpts>, events: EventMap, handlers: HandlerMap<EventMap, EOpts>): Record<EK, () => void>;
+/**
+ * Remove one or all invoke handlers for a specific invoke event.
+ *
+ * @param ctx The event context from which to remove the invoke handler(s).
+ * @param event The invoke event whose handlers are to be removed.
+ * @param handler The specific handler to remove. If not omitted, all handlers for the event will be removed.
+ * @returns `true` if at least one handler was removed, `false` otherwise
+ */
+declare function undefineInvokeHandler<Res, Req = undefined, ResErr = Error, ReqErr = Error, CtxExt = any, EOpts = any>(ctx: InvocableEventContext<CtxExt, EOpts>, event: InvokeEventa<Res, Req, ResErr, ReqErr>, handler?: Handler<Res, Req, InvocableEventContext<CtxExt, EOpts>, EOpts>): boolean;
+//#endregion
+export { ExtendableInvokeResponse, Handler, HandlerMap, InvocableEventContext, InvokeEventType, InvokeEventa, InvokeFunction, InvokeFunctionMap, ReceiveEvent, ReceiveEventError, ReceiveEventStreamEnd, SendEvent, SendEventError, defineInvoke, defineInvokeEventa, defineInvokeHandler, defineInvokeHandlers, defineInvokes, isExtendableInvokeResponseLike, isInvokeEventa, isReceiveEvent, isSendEvent, undefineInvokeHandler };
+//# sourceMappingURL=invoke-LTUFMmHi.d.mts.map

package/dist/shared-Da41l-vp.mjs

@@ -0,0 +1,21 @@
+import { defineEventa, nanoid } from "./context-C35Qku9U.mjs";
+
+//#region src/adapters/electron/internal.ts
+function generatePayload(type, payload) {
+	return {
+		id: nanoid(),
+		type,
+		payload
+	};
+}
+function parsePayload(data) {
+	return data;
+}
+
+//#endregion
+//#region src/adapters/electron/shared.ts
+const errorEvent = { ...defineEventa() };
+
+//#endregion
+export { errorEvent, generatePayload, parsePayload };
+//# sourceMappingURL=shared-Da41l-vp.mjs.map

package/dist/shared-Da41l-vp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-Da41l-vp.mjs","names":[],"sources":["../src/adapters/electron/internal.ts","../src/adapters/electron/shared.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"],"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"}

package/dist/shared-DbO1rU2W.mjs

@@ -0,0 +1,71 @@
+import { defineEventa, defineOutboundEventa, nanoid } from "./context-C35Qku9U.mjs";
+import { isExtendableInvokeResponseLike } from "./src-Bb-vxm5k.mjs";
+
+//#region src/adapters/webworkers/internal.ts
+function generateWorkerPayload(type, payload) {
+	return {
+		id: nanoid(),
+		type,
+		payload
+	};
+}
+function parseWorkerPayload(data) {
+	return data;
+}
+
+//#endregion
+//#region src/adapters/webworkers/shared.ts
+function defineWorkerEventa(id) {
+	return {
+		...defineEventa(id),
+		_workerTransfer: true
+	};
+}
+function defineOutboundWorkerEventa(id) {
+	return {
+		...defineOutboundEventa(id),
+		_workerTransfer: true
+	};
+}
+function isWorkerEventa(event) {
+	return typeof event === "object" && "_workerTransfer" in event && typeof event._workerTransfer === "boolean" && event._workerTransfer === true;
+}
+const workerErrorEvent = defineEventa();
+const workerMessageErrorEvent = defineEventa();
+function normalizeOnListenerParameters(event, options) {
+	let eventPayload = event.body;
+	let transfer;
+	if (isExtendableInvokeResponseLike(event)) {
+		if (event.body.content.invokeResponse?.transfer != null) {
+			transfer = event.body.content.invokeResponse.transfer;
+			delete event.body.content.invokeResponse;
+		}
+		eventPayload = {
+			...event.body,
+			content: event.body.content.response
+		};
+		delete eventPayload.content.response;
+	} else if (isWorkerEventa(event)) {
+		transfer = event.body?.transfer;
+		delete event.body?.transfer;
+		eventPayload = event.body?.message;
+		delete event.body?.message;
+	}
+	if (typeof options !== "undefined" && options != null && typeof options === "object" && "transfer" in options) {
+		if (Array.isArray(options.transfer)) transfer = options.transfer;
+	}
+	return {
+		body: eventPayload,
+		transfer
+	};
+}
+function withTransfer(body, transfer) {
+	return {
+		response: body,
+		invokeResponse: { transfer: transfer ?? [] }
+	};
+}
+
+//#endregion
+export { defineOutboundWorkerEventa, defineWorkerEventa, generateWorkerPayload, isWorkerEventa, normalizeOnListenerParameters, parseWorkerPayload, withTransfer, workerErrorEvent };
+//# sourceMappingURL=shared-DbO1rU2W.mjs.map

package/dist/shared-DbO1rU2W.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-DbO1rU2W.mjs","names":["eventPayload: any","transfer: Transferable[] | undefined"],"sources":["../src/adapters/webworkers/internal.ts","../src/adapters/webworkers/shared.ts"],"sourcesContent":["import type { EventTag } from '../..'\nimport type { WorkerPayload } from './shared'\n\nimport { nanoid } from '../..'\n\nexport function generateWorkerPayload<T>(type: EventTag<any, any>, payload: T): WorkerPayload<T> {\n  return {\n    id: nanoid(),\n    type,\n    payload,\n  }\n}\n\nexport function parseWorkerPayload<T>(data: unknown): WorkerPayload<T> {\n  return data as WorkerPayload<T>\n}\n","import type { EventContext } from '../../context'\nimport type { Eventa, EventTag } from '../../eventa'\nimport type { ExtendableInvokeResponse } from '../../invoke'\n\nimport { defineEventa, defineOutboundEventa } from '../../eventa'\nimport { isExtendableInvokeResponseLike } from '../../invoke'\n\nexport interface WorkerPayload<T> {\n  id: string\n  type: EventTag<any, any>\n  payload: T\n  transfer?: Transferable[]\n}\n\nexport interface WorkerEventa<T> extends Eventa<{ message: T, transfer?: Transferable[] }> {\n  _workerTransfer: true\n}\n\nexport function defineWorkerEventa<T>(id?: string): WorkerEventa<T> {\n  return {\n    ...defineEventa<{ message: T, transfer?: Transferable[] }>(id),\n    _workerTransfer: true,\n  }\n}\n\nexport function defineOutboundWorkerEventa<T>(id?: string): WorkerEventa<T> {\n  return {\n    ...defineOutboundEventa<{ message: T, transfer?: Transferable[] }>(id),\n    _workerTransfer: true,\n  }\n}\n\nexport function isWorkerEventa(event: Eventa<any>): event is WorkerEventa<any> {\n  return typeof event === 'object'\n    && '_workerTransfer' in event\n    && typeof event._workerTransfer === 'boolean'\n    && event._workerTransfer === true\n}\n\nexport const workerErrorEvent = defineEventa<{ error: unknown }>()\nexport const workerMessageErrorEvent = defineEventa<{ error: unknown, message: any }>()\n\nexport function normalizeOnListenerParameters(event: Eventa<any>, options?: { transfer?: Transferable[] } | unknown) {\n  let eventPayload: any = event.body\n  let transfer: Transferable[] | undefined\n\n  if (isExtendableInvokeResponseLike<unknown, EventContext<{ invokeResponse?: { transfer?: Transferable[] } }>>(event)) {\n    if (event.body!.content.invokeResponse?.transfer != null) {\n      transfer = event.body!.content.invokeResponse!.transfer\n      delete event.body!.content.invokeResponse\n    }\n\n    eventPayload = { ...event.body, content: event.body!.content.response }\n    delete eventPayload.content.response\n  }\n  else if (isWorkerEventa(event)) {\n    transfer = event.body?.transfer\n    delete event.body?.transfer\n\n    eventPayload = event.body?.message\n    delete event.body?.message\n  }\n\n  // Override from options\n  if (typeof options !== 'undefined' && options != null && typeof options === 'object' && 'transfer' in options) {\n    if (Array.isArray(options.transfer)) {\n      transfer = options.transfer\n    }\n  }\n\n  return {\n    body: eventPayload,\n    transfer,\n  }\n}\n\nexport interface WithTransfer<T> {\n  message: T\n  _transfer?: Transferable[]\n}\n\nexport function withTransfer<T>(body: T, transfer?: Transferable[]): ExtendableInvokeResponse<T, EventContext<{ invokeResponse?: { transfer?: Transferable[] } }, any>> {\n  return {\n    response: body,\n    invokeResponse: {\n      transfer: transfer ?? [],\n    },\n  }\n}\n"],"mappings":";;;;AAKA,SAAgB,sBAAyB,MAA0B,SAA8B;AAC/F,QAAO;EACL,IAAI,QAAQ;EACZ;EACA;EACD;;AAGH,SAAgB,mBAAsB,MAAiC;AACrE,QAAO;;;;;ACIT,SAAgB,mBAAsB,IAA8B;AAClE,QAAO;EACL,GAAG,aAAwD,GAAG;EAC9D,iBAAiB;EAClB;;AAGH,SAAgB,2BAA8B,IAA8B;AAC1E,QAAO;EACL,GAAG,qBAAgE,GAAG;EACtE,iBAAiB;EAClB;;AAGH,SAAgB,eAAe,OAAgD;AAC7E,QAAO,OAAO,UAAU,YACnB,qBAAqB,SACrB,OAAO,MAAM,oBAAoB,aACjC,MAAM,oBAAoB;;AAGjC,MAAa,mBAAmB,cAAkC;AAClE,MAAa,0BAA0B,cAAgD;AAEvF,SAAgB,8BAA8B,OAAoB,SAAmD;CACnH,IAAIA,eAAoB,MAAM;CAC9B,IAAIC;AAEJ,KAAI,+BAA0G,MAAM,EAAE;AACpH,MAAI,MAAM,KAAM,QAAQ,gBAAgB,YAAY,MAAM;AACxD,cAAW,MAAM,KAAM,QAAQ,eAAgB;AAC/C,UAAO,MAAM,KAAM,QAAQ;;AAG7B,iBAAe;GAAE,GAAG,MAAM;GAAM,SAAS,MAAM,KAAM,QAAQ;GAAU;AACvE,SAAO,aAAa,QAAQ;YAErB,eAAe,MAAM,EAAE;AAC9B,aAAW,MAAM,MAAM;AACvB,SAAO,MAAM,MAAM;AAEnB,iBAAe,MAAM,MAAM;AAC3B,SAAO,MAAM,MAAM;;AAIrB,KAAI,OAAO,YAAY,eAAe,WAAW,QAAQ,OAAO,YAAY,YAAY,cAAc,SACpG;MAAI,MAAM,QAAQ,QAAQ,SAAS,CACjC,YAAW,QAAQ;;AAIvB,QAAO;EACL,MAAM;EACN;EACD;;AAQH,SAAgB,aAAgB,MAAS,UAA+H;AACtK,QAAO;EACL,UAAU;EACV,gBAAgB,EACd,UAAU,YAAY,EAAE,EACzB;EACF"}