@vampgg/utils 1.0.0-beta.1

package/dist/async-queue.mjs

@@ -0,0 +1,156 @@
+//#region src/async-queue.ts
+var AsyncQueueOverflowError = class extends Error {
+	constructor(highWaterMark) {
+		super(`async queue overflowed (highWaterMark=${highWaterMark})`);
+		this.name = "AsyncQueueOverflowError";
+	}
+};
+var AsyncQueue = class {
+	buffer;
+	head = 0;
+	count = 0;
+	highWaterMark;
+	overflow;
+	pendingResolve = null;
+	pendingReject = null;
+	closed = false;
+	error;
+	hasError = false;
+	onDispose;
+	disposed = false;
+	constructor(opts = {}, onDispose) {
+		this.highWaterMark = opts.highWaterMark ?? 1024;
+		this.overflow = opts.overflow ?? "error";
+		this.buffer = new Array(Math.min(this.highWaterMark, 32));
+		this.onDispose = onDispose;
+	}
+	/** Producer: enqueue a value. Returns false if the buffer is full (backpressure signal). */
+	push(value) {
+		if (this.closed || this.hasError) return false;
+		if (this.pendingResolve) {
+			const resolve = this.pendingResolve;
+			this.pendingResolve = null;
+			this.pendingReject = null;
+			resolve({
+				value,
+				done: false
+			});
+			return true;
+		}
+		if (this.count >= this.highWaterMark) {
+			if (this.overflow === "error") {
+				this.fail(new AsyncQueueOverflowError(this.highWaterMark));
+				return false;
+			}
+			return false;
+		}
+		this.enqueue(value);
+		return true;
+	}
+	/** Producer: terminate the stream as a clean completion. Idempotent. */
+	close() {
+		if (this.closed || this.hasError) return;
+		this.closed = true;
+		if (this.pendingResolve) {
+			const resolve = this.pendingResolve;
+			this.pendingResolve = null;
+			this.pendingReject = null;
+			resolve({
+				value: void 0,
+				done: true
+			});
+		}
+	}
+	/** Producer: terminate the stream with an error thrown into the consumer. Idempotent. */
+	fail(error) {
+		if (this.closed || this.hasError) return;
+		this.hasError = true;
+		this.error = error;
+		if (this.pendingReject) {
+			const reject = this.pendingReject;
+			this.pendingResolve = null;
+			this.pendingReject = null;
+			reject(error);
+		}
+	}
+	async next() {
+		if (this.count > 0) return {
+			value: this.dequeue(),
+			done: false
+		};
+		if (this.hasError) {
+			await this.dispose();
+			throw this.error;
+		}
+		if (this.closed) {
+			await this.dispose();
+			return {
+				value: void 0,
+				done: true
+			};
+		}
+		return new Promise((resolve, reject) => {
+			this.pendingResolve = resolve;
+			this.pendingReject = reject;
+		});
+	}
+	/** Consumer aborted early (break / return). Runs dispose and ends the stream. */
+	async return(value) {
+		this.closed = true;
+		if (this.pendingResolve) {
+			const resolve = this.pendingResolve;
+			this.pendingResolve = null;
+			this.pendingReject = null;
+			resolve({
+				value: void 0,
+				done: true
+			});
+		}
+		await this.dispose();
+		return {
+			value,
+			done: true
+		};
+	}
+	/** Consumer threw. Propagate after dispose. */
+	async throw(e) {
+		this.closed = true;
+		if (this.pendingReject) {
+			const reject = this.pendingReject;
+			this.pendingResolve = null;
+			this.pendingReject = null;
+			reject(e);
+		}
+		await this.dispose();
+		throw e;
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	enqueue(value) {
+		if (this.count === this.buffer.length) this.grow();
+		const tail = (this.head + this.count) % this.buffer.length;
+		this.buffer[tail] = value;
+		this.count++;
+	}
+	dequeue() {
+		const value = this.buffer[this.head];
+		this.buffer[this.head] = void 0;
+		this.head = (this.head + 1) % this.buffer.length;
+		this.count--;
+		return value;
+	}
+	grow() {
+		const next = new Array(this.buffer.length * 2);
+		for (let i = 0; i < this.count; i++) next[i] = this.buffer[(this.head + i) % this.buffer.length];
+		this.buffer = next;
+		this.head = 0;
+	}
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		await this.onDispose?.();
+	}
+};
+//#endregion
+export { AsyncQueue, AsyncQueueOverflowError };

package/dist/bebop.d.mts

@@ -0,0 +1,37 @@
+import { BebopRecord, BebopView } from "bebop";
+
+//#region src/bebop.d.ts
+declare const BEBOP_SCHEMA: Uint8Array<ArrayBuffer>;
+interface Error {
+  readonly code: number;
+  readonly tag: string;
+  readonly stack: string;
+  readonly msg: string;
+  readonly details: Map<string, string>;
+}
+declare const Error: ((data: Error) => Error & BebopRecord) & {
+  encode(record: Error): Uint8Array<ArrayBufferLike>;
+  encodeInto(record: Error, view: BebopView): void;
+  decode(buffer: Uint8Array<ArrayBufferLike>): Error & BebopRecord;
+  readFrom(view: BebopView): Error;
+};
+interface Message {
+  methodId?: number;
+  messageId?: string;
+  timestamp?: Date;
+  deadline?: Date;
+  data?: Uint8Array;
+  credential?: string;
+  status?: number;
+  previousAttempts?: number;
+  msg?: string;
+  authorization?: string;
+}
+declare const Message: ((data: Message) => Message & BebopRecord) & {
+  encode(record: Message): Uint8Array<ArrayBufferLike>;
+  encodeInto(record: Message, view: BebopView): void;
+  decode(buffer: Uint8Array<ArrayBufferLike>): Message & BebopRecord;
+  readFrom(view: BebopView): Message;
+};
+//#endregion
+export { BEBOP_SCHEMA, Error, Message };

package/dist/bebop.mjs

@@ -0,0 +1,434 @@
+import { BebopView } from "bebop";
+//#region src/bebop.ts
+const BEBOP_SCHEMA = new Uint8Array([
+	3,
+	2,
+	0,
+	0,
+	0,
+	69,
+	114,
+	114,
+	111,
+	114,
+	0,
+	1,
+	0,
+	0,
+	20,
+	0,
+	0,
+	0,
+	0,
+	5,
+	99,
+	111,
+	100,
+	101,
+	0,
+	251,
+	255,
+	255,
+	255,
+	0,
+	116,
+	97,
+	103,
+	0,
+	245,
+	255,
+	255,
+	255,
+	0,
+	115,
+	116,
+	97,
+	99,
+	107,
+	0,
+	245,
+	255,
+	255,
+	255,
+	0,
+	109,
+	115,
+	103,
+	0,
+	245,
+	255,
+	255,
+	255,
+	0,
+	100,
+	101,
+	116,
+	97,
+	105,
+	108,
+	115,
+	0,
+	241,
+	255,
+	255,
+	255,
+	245,
+	255,
+	255,
+	255,
+	245,
+	255,
+	255,
+	255,
+	0,
+	77,
+	101,
+	115,
+	115,
+	97,
+	103,
+	101,
+	0,
+	2,
+	0,
+	5,
+	0,
+	0,
+	0,
+	10,
+	109,
+	101,
+	116,
+	104,
+	111,
+	100,
+	73,
+	100,
+	0,
+	251,
+	255,
+	255,
+	255,
+	0,
+	1,
+	109,
+	101,
+	115,
+	115,
+	97,
+	103,
+	101,
+	73,
+	100,
+	0,
+	244,
+	255,
+	255,
+	255,
+	0,
+	2,
+	116,
+	105,
+	109,
+	101,
+	115,
+	116,
+	97,
+	109,
+	112,
+	0,
+	243,
+	255,
+	255,
+	255,
+	0,
+	3,
+	100,
+	101,
+	97,
+	100,
+	108,
+	105,
+	110,
+	101,
+	0,
+	243,
+	255,
+	255,
+	255,
+	0,
+	4,
+	100,
+	97,
+	116,
+	97,
+	0,
+	242,
+	255,
+	255,
+	255,
+	0,
+	254,
+	255,
+	255,
+	255,
+	0,
+	5,
+	99,
+	114,
+	101,
+	100,
+	101,
+	110,
+	116,
+	105,
+	97,
+	108,
+	0,
+	245,
+	255,
+	255,
+	255,
+	0,
+	6,
+	115,
+	116,
+	97,
+	116,
+	117,
+	115,
+	0,
+	254,
+	255,
+	255,
+	255,
+	0,
+	7,
+	112,
+	114,
+	101,
+	118,
+	105,
+	111,
+	117,
+	115,
+	65,
+	116,
+	116,
+	101,
+	109,
+	112,
+	116,
+	115,
+	0,
+	254,
+	255,
+	255,
+	255,
+	0,
+	8,
+	109,
+	115,
+	103,
+	0,
+	245,
+	255,
+	255,
+	255,
+	0,
+	9,
+	97,
+	117,
+	116,
+	104,
+	111,
+	114,
+	105,
+	122,
+	97,
+	116,
+	105,
+	111,
+	110,
+	0,
+	245,
+	255,
+	255,
+	255,
+	0,
+	10,
+	0,
+	0,
+	0,
+	0
+]);
+const Error = /*#__PURE__*/ Object.freeze(/*#__PURE__*/ Object.assign((data) => {
+	return Object.freeze({
+		...data,
+		encode() {
+			return Error.encode(this);
+		}
+	});
+}, {
+	encode(record) {
+		const view = BebopView.getInstance();
+		view.startWriting();
+		Error.encodeInto(record, view);
+		return view.toArray();
+	},
+	encodeInto(record, view) {
+		view.writeUint32(record.code);
+		view.writeString(record.tag);
+		view.writeString(record.stack);
+		view.writeString(record.msg);
+		view.writeUint32(record.details.size);
+		for (const [k0, v0] of record.details) {
+			view.writeString(k0);
+			view.writeString(v0);
+		}
+	},
+	decode(buffer) {
+		const view = BebopView.getInstance();
+		view.startReading(buffer);
+		return Error(Error.readFrom(view));
+	},
+	readFrom(view) {
+		let field0;
+		field0 = view.readUint32();
+		let field1;
+		field1 = view.readString();
+		let field2;
+		field2 = view.readString();
+		let field3;
+		field3 = view.readString();
+		let field4;
+		{
+			const length0 = view.readUint32();
+			field4 = /* @__PURE__ */ new Map();
+			for (let i0 = 0; i0 < length0; i0++) {
+				let k0;
+				let v0;
+				k0 = view.readString();
+				v0 = view.readString();
+				field4.set(k0, v0);
+			}
+		}
+		return {
+			code: field0,
+			tag: field1,
+			stack: field2,
+			msg: field3,
+			details: field4
+		};
+	}
+}));
+const Message = /*#__PURE__*/ Object.freeze(/*#__PURE__*/ Object.assign((data) => {
+	return {
+		...data,
+		encode() {
+			return Message.encode(this);
+		}
+	};
+}, {
+	encode(record) {
+		const view = BebopView.getInstance();
+		view.startWriting();
+		Message.encodeInto(record, view);
+		return view.toArray();
+	},
+	encodeInto(record, view) {
+		const pos = view.reserveMessageLength();
+		const start = view.length;
+		if (record.methodId !== void 0) {
+			view.writeByte(1);
+			view.writeUint32(record.methodId);
+		}
+		if (record.messageId !== void 0) {
+			view.writeByte(2);
+			view.writeGuid(record.messageId);
+		}
+		if (record.timestamp !== void 0) {
+			view.writeByte(3);
+			view.writeDate(record.timestamp);
+		}
+		if (record.deadline !== void 0) {
+			view.writeByte(4);
+			view.writeDate(record.deadline);
+		}
+		if (record.data !== void 0) {
+			view.writeByte(5);
+			view.writeBytes(record.data);
+		}
+		if (record.credential !== void 0) {
+			view.writeByte(6);
+			view.writeString(record.credential);
+		}
+		if (record.status !== void 0) {
+			view.writeByte(7);
+			view.writeByte(record.status);
+		}
+		if (record.previousAttempts !== void 0) {
+			view.writeByte(8);
+			view.writeByte(record.previousAttempts);
+		}
+		if (record.msg !== void 0) {
+			view.writeByte(9);
+			view.writeString(record.msg);
+		}
+		if (record.authorization !== void 0) {
+			view.writeByte(10);
+			view.writeString(record.authorization);
+		}
+		view.writeByte(0);
+		const end = view.length;
+		view.fillMessageLength(pos, end - start);
+	},
+	decode(buffer) {
+		const view = BebopView.getInstance();
+		view.startReading(buffer);
+		return Message(Message.readFrom(view));
+	},
+	readFrom(view) {
+		const message = {};
+		const length = view.readMessageLength();
+		const end = view.index + length;
+		while (true) switch (view.readByte()) {
+			case 0: return message;
+			case 1:
+				message.methodId = view.readUint32();
+				break;
+			case 2:
+				message.messageId = view.readGuid();
+				break;
+			case 3:
+				message.timestamp = view.readDate();
+				break;
+			case 4:
+				message.deadline = view.readDate();
+				break;
+			case 5:
+				message.data = view.readBytes();
+				break;
+			case 6:
+				message.credential = view.readString();
+				break;
+			case 7:
+				message.status = view.readByte();
+				break;
+			case 8:
+				message.previousAttempts = view.readByte();
+				break;
+			case 9:
+				message.msg = view.readString();
+				break;
+			case 10:
+				message.authorization = view.readString();
+				break;
+			default:
+				view.index = end;
+				return message;
+		}
+	}
+}));
+//#endregion
+export { BEBOP_SCHEMA, Error, Message };

package/dist/context-logger.d.mts

@@ -0,0 +1,11 @@
+import { ConsoleLogger, TempoLogLevel, TempoLogger } from "@tempojs/common";
+
+//#region src/context-logger.d.ts
+declare class ContextLogger extends ConsoleLogger {
+  bindings: Record<string, unknown>;
+  constructor(sourceName: string, logLevel?: TempoLogLevel, parent?: TempoLogger, bindings?: Record<string, unknown>);
+  correlate<TLogger extends TempoLogger>(sourceName: string, correlationId?: string, asOrphan?: boolean, bindings?: Record<string, unknown>): TLogger;
+  clone<TLogger extends TempoLogger>(sourceName: string, asOrphan?: boolean, bindings?: Record<string, unknown>): TLogger;
+}
+//#endregion
+export { ContextLogger };

package/dist/context-logger.mjs

@@ -0,0 +1,31 @@
+import { ConsoleLogger, TempoLogLevel, TempoLogger } from "@tempojs/common";
+//#region src/context-logger.ts
+var ContextLogger = class extends ConsoleLogger {
+	bindings = {};
+	constructor(sourceName, logLevel = TempoLogLevel.Info, parent, bindings = {}) {
+		super(sourceName, logLevel, parent);
+		this.bindings = bindings || {};
+		TempoLogger.instances.delete(sourceName.replace(/\s+/g, "_"));
+	}
+	correlate(sourceName, correlationId, asOrphan, bindings) {
+		return this.clone(sourceName, asOrphan, {
+			...correlationId ? { correlationId } : {},
+			...bindings
+		});
+	}
+	clone(sourceName, asOrphan, bindings) {
+		const logger = Reflect.construct(this.constructor, [
+			sourceName,
+			this.logLevel,
+			asOrphan !== true ? this : void 0
+		]);
+		logger.bindings = {
+			...this.bindings,
+			...bindings
+		};
+		if (asOrphan !== true) this.children.add(logger);
+		return logger;
+	}
+};
+//#endregion
+export { ContextLogger };

package/dist/create-duplex-iterator.d.mts

@@ -0,0 +1,16 @@
+import { AsyncQueueOptions } from "./async-queue.mjs";
+import { CleanupFn, Context } from "./create-event-iterator.mjs";
+import { BebopRecord } from "bebop";
+
+//#region src/create-duplex-iterator.d.ts
+type Writer<T> = (context: Context<T>) => void | CleanupFn | Promise<CleanupFn | void>;
+/**
+ * Duplex stream iterator. The outgoing generator is pumped in its own task and
+ * the incoming stream is drained independently off a bounded {@link AsyncQueue}
+ * — the two are never coupled, so an outgoing send with no incoming reply (or a
+ * server push with no matching outgoing send) neither deadlocks nor drops
+ * frames. Consumer teardown halts the outgoing pump and unsubscribes incoming.
+ */
+declare function createDuplexIterator<T>(outgoing: AsyncGenerator<BebopRecord, void, undefined>, emitter: (record: BebopRecord) => void, incoming: Writer<T>, options?: AsyncQueueOptions): AsyncGenerator<T>;
+//#endregion
+export { Writer, createDuplexIterator };

package/dist/create-duplex-iterator.mjs

@@ -0,0 +1,36 @@
+import { AsyncQueue } from "./async-queue.mjs";
+import { queueIterator } from "./create-event-iterator.mjs";
+//#region src/create-duplex-iterator.ts
+/**
+* Duplex stream iterator. The outgoing generator is pumped in its own task and
+* the incoming stream is drained independently off a bounded {@link AsyncQueue}
+* — the two are never coupled, so an outgoing send with no incoming reply (or a
+* server push with no matching outgoing send) neither deadlocks nor drops
+* frames. Consumer teardown halts the outgoing pump and unsubscribes incoming.
+*/
+function createDuplexIterator(outgoing, emitter, incoming, options) {
+	let unsubscribe;
+	const queue = new AsyncQueue(options, async () => {
+		await outgoing.return?.(void 0);
+		await unsubscribe?.();
+	});
+	const context = {
+		emit: (value) => {
+			queue.push(value);
+		},
+		cancel: () => queue.close(),
+		error: (e) => queue.fail(e)
+	};
+	return queueIterator(queue, async () => {
+		unsubscribe = await incoming(context);
+		(async () => {
+			try {
+				for await (const record of outgoing) emitter(record);
+			} catch (e) {
+				queue.fail(e);
+			}
+		})().catch(() => {});
+	});
+}
+//#endregion
+export { createDuplexIterator };