@mojir/dvala 0.0.15 → 0.0.17

package/dist/cli/cli.js

@@ -118,7 +118,8 @@ const NodeTypes = {
 	SpecialBuiltinSymbol: 7,
 	ReservedSymbol: 8,
 	Binding: 9,
-	Spread: 10
+	Spread: 10,
+	TemplateString: 11
 };
 const NodeTypesSet = new Set(Object.values(NodeTypes));
 function getNodeTypeName(type) {
@@ -477,7 +478,7 @@ function findAllOccurrences(input, pattern) {
 }
 //#endregion
 //#region package.json
-var version = "0.0.15";
+var version = "0.0.17";
 //#endregion
 //#region src/typeGuards/string.ts
 function isString(value, options = {}) {
@@ -24481,6 +24482,128 @@ const standardEffects = {
 				"-effect-dvala.io.read-stdin",
 				"-effect-dvala.io.print",
 				"-effect-dvala.io.println",
+				"-effect-dvala.io.pick",
+				"-effect-dvala.io.confirm",
+				"perform",
+				"effect"
+			]
+		}
+	},
+	"dvala.io.pick": {
+		handler: (args, k, sourceCodeInfo) => {
+			const items = args[0];
+			const options = args[1];
+			if (!Array.isArray(items)) throw new DvalaError(`dvala.io.pick: first argument must be an array, got ${typeof items}`, sourceCodeInfo);
+			if (items.length === 0) throw new DvalaError("dvala.io.pick: items array must not be empty", sourceCodeInfo);
+			for (let i = 0; i < items.length; i++) if (typeof items[i] !== "string") throw new DvalaError(`dvala.io.pick: items[${i}] must be a string, got ${typeof items[i]}`, sourceCodeInfo);
+			let promptMessage;
+			let defaultIndex;
+			if (options !== void 0) {
+				if (typeof options !== "object" || options === null || Array.isArray(options)) throw new DvalaError(`dvala.io.pick: second argument must be an object, got ${typeof options}`, sourceCodeInfo);
+				const opts = options;
+				if (opts["prompt"] !== void 0) {
+					if (typeof opts["prompt"] !== "string") throw new DvalaError("dvala.io.pick: options.prompt must be a string", sourceCodeInfo);
+					promptMessage = opts["prompt"];
+				}
+				if (opts["default"] !== void 0) {
+					if (typeof opts["default"] !== "number" || !Number.isInteger(opts["default"])) throw new DvalaError("dvala.io.pick: options.default must be an integer", sourceCodeInfo);
+					defaultIndex = opts["default"];
+					if (defaultIndex < 0 || defaultIndex >= items.length) throw new DvalaError(`dvala.io.pick: options.default (${defaultIndex}) is out of bounds for array of length ${items.length}`, sourceCodeInfo);
+				}
+			}
+			if (typeof globalThis.prompt === "function") {
+				const listLines = items.map((item, i) => `${i}: ${item}`).join("\n");
+				const message = `${promptMessage ?? "Choose an item:"}${defaultIndex !== void 0 ? ` [default: ${defaultIndex}]` : ""}\n${listLines}`;
+				const result = globalThis.prompt(message);
+				if (result === null) return {
+					type: "Value",
+					value: null,
+					k
+				};
+				const trimmed = result.trim();
+				if (trimmed === "") return {
+					type: "Value",
+					value: defaultIndex !== void 0 ? defaultIndex : null,
+					k
+				};
+				const parsed = Number(trimmed);
+				if (!Number.isInteger(parsed) || parsed < 0 || parsed >= items.length) throw new DvalaError(`dvala.io.pick: invalid selection "${trimmed}"`, sourceCodeInfo);
+				return {
+					type: "Value",
+					value: parsed,
+					k
+				};
+			}
+			throw new DvalaError("dvala.io.pick is not supported in this environment. In Node.js, register a \"dvala.io.pick\" host handler.", sourceCodeInfo);
+		},
+		arity: {
+			min: 1,
+			max: 2
+		},
+		docs: {
+			category: "effect",
+			description: "Presents a numbered list of items and asks the user to choose one. In browsers uses `window.prompt()`. In Node.js, register a host handler. Resumes with the index of the chosen item, or `null` if the user cancels.",
+			returns: { type: ["integer", "null"] },
+			args: {
+				items: {
+					type: "array",
+					description: "Non-empty array of strings to display."
+				},
+				options: {
+					type: "object",
+					description: "Optional settings: `prompt` (string label) and `default` (integer index to use when the user submits an empty input)."
+				}
+			},
+			variants: [{ argumentNames: ["items"] }, { argumentNames: ["items", "options"] }],
+			examples: ["effect(dvala.io.pick)"],
+			seeAlso: [
+				"-effect-dvala.io.read-line",
+				"-effect-dvala.io.confirm",
+				"perform",
+				"effect"
+			]
+		}
+	},
+	"dvala.io.confirm": {
+		handler: (args, k, sourceCodeInfo) => {
+			const question = args[0];
+			const options = args[1];
+			if (typeof question !== "string") throw new DvalaError(`dvala.io.confirm: first argument must be a string, got ${typeof question}`, sourceCodeInfo);
+			if (options !== void 0) {
+				if (typeof options !== "object" || options === null || Array.isArray(options)) throw new DvalaError(`dvala.io.confirm: second argument must be an object, got ${typeof options}`, sourceCodeInfo);
+				const opts = options;
+				if (opts["default"] !== void 0 && typeof opts["default"] !== "boolean") throw new DvalaError("dvala.io.confirm: options.default must be a boolean", sourceCodeInfo);
+			}
+			if (typeof globalThis.confirm === "function") return {
+				type: "Value",
+				value: globalThis.confirm(question),
+				k
+			};
+			throw new DvalaError("dvala.io.confirm is not supported in this environment. In Node.js, register a \"dvala.io.confirm\" host handler.", sourceCodeInfo);
+		},
+		arity: {
+			min: 1,
+			max: 2
+		},
+		docs: {
+			category: "effect",
+			description: "Asks the user a yes/no question. In browsers uses `window.confirm()` and returns `true` (OK) or `false` (Cancel). In Node.js, register a host handler. The optional `default` hints the preferred answer to host handlers (e.g. for rendering `[Y/n]` in a CLI), but has no effect on the browser implementation.",
+			returns: { type: "boolean" },
+			args: {
+				question: {
+					type: "string",
+					description: "The yes/no question to present."
+				},
+				options: {
+					type: "object",
+					description: "Optional settings: `default` (boolean, hints the preferred answer for host handlers)."
+				}
+			},
+			variants: [{ argumentNames: ["question"] }, { argumentNames: ["question", "options"] }],
+			examples: ["effect(dvala.io.confirm)"],
+			seeAlso: [
+				"-effect-dvala.io.read-line",
+				"-effect-dvala.io.pick",
 				"perform",
 				"effect"
 			]
@@ -25688,6 +25811,94 @@ const tokenizeShebang = (input, position) => {
 	}
 	return NO_MATCH;
 };
+const tokenizeTemplateString = (input, position) => {
+	if (input[position] !== "`") return NO_MATCH;
+	let value = "`";
+	let length = 1;
+	while (position + length < input.length) {
+		const char = input[position + length];
+		if (char === "`") {
+			value += "`";
+			length += 1;
+			return [length, ["TemplateString", value]];
+		}
+		if (char === "$" && input[position + length + 1] === "{") {
+			value += "${";
+			length += 2;
+			let braceDepth = 1;
+			while (position + length < input.length && braceDepth > 0) {
+				const c = input[position + length];
+				if (c === "{") {
+					braceDepth += 1;
+					value += c;
+					length += 1;
+				} else if (c === "}") {
+					braceDepth -= 1;
+					value += c;
+					length += 1;
+				} else if (c === "\"") {
+					value += c;
+					length += 1;
+					let escaping = false;
+					while (position + length < input.length) {
+						const sc = input[position + length];
+						value += sc;
+						length += 1;
+						if (escaping) escaping = false;
+						else if (sc === "\\") escaping = true;
+						else if (sc === "\"") break;
+					}
+				} else if (c === "'") {
+					value += c;
+					length += 1;
+					let escaping = false;
+					while (position + length < input.length) {
+						const sc = input[position + length];
+						value += sc;
+						length += 1;
+						if (escaping) escaping = false;
+						else if (sc === "\\") escaping = true;
+						else if (sc === "'") break;
+					}
+				} else if (c === "`") {
+					const [nestedLength, nestedToken] = tokenizeTemplateString(input, position + length);
+					if (nestedLength === 0 || !nestedToken) return [length, [
+						"Error",
+						value,
+						void 0,
+						`Unclosed nested template string at position ${position + length}`
+					]];
+					if (nestedToken[0] === "Error") return [length + nestedLength, [
+						"Error",
+						value + nestedToken[1],
+						void 0,
+						nestedToken[3]
+					]];
+					value += nestedToken[1];
+					length += nestedLength;
+				} else {
+					value += c;
+					length += 1;
+				}
+			}
+			if (braceDepth > 0) return [length, [
+				"Error",
+				value,
+				void 0,
+				`Unclosed interpolation in template string at position ${position}`
+			]];
+		} else {
+			value += char;
+			length += 1;
+		}
+	}
+	return [length, [
+		"Error",
+		value,
+		void 0,
+		`Unclosed template string at position ${position}`
+	]];
+};
 const tokenizeSingleLineComment = (input, position) => {
 	if (input[position] === "/" && input[position + 1] === "/") {
 		let length = 2;
@@ -25712,6 +25923,7 @@ const tokenizers = [
 	tokenizeLBrace,
 	tokenizeRBrace,
 	tokenizeString,
+	tokenizeTemplateString,
 	tokenizeRegexpShorthand,
 	tokenizeBasePrefixedNumber,
 	tokenizeNumber,
@@ -26506,6 +26718,11 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin) {
 			});
 		}
 		case NodeTypes.Spread: return findUnresolvedSymbolsInNode(node[1], contextStack, builtin);
+		case NodeTypes.TemplateString: {
+			const unresolvedSymbols = /* @__PURE__ */ new Set();
+			for (const segment of node[1]) findUnresolvedSymbolsInNode(segment, contextStack, builtin)?.forEach((symbol) => unresolvedSymbols.add(symbol));
+			return unresolvedSymbols;
+		}
 		default: throw new DvalaError(`Unhandled node type: ${nodeType}`, node[2]);
 	}
 }
@@ -27440,6 +27657,176 @@ function parseObject(ctx) {
 	return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.object, params]], firstToken[2]);
 }
 //#endregion
+//#region src/tokenizer/minifyTokenStream.ts
+function minifyTokenStream(tokenStream, { removeWhiteSpace }) {
+	const tokens = tokenStream.tokens.filter((token) => {
+		if (isSingleLineCommentToken(token) || isMultiLineCommentToken(token) || isShebangToken(token) || removeWhiteSpace && isWhitespaceToken(token)) return false;
+		return true;
+	});
+	return {
+		...tokenStream,
+		tokens
+	};
+}
+//#endregion
+//#region src/parser/subParsers/parseTemplateString.ts
+/**
+* Scan from `start` inside a `${...}` interpolation until the matching `}`.
+* Returns the expression source text (without the outer `${` and `}`) and
+* the number of characters consumed (including the closing `}`).
+*/
+function scanExpression(raw, start) {
+	let i = start;
+	let expr = "";
+	let depth = 1;
+	while (i < raw.length && depth > 0) {
+		const c = raw[i];
+		if (c === "{") {
+			depth++;
+			expr += c;
+			i++;
+		} else if (c === "}") {
+			depth--;
+			if (depth > 0) expr += c;
+			i++;
+		} else if (c === "\"") {
+			const { str, consumed } = scanString(raw, i);
+			expr += str;
+			i += consumed;
+		} else if (c === "'") {
+			const { str, consumed } = scanQuotedSymbol(raw, i);
+			expr += str;
+			i += consumed;
+		} else if (c === "`") {
+			const { str, consumed } = scanNestedTemplate(raw, i);
+			expr += str;
+			i += consumed;
+		} else {
+			expr += c;
+			i++;
+		}
+	}
+	return {
+		expr,
+		consumed: i - start
+	};
+}
+function scanString(raw, start) {
+	let i = start + 1;
+	let str = "\"";
+	let escaping = false;
+	while (i < raw.length) {
+		const c = raw[i];
+		str += c;
+		i++;
+		if (escaping) escaping = false;
+		else if (c === "\\") escaping = true;
+		else if (c === "\"") break;
+	}
+	return {
+		str,
+		consumed: i - start
+	};
+}
+function scanQuotedSymbol(raw, start) {
+	let i = start + 1;
+	let str = "'";
+	let escaping = false;
+	while (i < raw.length) {
+		const c = raw[i];
+		str += c;
+		i++;
+		if (escaping) escaping = false;
+		else if (c === "\\") escaping = true;
+		else if (c === "'") break;
+	}
+	return {
+		str,
+		consumed: i - start
+	};
+}
+/**
+* Scan a full nested template string starting at `start` (pointing at the opening backtick).
+* Handles ${...} spans inside the template recursively.
+*/
+function scanNestedTemplate(raw, start) {
+	let i = start + 1;
+	let str = "`";
+	while (i < raw.length) {
+		const c = raw[i];
+		if (c === "`") {
+			str += c;
+			i++;
+			break;
+		} else if (c === "$" && raw[i + 1] === "{") {
+			str += "${";
+			i += 2;
+			const { expr, consumed } = scanExpression(raw, i);
+			str += `${expr}}`;
+			i += consumed;
+		} else {
+			str += c;
+			i++;
+		}
+	}
+	return {
+		str,
+		consumed: i - start
+	};
+}
+/**
+* Split the raw content of a template string (between the surrounding backticks)
+* into alternating literal and expression segments.
+*/
+function splitSegments(raw) {
+	const segments = [];
+	let i = 0;
+	let literal = "";
+	while (i < raw.length) if (raw[i] === "$" && raw[i + 1] === "{") {
+		if (literal.length > 0) {
+			segments.push({
+				type: "literal",
+				value: literal
+			});
+			literal = "";
+		}
+		i += 2;
+		const { expr, consumed } = scanExpression(raw, i);
+		i += consumed;
+		segments.push({
+			type: "expression",
+			value: expr
+		});
+	} else {
+		literal += raw[i];
+		i++;
+	}
+	if (literal.length > 0) segments.push({
+		type: "literal",
+		value: literal
+	});
+	return segments;
+}
+function parseTemplateString(ctx, token) {
+	ctx.advance();
+	const sourceCodeInfo = token[2];
+	const segments = splitSegments(token[1].slice(1, -1));
+	if (segments.length === 0) return withSourceCodeInfo([NodeTypes.String, ""], sourceCodeInfo);
+	if (segments.length === 1 && segments[0].type === "literal") return withSourceCodeInfo([NodeTypes.String, segments[0].value], sourceCodeInfo);
+	const segmentNodes = [];
+	for (const segment of segments) if (segment.type === "literal") {
+		if (segment.value.length === 0) continue;
+		segmentNodes.push(withSourceCodeInfo([NodeTypes.String, segment.value], sourceCodeInfo));
+	} else {
+		if (segment.value.trim().length === 0) throw new DvalaError("Empty interpolation in template string", sourceCodeInfo);
+		const minified = minifyTokenStream(tokenize(segment.value, false, sourceCodeInfo?.filePath), { removeWhiteSpace: true });
+		for (const t of minified.tokens) if (t[0] === "Error") throw new DvalaError(`Template string interpolation error: ${t[3]}`, sourceCodeInfo);
+		const expr = parseExpression(createParserContext(minified), 0);
+		segmentNodes.push(expr);
+	}
+	return withSourceCodeInfo([NodeTypes.TemplateString, segmentNodes], sourceCodeInfo);
+}
+//#endregion
 //#region src/parser/subParsers/parseOperand.ts
 function parseOperand(ctx) {
 	let operand = parseOperandPart(ctx);
@@ -27494,6 +27881,7 @@ function parseOperandPart(ctx) {
 		case "Number":
 		case "BasePrefixedNumber": return parseNumber(ctx);
 		case "string": return parseString(ctx, token);
+		case "TemplateString": return parseTemplateString(ctx, token);
 		case "Symbol": {
 			ctx.storePosition();
 			const lamdaFunction = parseLambdaFunction(ctx);
@@ -27625,18 +28013,6 @@ function parse(tokenStream) {
 	return nodes;
 }
 //#endregion
-//#region src/tokenizer/minifyTokenStream.ts
-function minifyTokenStream(tokenStream, { removeWhiteSpace }) {
-	const tokens = tokenStream.tokens.filter((token) => {
-		if (isSingleLineCommentToken(token) || isMultiLineCommentToken(token) || isShebangToken(token) || removeWhiteSpace && isWhitespaceToken(token)) return false;
-		return true;
-	});
-	return {
-		...tokenStream,
-		tokens
-	};
-}
-//#endregion
 //#region src/evaluator/effectTypes.ts
 const SUSPENDED_MESSAGE = "Program suspended";
 /**
@@ -28317,9 +28693,33 @@ function stepNode(node, env, k) {
 		};
 		case NodeTypes.NormalExpression: return stepNormalExpression(node, env, k);
 		case NodeTypes.SpecialExpression: return stepSpecialExpression(node, env, k);
+		case NodeTypes.TemplateString: return stepTemplateString(node, env, k);
 		default: throw new DvalaError(`${getNodeTypeName(node[0])}-node cannot be evaluated`, node[2]);
 	}
 }
+function stepTemplateString(node, env, k) {
+	const segments = node[1];
+	const sourceCodeInfo = node[2];
+	if (segments.length === 0) return {
+		type: "Value",
+		value: "",
+		k
+	};
+	const frame = {
+		type: "TemplateStringBuild",
+		segments,
+		index: 0,
+		result: "",
+		env,
+		sourceCodeInfo
+	};
+	return {
+		type: "Eval",
+		node: segments[0],
+		env,
+		k: [frame, ...k]
+	};
+}
 /**
 * Normal expressions: evaluate arguments left-to-right, then dispatch.
 * Push EvalArgsFrame + NanCheckFrame, then start evaluating the first arg.
@@ -29249,6 +29649,7 @@ function applyFrame(frame, value, k) {
 		case "And": return applyAnd(frame, value, k);
 		case "Or": return applyOr(frame, value, k);
 		case "Qq": return applyQq(frame, value, k);
+		case "TemplateStringBuild": return applyTemplateStringBuild(frame, value, k);
 		case "ArrayBuild": return applyArrayBuild(frame, value, k);
 		case "ObjectBuild": return applyObjectBuild(frame, value, k);
 		case "LetBind": return applyLetBind(frame, value, k);
@@ -29535,6 +29936,27 @@ function advanceQq(frame, k) {
 function skipUndefinedQq(frame, k) {
 	return advanceQq(frame, k);
 }
+function applyTemplateStringBuild(frame, value, k) {
+	const { segments, env } = frame;
+	const result = frame.result + String(value);
+	const nextIndex = frame.index + 1;
+	if (nextIndex >= segments.length) return {
+		type: "Value",
+		value: result,
+		k
+	};
+	const newFrame = {
+		...frame,
+		index: nextIndex,
+		result
+	};
+	return {
+		type: "Eval",
+		node: segments[nextIndex],
+		env,
+		k: [newFrame, ...k]
+	};
+}
 function applyArrayBuild(frame, value, k) {
 	const { nodes, result, env, sourceCodeInfo } = frame;
 	if (frame.isSpread) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mojir/dvala",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "dvala",
   "author": "Albert Mojir",
   "license": "MIT",
@@ -138,7 +138,9 @@
     "dvala": "node ./dist/cli/cli.js",
     "dev": "npx serve docs -p 9901",
     "test:e2e": "npx playwright test",
+    "test:e2e:prod": "E2E_BASE_URL=https://mojir.github.io/dvala npx playwright test",
     "test:e2e:headed": "npx playwright test --headed",
+    "test:e2e:prod:headed": "E2E_BASE_URL=https://mojir.github.io/dvala npx playwright test --headed",
     "lcov": "open-cli ./coverage/index.html",
     "mcp:inspect": "npx @modelcontextprotocol/inspector node ./dist/mcp-server/server.js"
   },