semola 0.5.3 → 0.6.0

package/dist/lib/prompts/index.mjs

@@ -1,6 +1,365 @@
-import { createNodePromptRuntime } from "../../prompts/core/runtime.mjs";
-import { runPromptSession } from "../../prompts/core/session.mjs";
+import { mightThrow, mightThrowSync } from "../errors/index.mjs";
 import { styleText } from "node:util";
+//#region src/lib/prompts/errors.ts
+var PromptIOError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PromptIOError";
+	}
+};
+var PromptEnvironmentError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PromptEnvironmentError";
+	}
+};
+var PromptCancelledError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PromptCancelledError";
+	}
+};
+//#endregion
+//#region src/lib/prompts/core/keys.ts
+const ESC = "\x1B";
+const CSI = "\x1B[";
+const ESC_BACKSPACE = `${ESC}\u007F`;
+const CHAR_KEY_MAP = new Map(Object.values({
+	enterCr: {
+		value: "\r",
+		name: "enter"
+	},
+	enterLf: {
+		value: "\n",
+		name: "enter"
+	},
+	ctrlA: {
+		value: "
",
+		name: "ctrl_a"
+	},
+	ctrlC: {
+		value: "",
+		name: "ctrl_c"
+	},
+	ctrlBackspace: {
+		value: "",
+		name: "ctrl_backspace"
+	},
+	backspace: {
+		value: "",
+		name: "backspace"
+	},
+	tab: {
+		value: "	",
+		name: "tab"
+	},
+	space: {
+		value: " ",
+		name: "space"
+	}
+}).map((entry) => [entry.value, { name: entry.name }]));
+const KNOWN_SEQUENCES = [
+	{
+		sequence: "\x1B[1;2D",
+		key: { name: "shift_left" }
+	},
+	{
+		sequence: "\x1B[1;2C",
+		key: { name: "shift_right" }
+	},
+	{
+		sequence: "\x1B[1;5D",
+		key: { name: "ctrl_left" }
+	},
+	{
+		sequence: "\x1B[1;5C",
+		key: { name: "ctrl_right" }
+	},
+	{
+		sequence: "\x1B[1;6D",
+		key: { name: "shift_ctrl_left" }
+	},
+	{
+		sequence: "\x1B[1;6C",
+		key: { name: "shift_ctrl_right" }
+	},
+	{
+		sequence: "\x1B[3~",
+		key: { name: "delete" }
+	},
+	{
+		sequence: "\x1B[H",
+		key: { name: "home" }
+	},
+	{
+		sequence: "\x1B[F",
+		key: { name: "end" }
+	},
+	{
+		sequence: "\x1B[A",
+		key: { name: "up" }
+	},
+	{
+		sequence: "\x1B[B",
+		key: { name: "down" }
+	},
+	{
+		sequence: "\x1B[C",
+		key: { name: "right" }
+	},
+	{
+		sequence: "\x1B[D",
+		key: { name: "left" }
+	}
+];
+const isControlChar = (char) => {
+	return char <= "" || char === "";
+};
+const isCsiFinalByte = (char) => {
+	if (!char) return false;
+	if (char >= "A" && char <= "Z") return true;
+	if (char >= "a" && char <= "z") return true;
+	if (char === "~") return true;
+	return false;
+};
+const readCsiLength = (remaining) => {
+	if (!remaining.startsWith(CSI)) return null;
+	let index = 2;
+	while (index < remaining.length) {
+		if (isCsiFinalByte(remaining[index] ?? "")) return {
+			length: index + 1,
+			incomplete: false
+		};
+		index += 1;
+	}
+	return {
+		length: 0,
+		incomplete: true
+	};
+};
+const parseKeys = (chunk) => {
+	const keys = [];
+	let cursor = 0;
+	while (cursor < chunk.length) {
+		const remaining = chunk.slice(cursor);
+		if (remaining.startsWith(ESC_BACKSPACE)) {
+			keys.push({ name: "ctrl_backspace" });
+			cursor += 2;
+			continue;
+		}
+		const knownSequence = KNOWN_SEQUENCES.find((entry) => remaining.startsWith(entry.sequence));
+		if (knownSequence) {
+			keys.push(knownSequence.key);
+			cursor += knownSequence.sequence.length;
+			continue;
+		}
+		const csiLength = readCsiLength(remaining);
+		if (csiLength) {
+			if (csiLength.incomplete) return {
+				keys,
+				remaining: chunk.slice(cursor)
+			};
+			cursor += csiLength.length;
+			continue;
+		}
+		const char = chunk[cursor] ?? "";
+		switch (char) {
+			case ESC:
+				if (cursor === chunk.length - 1) keys.push({ name: "escape" });
+				break;
+			default: {
+				const key = CHAR_KEY_MAP.get(char);
+				if (key) keys.push(key);
+				else if (!isControlChar(char)) keys.push({
+					name: "character",
+					value: char
+				});
+			}
+		}
+		cursor += 1;
+	}
+	return {
+		keys,
+		remaining: ""
+	};
+};
+//#endregion
+//#region src/lib/prompts/core/runtime.ts
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const countLines = (text) => {
+	let count = 1;
+	for (let i = 0; i < text.length; i++) if (text[i] === "\n") count += 1;
+	return count;
+};
+var NodePromptRuntime = class {
+	stdin;
+	stdout;
+	queue = [];
+	waiters = [];
+	initialized = false;
+	previousLines = 0;
+	buffer = "";
+	constructor(stdin = process.stdin, stdout = process.stdout) {
+		this.stdin = stdin;
+		this.stdout = stdout;
+	}
+	isInteractive() {
+		return Boolean(this.stdin.isTTY && this.stdout.isTTY && typeof this.stdin.setRawMode === "function");
+	}
+	init() {
+		if (!this.isInteractive()) throw new PromptEnvironmentError("Interactive prompts require a TTY with raw mode support");
+		if (this.initialized) return;
+		const [initError] = mightThrowSync(() => {
+			this.stdin.setRawMode(true);
+			this.stdin.setEncoding("utf8");
+			this.stdin.resume();
+			this.stdin.on("data", this.onData);
+			this.stdout.write(HIDE_CURSOR);
+		});
+		if (initError) throw new PromptIOError("Unable to initialize prompt runtime");
+		this.initialized = true;
+	}
+	readKey() {
+		const queued = this.queue.shift();
+		if (queued) return Promise.resolve(queued);
+		return new Promise((resolve, reject) => {
+			this.waiters.push({
+				resolve,
+				reject
+			});
+		});
+	}
+	render(frame) {
+		const [renderError] = mightThrowSync(() => {
+			if (this.previousLines > 1) this.stdout.write(`\u001B[${this.previousLines - 1}A`);
+			this.stdout.write("\r\x1B[J");
+			this.stdout.write(frame);
+			this.previousLines = countLines(frame);
+		});
+		if (renderError) throw new PromptIOError("Unable to render prompt frame");
+	}
+	done(frame) {
+		const [doneError] = mightThrowSync(() => {
+			if (this.previousLines > 1) this.stdout.write(`\u001B[${this.previousLines - 1}A`);
+			this.stdout.write("\r\x1B[J");
+			this.stdout.write(`${frame}\n`);
+			this.previousLines = 0;
+		});
+		if (doneError) throw new PromptIOError("Unable to finalize prompt frame");
+	}
+	close() {
+		if (!this.initialized) return;
+		this.initialized = false;
+		const [closeError] = mightThrowSync(() => {
+			this.stdin.off("data", this.onData);
+			this.stdin.setRawMode(false);
+			this.stdin.pause?.();
+			this.stdout.write(SHOW_CURSOR);
+		});
+		if (closeError) throw new PromptIOError("Unable to close prompt runtime");
+	}
+	interrupt() {
+		this.close();
+		process.exit(0);
+	}
+	onData = (chunk) => {
+		const value = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+		const combined = `${this.buffer}${value}`;
+		this.buffer = "";
+		const [parseError, result] = mightThrowSync(() => parseKeys(combined));
+		if (parseError || !result) {
+			for (const waiter of this.waiters.splice(0)) waiter.reject(new PromptIOError("Failed to parse input"));
+			return;
+		}
+		this.buffer = result.remaining;
+		for (const key of result.keys) {
+			const waiter = this.waiters.shift();
+			if (waiter) waiter.resolve(key);
+			else this.queue.push(key);
+		}
+	};
+};
+const createNodePromptRuntime = () => {
+	return new NodePromptRuntime();
+};
+//#endregion
+//#region src/lib/prompts/core/session.ts
+const CANCEL_MESSAGE = "Interrupted, bye!";
+const resolveOutput = async (options, value) => {
+	if (!options.transform) return value;
+	const [transformError, transformed] = await mightThrow(Promise.resolve().then(() => options.transform?.(value)));
+	if (transformError || transformed === null || transformed === void 0) throw new PromptIOError("Prompt transform callback failed unexpectedly");
+	return transformed;
+};
+const runValidation = async (options, value) => {
+	if (!options.validate) return null;
+	const [validationError, validationMessage] = await mightThrow(Promise.resolve().then(() => options.validate?.(value)));
+	if (validationError) throw new PromptIOError("Prompt validate callback failed unexpectedly");
+	if (typeof validationMessage === "string" && validationMessage.length > 0) return validationMessage;
+	return null;
+};
+const isCancelKey = (key) => {
+	if (key.name === "ctrl_c") return true;
+	if (key.name === "escape") return true;
+	return false;
+};
+const runPromptSession = async (params) => {
+	params.runtime.init();
+	let state = params.initialState;
+	let errorMessage = null;
+	const closeAndDone = (message) => {
+		params.runtime.close();
+		params.runtime.done(message);
+	};
+	const [sessionError, finalValue] = await mightThrow((async () => {
+		while (true) {
+			params.runtime.render(params.render({
+				options: params.options,
+				state,
+				errorMessage
+			}));
+			const key = await params.runtime.readKey();
+			if (!key) throw new PromptIOError("Unable to read prompt input");
+			if (isCancelKey(key)) {
+				params.runtime.close();
+				params.runtime.done(`✖ ${CANCEL_MESSAGE}`);
+				if (params.runtime.interrupt) params.runtime.interrupt(CANCEL_MESSAGE);
+				throw new PromptCancelledError(CANCEL_MESSAGE);
+			}
+			if (key.name !== "enter") {
+				state = params.onKey(state, key);
+				errorMessage = null;
+				continue;
+			}
+			const submitResult = params.onSubmit(state);
+			if ("errorMessage" in submitResult) {
+				errorMessage = submitResult.errorMessage;
+				continue;
+			}
+			const rawValue = submitResult.value;
+			const validationErrorMessage = await runValidation(params.options, rawValue);
+			if (validationErrorMessage) {
+				errorMessage = validationErrorMessage;
+				continue;
+			}
+			const outputValue = await resolveOutput(params.options, rawValue);
+			if (outputValue === null) throw new PromptIOError("Unable to transform prompt value");
+			closeAndDone(params.complete({
+				options: params.options,
+				state,
+				value: outputValue
+			}));
+			return outputValue;
+		}
+	})());
+	if (sessionError) {
+		params.runtime.close();
+		throw sessionError;
+	}
+	return finalValue;
+};
+//#endregion
 //#region src/lib/prompts/index.ts
 const pointer = (active) => {
 	return active ? paint("cyan", "❯") : " ";
@@ -401,5 +760,3 @@ const multiselect = async (options, runtime) => {
 };
 //#endregion
 export { confirm, input, multiselect, number, password, select };
-
-//# sourceMappingURL=index.mjs.map

package/dist/lib/pubsub/index.cjs

@@ -1,5 +1,31 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_lib_errors_index = require("../errors/index.cjs");
+//#region src/lib/pubsub/errors.ts
+var UnsubscribeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnsubscribeError";
+	}
+};
+var SerializationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SerializationError";
+	}
+};
+var PublishError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PublishError";
+	}
+};
+var SubscribeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SubscribeError";
+	}
+};
+//#endregion
 //#region src/lib/pubsub/index.ts
 var PubSub = class {
 	options;
@@ -22,33 +48,32 @@ var PubSub = class {
 		const inFlightUnsubscribe = this.unsubscribeInFlight;
 		if (inFlightUnsubscribe) await inFlightUnsubscribe;
 		const handler = this.handlers.get(handlerId);
-		if (!handler) return require_lib_errors_index.err("UnsubscribeError", "Not subscribed");
+		if (!handler) throw new UnsubscribeError("Not subscribed");
 		this.handlers.delete(handlerId);
-		if (this.handlers.size > 0) return require_lib_errors_index.ok(true);
+		if (this.handlers.size > 0) return;
 		this.isSubscribed = false;
 		this.unsubscribeInFlight = require_lib_errors_index.mightThrow(this.options.subscriber.unsubscribe(this.options.channel));
 		const unsubscribeInFlight = this.unsubscribeInFlight;
 		if (!unsubscribeInFlight) {
 			this.handlers.set(handlerId, handler);
 			this.isSubscribed = true;
-			return require_lib_errors_index.err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+			throw new UnsubscribeError(`Unable to unsubscribe from ${this.options.channel}`);
 		}
 		const [unsubscribeError] = await unsubscribeInFlight;
 		if (unsubscribeError) {
 			this.handlers.set(handlerId, handler);
 			this.isSubscribed = true;
 			this.unsubscribeInFlight = null;
-			return require_lib_errors_index.err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+			throw new UnsubscribeError(`Unable to unsubscribe from ${this.options.channel}`);
 		}
 		this.unsubscribeInFlight = null;
-		return require_lib_errors_index.ok(true);
 	}
 	async publish(message) {
 		const [stringifyError, stringified] = require_lib_errors_index.mightThrowSync(() => JSON.stringify(message));
-		if (stringifyError || !stringified) return require_lib_errors_index.err("SerializationError", "Unable to serialize message");
+		if (stringifyError || !stringified) throw new SerializationError("Unable to serialize message");
 		const [publishError, count] = await require_lib_errors_index.mightThrow(this.options.publisher.publish(this.options.channel, stringified));
-		if (publishError) return require_lib_errors_index.err("PublishError", `Unable to publish to ${this.options.channel}`);
-		return require_lib_errors_index.ok(count);
+		if (publishError) throw new PublishError(`Unable to publish to ${this.options.channel}`);
+		return count;
 	}
 	async subscribe(handler) {
 		const inFlightUnsubscribe = this.unsubscribeInFlight;
@@ -56,39 +81,39 @@ var PubSub = class {
 		const handlerId = this.nextHandlerId;
 		this.nextHandlerId += 1;
 		this.handlers.set(handlerId, handler);
-		if (this.isActive()) return require_lib_errors_index.ok(() => this.unsubscribeHandler(handlerId));
+		if (this.isActive()) return () => this.unsubscribeHandler(handlerId);
 		const inFlightSubscribe = this.subscribeInFlight;
 		if (inFlightSubscribe) {
 			const [inFlightError] = await inFlightSubscribe;
 			if (inFlightError || !this.isSubscribed) {
 				this.handlers.delete(handlerId);
-				return require_lib_errors_index.err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+				throw new SubscribeError(`Unable to subscribe to ${this.options.channel}`);
 			}
-			return require_lib_errors_index.ok(() => this.unsubscribeHandler(handlerId));
+			return () => this.unsubscribeHandler(handlerId);
 		}
 		this.subscribeInFlight = require_lib_errors_index.mightThrow(this.options.subscriber.subscribe(this.options.channel, async (message, channel) => this.onMessage(message, channel)));
 		const subscribeInFlight = this.subscribeInFlight;
 		if (!subscribeInFlight) {
 			this.handlers.delete(handlerId);
-			return require_lib_errors_index.err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+			throw new SubscribeError(`Unable to subscribe to ${this.options.channel}`);
 		}
 		const [subscribeError, count] = await subscribeInFlight;
 		this.subscribeInFlight = null;
 		if (subscribeError) {
 			this.handlers.delete(handlerId);
-			return require_lib_errors_index.err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+			throw new SubscribeError(`Unable to subscribe to ${this.options.channel}`);
 		}
 		if (!count) {
 			this.handlers.delete(handlerId);
-			return require_lib_errors_index.err("SubscribeError", `Unable to subscribe to ${this.options.channel}`);
+			throw new SubscribeError(`Unable to subscribe to ${this.options.channel}`);
 		}
 		this.isSubscribed = true;
-		return require_lib_errors_index.ok(() => this.unsubscribeHandler(handlerId));
+		return () => this.unsubscribeHandler(handlerId);
 	}
 	async unsubscribe() {
 		const inFlightUnsubscribe = this.unsubscribeInFlight;
 		if (inFlightUnsubscribe) await inFlightUnsubscribe;
-		if (!this.isActive()) return require_lib_errors_index.err("UnsubscribeError", "Not subscribed");
+		if (!this.isActive()) throw new UnsubscribeError("Not subscribed");
 		const handlers = new Map(this.handlers);
 		this.handlers.clear();
 		this.isSubscribed = false;
@@ -97,17 +122,16 @@ var PubSub = class {
 		if (!unsubscribeInFlight) {
 			this.handlers = handlers;
 			this.isSubscribed = true;
-			return require_lib_errors_index.err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+			throw new UnsubscribeError(`Unable to unsubscribe from ${this.options.channel}`);
 		}
 		const [unsubscribeError] = await unsubscribeInFlight;
 		if (unsubscribeError) {
 			this.handlers = handlers;
 			this.isSubscribed = true;
 			this.unsubscribeInFlight = null;
-			return require_lib_errors_index.err("UnsubscribeError", `Unable to unsubscribe from ${this.options.channel}`);
+			throw new UnsubscribeError(`Unable to unsubscribe from ${this.options.channel}`);
 		}
 		this.unsubscribeInFlight = null;
-		return require_lib_errors_index.ok(true);
 	}
 	isActive() {
 		return this.handlers.size > 0 && this.isSubscribed;

package/dist/lib/pubsub/index.d.cts

@@ -1,5 +1,11 @@
-import { MessageHandler, PubSubOptions } from "../../pubsub/types.cjs";
-
+//#region src/lib/pubsub/types.d.ts
+type PubSubOptions = {
+  subscriber: Bun.RedisClient;
+  publisher: Bun.RedisClient;
+  channel: string;
+};
+type MessageHandler<T> = (message: T, channel: string) => void | Promise<void>;
+//#endregion
 //#region src/lib/pubsub/index.d.ts
 declare class PubSub<T extends Record<string, unknown>> {
   private options;
@@ -11,26 +17,10 @@ declare class PubSub<T extends Record<string, unknown>> {
   constructor(options: PubSubOptions);
   private onMessage;
   private unsubscribeHandler;
-  publish(message: T): Promise<readonly [{
-    readonly type: "SerializationError";
-    readonly message: string;
-  }, null] | readonly [{
-    readonly type: "PublishError";
-    readonly message: string;
-  }, null] | readonly [null, number]>;
-  subscribe(handler: MessageHandler<T>): Promise<readonly [null, () => Promise<readonly [{
-    readonly type: "UnsubscribeError";
-    readonly message: string;
-  }, null] | readonly [null, boolean]>] | readonly [{
-    readonly type: "SubscribeError";
-    readonly message: string;
-  }, null]>;
-  unsubscribe(): Promise<readonly [{
-    readonly type: "UnsubscribeError";
-    readonly message: string;
-  }, null] | readonly [null, boolean]>;
+  publish(message: T): Promise<number>;
+  subscribe(handler: MessageHandler<T>): Promise<() => Promise<void>>;
+  unsubscribe(): Promise<void>;
   isActive(): boolean;
 }
 //#endregion
-export { PubSub };
-//# sourceMappingURL=index.d.cts.map
+export { PubSub };

package/dist/lib/pubsub/index.d.mts

@@ -1,5 +1,11 @@
-import { MessageHandler, PubSubOptions } from "../../pubsub/types.mjs";
-
+//#region src/lib/pubsub/types.d.ts
+type PubSubOptions = {
+  subscriber: Bun.RedisClient;
+  publisher: Bun.RedisClient;
+  channel: string;
+};
+type MessageHandler<T> = (message: T, channel: string) => void | Promise<void>;
+//#endregion
 //#region src/lib/pubsub/index.d.ts
 declare class PubSub<T extends Record<string, unknown>> {
   private options;
@@ -11,26 +17,10 @@ declare class PubSub<T extends Record<string, unknown>> {
   constructor(options: PubSubOptions);
   private onMessage;
   private unsubscribeHandler;
-  publish(message: T): Promise<readonly [{
-    readonly type: "SerializationError";
-    readonly message: string;
-  }, null] | readonly [{
-    readonly type: "PublishError";
-    readonly message: string;
-  }, null] | readonly [null, number]>;
-  subscribe(handler: MessageHandler<T>): Promise<readonly [null, () => Promise<readonly [{
-    readonly type: "UnsubscribeError";
-    readonly message: string;
-  }, null] | readonly [null, boolean]>] | readonly [{
-    readonly type: "SubscribeError";
-    readonly message: string;
-  }, null]>;
-  unsubscribe(): Promise<readonly [{
-    readonly type: "UnsubscribeError";
-    readonly message: string;
-  }, null] | readonly [null, boolean]>;
+  publish(message: T): Promise<number>;
+  subscribe(handler: MessageHandler<T>): Promise<() => Promise<void>>;
+  unsubscribe(): Promise<void>;
   isActive(): boolean;
 }
 //#endregion
-export { PubSub };
-//# sourceMappingURL=index.d.mts.map
+export { PubSub };