@samva/markup 0.1.1 → 0.1.2

package/dist/predicate.js

@@ -1,417 +1,2 @@
-import { Result } from "effect";
-//#region src/predicate.ts
-const CHAR_TAB = 9;
-const CHAR_LINE_FEED = 10;
-const CHAR_CARRIAGE_RETURN = 13;
-const CHAR_SPACE = 32;
-const CHAR_BANG = 33;
-const CHAR_SINGLE_QUOTE = 39;
-const CHAR_OPEN_PAREN = 40;
-const CHAR_CLOSE_PAREN = 41;
-const CHAR_MINUS = 45;
-const CHAR_DOT = 46;
-const CHAR_LESS_THAN = 60;
-const CHAR_EQUALS = 61;
-const CHAR_GREATER_THAN = 62;
-const CHAR_UNDERSCORE = 95;
-const CHAR_0 = 48;
-const CHAR_9 = 57;
-const CHAR_UPPER_A = 65;
-const CHAR_UPPER_Z = 90;
-const CHAR_LOWER_A = 97;
-const CHAR_LOWER_Z = 122;
-const isWhitespace = (code) => code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_LINE_FEED || code === CHAR_CARRIAGE_RETURN;
-const isDigit = (code) => code >= CHAR_0 && code <= CHAR_9;
-const isLetter = (code) => code >= CHAR_UPPER_A && code <= CHAR_UPPER_Z || code >= CHAR_LOWER_A && code <= CHAR_LOWER_Z;
-const isNameStart = (code) => isLetter(code) || code === CHAR_UNDERSCORE;
-const isNameChar = (code) => isNameStart(code) || isDigit(code);
-const KEYWORDS = [
-	"and",
-	"or",
-	"not"
-];
-const isKeyword = (text) => KEYWORDS.includes(text);
-const tokenize = (source, baseOffset) => {
-	const tokens = [];
-	let index = 0;
-	const length = source.length;
-	const failAt = (code, message, start, end) => Result.fail({ diagnostic: {
-		code,
-		message,
-		span: {
-			start: baseOffset + start,
-			end: baseOffset + end
-		}
-	} });
-	while (index < length) {
-		const code = source.charCodeAt(index);
-		if (isWhitespace(code)) {
-			index++;
-			continue;
-		}
-		const start = index;
-		if (code === CHAR_OPEN_PAREN) {
-			index++;
-			tokens.push({
-				kind: "lparen",
-				text: "(",
-				span: {
-					start: baseOffset + start,
-					end: baseOffset + index
-				}
-			});
-			continue;
-		}
-		if (code === CHAR_CLOSE_PAREN) {
-			index++;
-			tokens.push({
-				kind: "rparen",
-				text: ")",
-				span: {
-					start: baseOffset + start,
-					end: baseOffset + index
-				}
-			});
-			continue;
-		}
-		if (code === CHAR_EQUALS || code === CHAR_BANG) {
-			if (source.charCodeAt(index + 1) === CHAR_EQUALS) {
-				index += 2;
-				tokens.push({
-					kind: "op",
-					text: code === CHAR_EQUALS ? "==" : "!=",
-					span: {
-						start: baseOffset + start,
-						end: baseOffset + index
-					}
-				});
-				continue;
-			}
-			return failAt("predicate-invalid-operator", `unexpected ${String.fromCharCode(code)} — ${code === CHAR_EQUALS ? "write == to compare" : "write != to compare"}`, start, start + 1);
-		}
-		if (code === CHAR_GREATER_THAN || code === CHAR_LESS_THAN) {
-			index++;
-			if (source.charCodeAt(index) === CHAR_EQUALS) index++;
-			tokens.push({
-				kind: "op",
-				text: source.slice(start, index),
-				span: {
-					start: baseOffset + start,
-					end: baseOffset + index
-				}
-			});
-			continue;
-		}
-		if (code === CHAR_SINGLE_QUOTE) {
-			index++;
-			const contentStart = index;
-			while (index < length && source.charCodeAt(index) !== CHAR_SINGLE_QUOTE) index++;
-			if (index >= length) return failAt("predicate-unterminated-string", "unterminated string — add a closing '", start, length);
-			const value = source.slice(contentStart, index);
-			index++;
-			if (value.includes("--")) return failAt("predicate-string-double-dash", "string literals cannot contain -- (predicates are embedded in HTML comment markers)", start, index);
-			tokens.push({
-				kind: "string",
-				text: source.slice(start, index),
-				string: value,
-				span: {
-					start: baseOffset + start,
-					end: baseOffset + index
-				}
-			});
-			continue;
-		}
-		if (isDigit(code) || code === CHAR_MINUS && isDigit(source.charCodeAt(index + 1))) {
-			index++;
-			while (index < length && isDigit(source.charCodeAt(index))) index++;
-			if (source.charCodeAt(index) === CHAR_DOT && isDigit(source.charCodeAt(index + 1))) {
-				index++;
-				while (index < length && isDigit(source.charCodeAt(index))) index++;
-			}
-			tokens.push({
-				kind: "number",
-				text: source.slice(start, index),
-				number: Number.parseFloat(source.slice(start, index)),
-				span: {
-					start: baseOffset + start,
-					end: baseOffset + index
-				}
-			});
-			continue;
-		}
-		if (isNameStart(code)) {
-			index++;
-			while (index < length && isNameChar(source.charCodeAt(index))) index++;
-			if (source.charCodeAt(index) === CHAR_DOT) return failAt("predicate-path-not-supported", `unexpected . after "${source.slice(start, index)}" — predicates use flat variable names, not paths`, start, index + 1);
-			tokens.push({
-				kind: "name",
-				text: source.slice(start, index),
-				span: {
-					start: baseOffset + start,
-					end: baseOffset + index
-				}
-			});
-			continue;
-		}
-		if (code === CHAR_DOT) return failAt("predicate-path-not-supported", "unexpected . — predicates use flat variable names, not paths", start, start + 1);
-		return failAt("predicate-unexpected-character", `unexpected character ${JSON.stringify(String.fromCharCode(code))} in predicate`, start, start + 1);
-	}
-	tokens.push({
-		kind: "eof",
-		text: "",
-		span: {
-			start: baseOffset + length,
-			end: baseOffset + length
-		}
-	});
-	return Result.succeed(tokens);
-};
-const COMPARISON_OPS = [
-	"==",
-	"!=",
-	">",
-	">=",
-	"<",
-	"<="
-];
-/**
-* Parses a predicate. `baseOffset` is the absolute source offset of the
-* predicate's first character (an <If> test attribute passes valueSpan.start),
-* so diagnostic and node spans point into the containing document.
-*/
-const parsePredicate = (source, baseOffset = 0) => {
-	const lexed = tokenize(source, baseOffset);
-	if (Result.isFailure(lexed)) return Result.fail([lexed.failure.diagnostic]);
-	const tokens = lexed.success;
-	let index = 0;
-	let diagnostic;
-	const fail = (code, message, span) => {
-		diagnostic ??= {
-			code,
-			message,
-			span
-		};
-		return null;
-	};
-	const peek = () => tokens[index];
-	const advance = () => tokens[index++];
-	const isKeywordToken = (token, keyword) => token.kind === "name" && token.text === keyword;
-	const parsePrimary = () => {
-		const token = advance();
-		if (token.kind === "lparen") {
-			const inner = parseOr();
-			if (inner === null) return null;
-			const close = advance();
-			if (close.kind !== "rparen") return fail("predicate-missing-paren", "missing ) — close the group", close.span);
-			return inner;
-		}
-		if (token.kind === "name") {
-			if (isKeyword(token.text)) return fail("predicate-unexpected-token", `unexpected "${token.text}" — expected a variable name, comparison, or ( group )`, token.span);
-			const opToken = peek();
-			if (opToken.kind !== "op") return {
-				kind: "name",
-				name: token.text,
-				span: token.span
-			};
-			advance();
-			const op = COMPARISON_OPS.find((candidate) => candidate === opToken.text);
-			if (op === void 0) return fail("predicate-invalid-operator", `unknown operator ${opToken.text} — use ==, !=, >, >=, <, or <=`, opToken.span);
-			const literalToken = advance();
-			if (literalToken.kind === "string") return {
-				kind: "comparison",
-				name: token.text,
-				op,
-				literal: {
-					kind: "string",
-					value: literalToken.string
-				},
-				span: {
-					start: token.span.start,
-					end: literalToken.span.end
-				}
-			};
-			if (literalToken.kind === "number") return {
-				kind: "comparison",
-				name: token.text,
-				op,
-				literal: {
-					kind: "number",
-					value: literalToken.number
-				},
-				span: {
-					start: token.span.start,
-					end: literalToken.span.end
-				}
-			};
-			return fail("predicate-expected-literal", `expected a literal after ${op} — write ${token.text} ${op} 'value' or ${token.text} ${op} 5`, literalToken.span);
-		}
-		if (token.kind === "eof") return fail("predicate-unexpected-end", "unexpected end of predicate — expected a variable name, comparison, or ( group )", token.span);
-		return fail("predicate-unexpected-token", `unexpected ${token.text} — comparisons put the variable first: name == 'value'`, token.span);
-	};
-	const parseUnary = () => {
-		const token = peek();
-		if (isKeywordToken(token, "not")) {
-			advance();
-			const operand = parsePrimary();
-			if (operand === null) return null;
-			return {
-				kind: "not",
-				operand,
-				span: {
-					start: token.span.start,
-					end: operand.span.end
-				}
-			};
-		}
-		return parsePrimary();
-	};
-	const parseAnd = () => {
-		let left = parseUnary();
-		while (left !== null && isKeywordToken(peek(), "and")) {
-			advance();
-			const right = parseUnary();
-			if (right === null) return null;
-			left = {
-				kind: "and",
-				left,
-				right,
-				span: {
-					start: left.span.start,
-					end: right.span.end
-				}
-			};
-		}
-		return left;
-	};
-	const parseOr = () => {
-		let left = parseAnd();
-		while (left !== null && isKeywordToken(peek(), "or")) {
-			advance();
-			const right = parseAnd();
-			if (right === null) return null;
-			left = {
-				kind: "or",
-				left,
-				right,
-				span: {
-					start: left.span.start,
-					end: right.span.end
-				}
-			};
-		}
-		return left;
-	};
-	if (source.trim().length === 0) return Result.fail([{
-		code: "predicate-empty",
-		message: "empty predicate — write e.g. plan == 'pro'",
-		span: {
-			start: baseOffset,
-			end: baseOffset + source.length
-		}
-	}]);
-	const ast = parseOr();
-	if (ast !== null && diagnostic === void 0) {
-		const trailing = peek();
-		if (trailing.kind !== "eof") fail("predicate-trailing-input", `unexpected ${JSON.stringify(trailing.text)} after the predicate — join clauses with "and" or "or"`, trailing.span);
-	}
-	if (ast === null || diagnostic !== void 0) return Result.fail([diagnostic ?? {
-		code: "predicate-parse-failed",
-		message: "predicate parse failed",
-		span: {
-			start: baseOffset,
-			end: baseOffset + source.length
-		}
-	}]);
-	return Result.succeed(ast);
-};
-const toNumber = (value) => {
-	if (typeof value === "number") return value;
-	if (typeof value === "string" && value.trim() !== "") return Number(value);
-	return NaN;
-};
-const compareNumbers = (op, left, right) => {
-	switch (op) {
-		case "==": return left === right;
-		case "!=": return left !== right;
-		case ">": return left > right;
-		case ">=": return left >= right;
-		case "<": return left < right;
-		case "<=": return left <= right;
-	}
-};
-const evaluateComparison = (node, variables) => {
-	const value = variables[node.name];
-	if (value === void 0 || value === null) return false;
-	if (node.literal.kind === "number") {
-		const left = toNumber(value);
-		if (Number.isNaN(left)) return false;
-		return compareNumbers(node.op, left, node.literal.value);
-	}
-	if (node.op === "==" || node.op === "!=") {
-		if (typeof value !== "string") return false;
-		return node.op === "==" ? value === node.literal.value : value !== node.literal.value;
-	}
-	const left = toNumber(value);
-	const right = toNumber(node.literal.value);
-	if (Number.isNaN(left) || Number.isNaN(right)) return false;
-	return compareNumbers(node.op, left, right);
-};
-const evaluatePredicate = (ast, variables) => {
-	switch (ast.kind) {
-		case "or": return evaluatePredicate(ast.left, variables) || evaluatePredicate(ast.right, variables);
-		case "and": return evaluatePredicate(ast.left, variables) && evaluatePredicate(ast.right, variables);
-		case "not": return !evaluatePredicate(ast.operand, variables);
-		case "comparison": return evaluateComparison(ast, variables);
-		case "name": {
-			const value = variables[ast.name];
-			return value !== void 0 && value !== null && value !== "";
-		}
-	}
-};
-const precedence = (node) => {
-	switch (node.kind) {
-		case "or": return 1;
-		case "and": return 2;
-		case "not": return 3;
-		case "comparison":
-		case "name": return 4;
-	}
-};
-const printLiteral = (literal) => literal.kind === "string" ? `'${literal.value}'` : String(literal.value);
-const printNode = (node, minPrecedence) => {
-	const wrap = (text) => precedence(node) < minPrecedence ? `(${text})` : text;
-	switch (node.kind) {
-		case "or": return wrap(`${printNode(node.left, 1)} or ${printNode(node.right, 1)}`);
-		case "and": return wrap(`${printNode(node.left, 2)} and ${printNode(node.right, 2)}`);
-		case "not": return wrap(`not ${printNode(node.operand, 4)}`);
-		case "comparison": return wrap(`${node.name} ${node.op} ${printLiteral(node.literal)}`);
-		case "name": return wrap(node.name);
-	}
-};
-/** Canonical form: single space around operators/keywords, minimal parens. */
-const printPredicate = (ast) => printNode(ast, 0);
-const collectPredicateVariables = (ast) => {
-	const names = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		switch (node.kind) {
-			case "or":
-			case "and":
-				visit(node.left);
-				visit(node.right);
-				return;
-			case "not":
-				visit(node.operand);
-				return;
-			case "comparison":
-			case "name":
-				names.add(node.name);
-				return;
-		}
-	};
-	visit(ast);
-	return names;
-};
-//#endregion
-export { collectPredicateVariables, evaluatePredicate, parsePredicate, printPredicate };
-
-//# sourceMappingURL=predicate.js.map
+import { a as printPredicate, i as parsePredicate, n as collectPredicateVariables, r as evaluatePredicate, t as PREDICATE_PARSER_LIMITS } from "./predicate-CvkzT-a2.js";
+export { PREDICATE_PARSER_LIMITS, collectPredicateVariables, evaluatePredicate, parsePredicate, printPredicate };

package/dist/presets/category-mapping.d.ts

@@ -1,5 +1,5 @@
 import { PresetCategory } from "../presets.js";
-import { TemplateCollectionId } from "./public-gallery.js";
+import { i as TemplateCollectionId } from "../public-gallery-D0Zv0pZE.js";
 //#region presets/category-mapping.d.ts
 declare const LAB_DIMENSIONS: readonly ["newsletter", "receipt", "security", "product-update", "onboarding", "promotion", "shipping", "social-notification"];
 type LabDimension = (typeof LAB_DIMENSIONS)[number];