@moeru/eventa 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/{shared-CA_i_yfR.mjs → shared-Dl0_bFq0.mjs}

@@ -1,5 +1,5 @@
-import { a as defineEventa, l as nanoid } from "./context-BMDJMapI.mjs";
-
+import { a as defineEventa, l as nanoid } from "./context-Dht_IZMb.mjs";
+import "./src-CTs6h4Ci.mjs";
 //#region src/adapters/electron/internal.ts
 function generatePayload(type, payload) {
 	return {
@@ -11,11 +11,10 @@ function generatePayload(type, payload) {
 function parsePayload(data) {
 	return data;
 }
-
 //#endregion
 //#region src/adapters/electron/shared.ts
 const errorEvent = { ...defineEventa() };
-
 //#endregion
 export { generatePayload as n, parsePayload as r, errorEvent as t };
-//# sourceMappingURL=shared-CA_i_yfR.mjs.map
+
+//# sourceMappingURL=shared-Dl0_bFq0.mjs.map

package/dist/{shared-CA_i_yfR.mjs.map → shared-Dl0_bFq0.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"shared-CA_i_yfR.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"}
+{"version":3,"file":"shared-Dl0_bFq0.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/{src-eMqISeHo.mjs → src-CTs6h4Ci.mjs}

@@ -1,5 +1,4 @@
-import { a as defineEventa, l as nanoid } from "./context-BMDJMapI.mjs";
-
+import { a as defineEventa, l as nanoid } from "./context-Dht_IZMb.mjs";
 //#region src/context-extension-invoke-internal.ts
 /**
 * Read the internal invoke configuration from context extensions, if present.
@@ -30,49 +29,69 @@ function registerInvokeAbortEventListeners(ctx, eventOrMatch) {
 	ctx.extensions = extensions;
 	return invokeInternal;
 }
-
 //#endregion
 //#region src/invoke-shared.ts
-let InvokeEventType = /* @__PURE__ */ function(InvokeEventType$1) {
-	InvokeEventType$1[InvokeEventType$1["SendEvent"] = 0] = "SendEvent";
-	InvokeEventType$1[InvokeEventType$1["SendEventError"] = 1] = "SendEventError";
-	InvokeEventType$1[InvokeEventType$1["SendEventStreamEnd"] = 2] = "SendEventStreamEnd";
-	InvokeEventType$1[InvokeEventType$1["SendEventAbort"] = 3] = "SendEventAbort";
-	InvokeEventType$1[InvokeEventType$1["ReceiveEvent"] = 4] = "ReceiveEvent";
-	InvokeEventType$1[InvokeEventType$1["ReceiveEventError"] = 5] = "ReceiveEventError";
-	InvokeEventType$1[InvokeEventType$1["ReceiveEventStreamEnd"] = 6] = "ReceiveEventStreamEnd";
-	return InvokeEventType$1;
+let InvokeEventType = /* @__PURE__ */ function(InvokeEventType) {
+	InvokeEventType[InvokeEventType["SendEvent"] = 0] = "SendEvent";
+	InvokeEventType[InvokeEventType["SendEventError"] = 1] = "SendEventError";
+	InvokeEventType[InvokeEventType["SendEventStreamEnd"] = 2] = "SendEventStreamEnd";
+	InvokeEventType[InvokeEventType["SendEventAbort"] = 3] = "SendEventAbort";
+	InvokeEventType[InvokeEventType["ReceiveEvent"] = 4] = "ReceiveEvent";
+	InvokeEventType[InvokeEventType["ReceiveEventError"] = 5] = "ReceiveEventError";
+	InvokeEventType[InvokeEventType["ReceiveEventStreamEnd"] = 6] = "ReceiveEventStreamEnd";
+	return InvokeEventType;
 }({});
-function defineInvokeEventa(tag) {
+function defineInvokeEventa(tag, options) {
 	if (!tag) tag = nanoid();
 	return {
 		sendEvent: {
-			...defineEventa(`${tag}-send`),
-			invokeType: InvokeEventType.SendEvent
+			...defineEventa(`${tag}-send`, {
+				metadata: options?.metadata,
+				invokeMetadata: options?.invokeMetadata
+			}),
+			invokeType: 0
 		},
 		sendEventError: {
-			...defineEventa(`${tag}-send-error`),
-			invokeType: InvokeEventType.SendEventError
+			...defineEventa(`${tag}-send-error`, {
+				metadata: options?.metadata,
+				invokeMetadata: options?.invokeMetadata
+			}),
+			invokeType: 1
 		},
 		sendEventStreamEnd: {
-			...defineEventa(`${tag}-send-stream-end`),
-			invokeType: InvokeEventType.SendEventStreamEnd
+			...defineEventa(`${tag}-send-stream-end`, {
+				metadata: options?.metadata,
+				invokeMetadata: options?.invokeMetadata
+			}),
+			invokeType: 2
 		},
 		sendEventAbort: {
-			...defineEventa(`${tag}-send-abort`),
-			invokeType: InvokeEventType.SendEventAbort
+			...defineEventa(`${tag}-send-abort`, {
+				metadata: options?.metadata,
+				invokeMetadata: options?.invokeMetadata
+			}),
+			invokeType: 3
 		},
 		receiveEvent: {
-			...defineEventa(`${tag}-receive`),
-			invokeType: InvokeEventType.ReceiveEvent
+			...defineEventa(`${tag}-receive`, {
+				metadata: options?.metadata,
+				invokeMetadata: options?.invokeMetadata
+			}),
+			invokeType: 4
 		},
 		receiveEventError: {
-			...defineEventa(`${tag}-receive-error`),
-			invokeType: InvokeEventType.ReceiveEventError
+			...defineEventa(`${tag}-receive-error`, {
+				metadata: options?.metadata,
+				invokeMetadata: options?.invokeMetadata
+			}),
+			invokeType: 5
 		},
 		receiveEventStreamEnd: {
-			...defineEventa(`${tag}-receive-stream-end`),
-			invokeType: InvokeEventType.ReceiveEventStreamEnd
+			...defineEventa(`${tag}-receive-stream-end`, {
+				metadata: options?.metadata,
+				invokeMetadata: options?.invokeMetadata
+			}),
+			invokeType: 6
 		}
 	};
 }
@@ -83,13 +102,12 @@ function isInvokeEventa(event) {
 }
 function isSendEvent(event) {
 	if (!isInvokeEventa(event)) return false;
-	return event.invokeType === InvokeEventType.SendEvent || event.invokeType === InvokeEventType.SendEventError || event.invokeType === InvokeEventType.SendEventStreamEnd || event.invokeType === InvokeEventType.SendEventAbort;
+	return event.invokeType === 0 || event.invokeType === 1 || event.invokeType === 2 || event.invokeType === 3;
 }
 function isReceiveEvent(event) {
 	if (!isInvokeEventa(event)) return false;
-	return event.invokeType === InvokeEventType.ReceiveEvent || event.invokeType === InvokeEventType.ReceiveEventError || event.invokeType === InvokeEventType.ReceiveEventStreamEnd;
+	return event.invokeType === 4 || event.invokeType === 5 || event.invokeType === 6;
 }
-
 //#endregion
 //#region src/utils.ts
 function randomBetween(min, max) {
@@ -170,7 +188,6 @@ function createUntil(options) {
 		handler: resolve
 	};
 }
-
 //#endregion
 //#region src/invoke.ts
 function isExtendableInvokeResponseLike(value) {
@@ -228,125 +245,127 @@ function isExtendableInvokeResponseLike(value) {
 * @param event Invoke event definition created by `defineInvokeEventa`.
 */
 function defineInvoke(ctx, event) {
-	async function getContext() {
-		if (typeof ctx === "function") {
-			const resolvedCtx = ctx();
-			if (resolvedCtx instanceof Promise) return await resolvedCtx;
-			return resolvedCtx;
-		}
+	function getContext() {
+		if (typeof ctx === "function") return ctx();
 		return ctx;
 	}
-	function _invoke(req, options) {
+	function createInvokePromise(resolvedCtx, req, options) {
 		return new Promise((resolve, reject) => {
-			getContext().then((ctx$1) => {
-				const invokeId = nanoid();
-				const invokeReceiveEvent = defineEventa(`${event.receiveEvent.id}-${invokeId}`);
-				const invokeReceiveEventError = defineEventa(`${event.receiveEventError.id}-${invokeId}`);
-				const { signal, ...emitOptions } = options ?? {};
-				let finished = false;
-				const onAbort = () => {
-					ctx$1.emit(event.sendEventAbort, {
+			const ctx = resolvedCtx;
+			const invokeId = nanoid();
+			const invokeReceiveEvent = defineEventa(`${event.receiveEvent.id}-${invokeId}`);
+			delete invokeReceiveEvent.metadata;
+			const invokeReceiveEventError = defineEventa(`${event.receiveEventError.id}-${invokeId}`);
+			delete invokeReceiveEventError.metadata;
+			const { signal, ...emitOptions } = options ?? {};
+			let finished = false;
+			const onAbort = () => {
+				ctx.emit(event.sendEventAbort, {
+					invokeId,
+					content: signal?.reason
+				}, emitOptions);
+				finishReject(createAbortError(signal?.reason));
+			};
+			const invokeInternalConfig = getContextExtensionInvokeInternalConfig(ctx);
+			const abortOffs = [];
+			const onAbortEvent = (payload, eventOptions) => {
+				const mappedError = invokeInternalConfig?.mapAbortError?.(payload, eventOptions);
+				if (typeof mappedError !== "undefined") {
+					finishReject(mappedError);
+					return;
+				}
+				const body = payload?.body;
+				finishReject(body && typeof body === "object" && "error" in body ? body.error : typeof body !== "undefined" ? body : payload);
+			};
+			const cleanup = () => {
+				ctx.off(invokeReceiveEvent);
+				ctx.off(invokeReceiveEventError);
+				for (const off of abortOffs) off();
+				if (signal) signal.removeEventListener("abort", onAbort);
+			};
+			const finishReject = (error) => {
+				if (finished) return;
+				finished = true;
+				reject(error);
+				cleanup();
+			};
+			const finishResolve = (value) => {
+				if (finished) return;
+				finished = true;
+				resolve(value);
+				cleanup();
+			};
+			ctx.on(invokeReceiveEvent, (payload) => {
+				if (!payload.body) return;
+				if (payload.body.invokeId !== invokeId) return;
+				const { content } = payload.body;
+				finishResolve(content);
+			});
+			ctx.on(invokeReceiveEventError, (payload) => {
+				if (!payload.body) return;
+				if (payload.body.invokeId !== invokeId) return;
+				const { error } = payload.body.content;
+				finishReject(error);
+			});
+			if (invokeInternalConfig?.abortOnEvents?.length) for (const eventOrMatch of invokeInternalConfig.abortOnEvents) abortOffs.push(ctx.on(eventOrMatch, onAbortEvent));
+			if (signal) {
+				if (signal.aborted) {
+					onAbort();
+					return;
+				}
+				signal.addEventListener("abort", onAbort, { once: true });
+			}
+			if (!isReadableStream(req) && !isAsyncIterable(req)) ctx.emit(event.sendEvent, {
+				invokeId,
+				content: req
+			}, emitOptions);
+			else {
+				const sendChunk = (chunk) => {
+					if (finished) return;
+					ctx.emit(event.sendEvent, {
 						invokeId,
-						content: signal?.reason
+						content: chunk,
+						isReqStream: true
 					}, emitOptions);
-					finishReject(createAbortError(signal?.reason));
-				};
-				const invokeInternalConfig = getContextExtensionInvokeInternalConfig(ctx$1);
-				const abortOffs = [];
-				const onAbortEvent = (payload, eventOptions) => {
-					const mappedError = invokeInternalConfig?.mapAbortError?.(payload, eventOptions);
-					if (typeof mappedError !== "undefined") {
-						finishReject(mappedError);
-						return;
-					}
-					const body = payload?.body;
-					finishReject(body && typeof body === "object" && "error" in body ? body.error : typeof body !== "undefined" ? body : payload);
-				};
-				const cleanup = () => {
-					ctx$1.off(invokeReceiveEvent);
-					ctx$1.off(invokeReceiveEventError);
-					for (const off of abortOffs) off();
-					if (signal) signal.removeEventListener("abort", onAbort);
-				};
-				const finishReject = (error) => {
-					if (finished) return;
-					finished = true;
-					reject(error);
-					cleanup();
 				};
-				const finishResolve = (value) => {
+				const sendEnd = () => {
 					if (finished) return;
-					finished = true;
-					resolve(value);
-					cleanup();
+					ctx.emit(event.sendEventStreamEnd, {
+						invokeId,
+						content: void 0
+					}, emitOptions);
 				};
-				ctx$1.on(invokeReceiveEvent, (payload) => {
-					if (!payload.body) return;
-					if (payload.body.invokeId !== invokeId) return;
-					const { content } = payload.body;
-					finishResolve(content);
-				});
-				ctx$1.on(invokeReceiveEventError, (payload) => {
-					if (!payload.body) return;
-					if (payload.body.invokeId !== invokeId) return;
-					const { error } = payload.body.content;
-					finishReject(error);
-				});
-				if (invokeInternalConfig?.abortOnEvents?.length) for (const eventOrMatch of invokeInternalConfig.abortOnEvents) abortOffs.push(ctx$1.on(eventOrMatch, onAbortEvent));
-				if (signal) {
-					if (signal.aborted) {
-						onAbort();
-						return;
-					}
-					signal.addEventListener("abort", onAbort, { once: true });
-				}
-				if (!isReadableStream(req) && !isAsyncIterable(req)) ctx$1.emit(event.sendEvent, {
-					invokeId,
-					content: req
-				}, emitOptions);
-				else {
-					const sendChunk = (chunk) => {
-						if (finished) return;
-						ctx$1.emit(event.sendEvent, {
-							invokeId,
-							content: chunk,
-							isReqStream: true
-						}, emitOptions);
-					};
-					const sendEnd = () => {
-						if (finished) return;
-						ctx$1.emit(event.sendEventStreamEnd, {
-							invokeId,
-							content: void 0
-						}, emitOptions);
-					};
-					const pump = async () => {
-						try {
-							for await (const chunk of req) {
-								if (signal?.aborted) return;
-								sendChunk(chunk);
-							}
-							sendEnd();
-						} catch (error) {
+				const pump = async () => {
+					try {
+						for await (const chunk of req) {
 							if (signal?.aborted) return;
-							if (isAbortError(error)) {
-								ctx$1.emit(event.sendEventAbort, {
-									invokeId,
-									content: error
-								}, emitOptions);
-								return;
-							}
-							ctx$1.emit(event.sendEventError, {
+							sendChunk(chunk);
+						}
+						sendEnd();
+					} catch (error) {
+						if (signal?.aborted) return;
+						if (isAbortError(error)) {
+							ctx.emit(event.sendEventAbort, {
 								invokeId,
 								content: error
 							}, emitOptions);
+							return;
 						}
-					};
-					pump();
-				}
-			});
+						ctx.emit(event.sendEventError, {
+							invokeId,
+							content: error
+						}, emitOptions);
+					}
+				};
+				pump();
+			}
 		});
 	}
+	function _invoke(req, options) {
+		const resolvedCtx = getContext();
+		if (resolvedCtx instanceof Promise) return resolvedCtx.then((ctx) => createInvokePromise(ctx, req, options));
+		return createInvokePromise(resolvedCtx, req, options);
+	}
 	return _invoke;
 }
 /**
@@ -485,17 +504,17 @@ function defineInvokeHandler(ctx, event, handler) {
 			const abortController = abortControllers.get(invokeId);
 			if (!abortController) {
 				abortReasons.set(invokeId, reason);
-				let streamController$1 = streamStates.get(invokeId);
-				if (!streamController$1) {
+				let streamController = streamStates.get(invokeId);
+				if (!streamController) {
 					let localController;
 					const reqStream = new ReadableStream({ start(c) {
 						localController = c;
 					} });
-					streamController$1 = localController;
-					streamStates.set(invokeId, streamController$1);
+					streamController = localController;
+					streamStates.set(invokeId, streamController);
 					handleInvoke(invokeId, reqStream, options);
 				}
-				streamController$1.error(createAbortError(reason));
+				streamController.error(createAbortError(reason));
 				streamStates.delete(invokeId);
 				return;
 			}
@@ -591,7 +610,6 @@ function undefineInvokeHandler(ctx, event, handler) {
 	ctx.invokeHandlers.delete(event.sendEvent.id);
 	return returnValue;
 }
-
 //#endregion
 //#region src/invoke-extension-transfer.ts
 function withTransfer(body, transfer) {
@@ -600,7 +618,6 @@ function withTransfer(body, transfer) {
 		invokeResponse: { transfer: transfer ?? [] }
 	};
 }
-
 //#endregion
 //#region src/invoke-remote-methods.ts
 const DEFAULT_FUNCTION_STUB_OPTIONS = {
@@ -682,10 +699,10 @@ function serializeInvokeFunctionPayload(value, ctx, options) {
 		if (depth > options.maxDepth) throw new Error(`Invoke payload is too deep (max ${options.maxDepth}).`);
 		if (seen.has(input)) return seen.get(input);
 		if (Array.isArray(input)) {
-			const output$1 = Array.from({ length: input.length });
-			seen.set(input, output$1);
-			for (let i = 0; i < input.length; i += 1) output$1[i] = walk(input[i], depth + 1);
-			return output$1;
+			const output = Array.from({ length: input.length });
+			seen.set(input, output);
+			for (let i = 0; i < input.length; i += 1) output[i] = walk(input[i], depth + 1);
+			return output;
 		}
 		if (!isPlainObject(input)) return input;
 		const output = Object.create(null);
@@ -719,10 +736,10 @@ function deserializeInvokeFunctionPayload(value, ctx, options) {
 		} else if (options.strict && hasInvokeFunctionStubKey(input)) throw new Error("Invalid invoke function stub payload.");
 		if (seen.has(input)) return seen.get(input);
 		if (Array.isArray(input)) {
-			const output$1 = Array.from({ length: input.length });
-			seen.set(input, output$1);
-			for (let i = 0; i < input.length; i += 1) output$1[i] = walk(input[i], depth + 1);
-			return output$1;
+			const output = Array.from({ length: input.length });
+			seen.set(input, output);
+			for (let i = 0; i < input.length; i += 1) output[i] = walk(input[i], depth + 1);
+			return output;
 		}
 		if (!isPlainObject(input)) return input;
 		const output = Object.create(null);
@@ -788,9 +805,9 @@ function withRemoteMethods(defaultOptions) {
 				const { functionStubs, ...invokeOptions } = options ?? {};
 				const normalizedOptions = resolveFunctionStubOptions(defaultOptions, functionStubs);
 				if (!normalizedOptions.allow) {
-					const wrapped$1 = baseInvoke(req, invokeOptions);
-					wrapped$1.dispose = () => void 0;
-					return wrapped$1;
+					const wrapped = baseInvoke(req, invokeOptions);
+					wrapped.dispose = () => void 0;
+					return wrapped;
 				}
 				let serialized;
 				try {
@@ -828,7 +845,6 @@ function withRemoteMethods(defaultOptions) {
 		}
 	};
 }
-
 //#endregion
 //#region src/stream.ts
 /**
@@ -1082,17 +1098,17 @@ function defineStreamInvokeHandler(serverCtx, event, fn) {
 		const abortController = abortControllers.get(invokeId);
 		if (!abortController) {
 			abortReasons.set(invokeId, reason);
-			let controller$1 = streamStates.get(invokeId);
-			if (!controller$1) {
+			let controller = streamStates.get(invokeId);
+			if (!controller) {
 				let localController;
 				const reqStream = new ReadableStream({ start(c) {
 					localController = c;
 				} });
-				controller$1 = localController;
-				streamStates.set(invokeId, controller$1);
+				controller = localController;
+				streamStates.set(invokeId, controller);
 				handleInvoke(invokeId, reqStream);
 			}
-			controller$1.error(createAbortError(reason));
+			controller.error(createAbortError(reason));
 			streamStates.delete(invokeId);
 			return;
 		}
@@ -1163,7 +1179,7 @@ function toStreamHandler(handler) {
 		}();
 	};
 }
-
 //#endregion
 export { isInvokeEventa as C, registerInvokeAbortEventListeners as E, defineInvokeEventa as S, isSendEvent as T, isAbortError as _, withRemoteMethods as a, randomBetween as b, defineInvokeHandler as c, isExtendableInvokeResponseLike as d, undefineInvokeHandler as f, createUntilTriggeredOnce as g, createUntilTriggered as h, createRemoteMethodTagPrefix as i, defineInvokeHandlers as l, createUntil as m, defineStreamInvokeHandler as n, withTransfer as o, createAbortError as p, toStreamHandler as r, defineInvoke as s, defineStreamInvoke as t, defineInvokes as u, isAsyncIterable as v, isReceiveEvent as w, InvokeEventType as x, isReadableStream as y };
-//# sourceMappingURL=src-eMqISeHo.mjs.map
+
+//# sourceMappingURL=src-CTs6h4Ci.mjs.map