@samva/markup 0.1.1 → 0.2.0

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/corpus.d.ts

@@ -0,0 +1,2 @@
+import { a as TemplateCorpusKind, c as TemplateFacetSet, d as templateFacetOptions, i as PublicCorpusRegistrationIssue, l as matchesTemplateFacets, n as OwnedEditablePreset, o as TemplateCorpusRecord, r as PublicCorpusRegistration, s as TemplateFacetQuery, t as InspirationReference, u as registerPublicCorpusEntry } from "../corpus-Dz5irJ9x.js";
+export { InspirationReference, OwnedEditablePreset, PublicCorpusRegistration, PublicCorpusRegistrationIssue, TemplateCorpusKind, TemplateCorpusRecord, TemplateFacetQuery, TemplateFacetSet, matchesTemplateFacets, registerPublicCorpusEntry, templateFacetOptions };

package/dist/presets/corpus.js

@@ -0,0 +1,186 @@
+import { presetCatalog } from "../presets.js";
+import { Result, Schema } from "effect";
+//#region presets/corpus.ts
+const TemplateCorpusKind = Schema.Literals(["owned-editable-sml", "inspiration-reference"]);
+const templateFacetOptions = {
+	jobType: [
+		"account-access",
+		"commerce",
+		"product-communication",
+		"lifecycle",
+		"publishing-campaigns"
+	],
+	lifecycle: [
+		"acquisition",
+		"activation",
+		"engagement",
+		"transaction",
+		"retention",
+		"recovery"
+	],
+	industry: [
+		"saas",
+		"ecommerce",
+		"developer-tools",
+		"newsletters-media"
+	],
+	season: ["evergreen", "seasonal"],
+	audience: [
+		"product-users",
+		"customers",
+		"members",
+		"readers",
+		"shoppers",
+		"teams"
+	],
+	design: [
+		"minimal",
+		"branded",
+		"editorial",
+		"data-heavy",
+		"single-cta"
+	],
+	brandProvenance: ["samva-original", "third-party-reference"]
+};
+const JobTypeFacet = Schema.Literals(templateFacetOptions.jobType);
+const LifecycleFacet = Schema.Literals(templateFacetOptions.lifecycle);
+const IndustryFacet = Schema.Literals(templateFacetOptions.industry);
+const SeasonFacet = Schema.Literals(templateFacetOptions.season);
+const AudienceFacet = Schema.Literals(templateFacetOptions.audience);
+const DesignFacet = Schema.Literals(templateFacetOptions.design);
+const BrandProvenanceFacet = Schema.Literals(templateFacetOptions.brandProvenance);
+const TemplateFacetSet = Schema.Struct({
+	jobType: Schema.Array(JobTypeFacet),
+	lifecycle: Schema.Array(LifecycleFacet),
+	industry: Schema.Array(IndustryFacet),
+	season: Schema.Array(SeasonFacet),
+	audience: Schema.Array(AudienceFacet),
+	design: Schema.Array(DesignFacet),
+	brandProvenance: Schema.Array(BrandProvenanceFacet)
+});
+const CorpusReview = Schema.Struct({
+	state: Schema.Literals([
+		"draft",
+		"approved",
+		"rejected"
+	]),
+	reviewedBy: Schema.String,
+	reviewedAt: Schema.String,
+	notes: Schema.String
+});
+const CorpusDisplay = Schema.Struct({
+	state: Schema.Literals(["hidden", "public"]),
+	attributionLabel: Schema.String
+});
+const CorpusRetention = Schema.Struct({
+	policy: Schema.Literals(["retain-until-withdrawn", "retain-while-linked"]),
+	reviewedAt: Schema.String
+});
+const CorpusTakedown = Schema.Struct({
+	state: Schema.Literals(["active", "removed"]),
+	contact: Schema.String,
+	procedureUrl: Schema.String
+});
+const OwnedEditablePreset = Schema.TaggedStruct("OwnedEditablePreset", {
+	corpusKind: Schema.Literal("owned-editable-sml"),
+	provenance: Schema.Struct({
+		owner: Schema.Literal("Samva"),
+		sourcePath: Schema.String,
+		recordedAt: Schema.String
+	}),
+	review: CorpusReview,
+	display: CorpusDisplay,
+	retention: CorpusRetention,
+	takedown: CorpusTakedown
+});
+const InspirationReference = Schema.TaggedStruct("InspirationReference", {
+	corpusKind: Schema.Literal("inspiration-reference"),
+	provenance: Schema.Struct({
+		publisher: Schema.String,
+		sourceUrl: Schema.String,
+		capturedAt: Schema.String,
+		rightsBasis: Schema.Literals(["display-link-and-commentary", "permission"])
+	}),
+	review: CorpusReview,
+	display: CorpusDisplay,
+	retention: CorpusRetention,
+	takedown: CorpusTakedown
+});
+const TemplateCorpusRecord = Schema.Union([OwnedEditablePreset, InspirationReference]);
+const ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+const nonEmpty = (value) => value.trim().length > 0;
+const isHttpsUrl = (value) => {
+	const url = URL.parse(value);
+	return url?.protocol === "https:" && url.hostname.length > 0 && url.username.length === 0 && url.password.length === 0;
+};
+const requiredFacetDimensions = [
+	"jobType",
+	"lifecycle",
+	"industry",
+	"season",
+	"audience",
+	"design",
+	"brandProvenance"
+];
+const canonicalOwnedPresetSources = new Map(presetCatalog.filter((preset) => preset.channel === "email").map((preset) => [preset.id, `packages/markup/presets/${preset.id}.tsx`]));
+/** Decode and gate a record before it can enter any public projection. */
+const registerPublicCorpusEntry = (input) => {
+	const decoded = Schema.decodeUnknownResult(Schema.Struct({
+		id: Schema.String,
+		corpus: TemplateCorpusRecord,
+		facets: TemplateFacetSet
+	}), { onExcessProperty: "error" })(input);
+	if (Result.isFailure(decoded)) return Result.fail({
+		id: "unknown",
+		message: "record does not match a corpus schema"
+	});
+	const { id, corpus, facets } = decoded.success;
+	const timestamps = [
+		corpus.review.reviewedAt,
+		corpus.retention.reviewedAt,
+		corpus._tag === "InspirationReference" ? corpus.provenance.capturedAt : corpus.provenance.recordedAt
+	];
+	if (!nonEmpty(id) || corpus.review.state !== "approved" || !nonEmpty(corpus.review.reviewedBy) || !nonEmpty(corpus.review.notes) || corpus.display.state !== "public" || !nonEmpty(corpus.display.attributionLabel) || corpus.takedown.state !== "active" || !nonEmpty(corpus.takedown.contact) || !isHttpsUrl(corpus.takedown.procedureUrl) || timestamps.some((timestamp) => !ISO_TIMESTAMP.test(timestamp))) return Result.fail({
+		id,
+		message: "public corpus records require approved review, display, retention, and takedown metadata"
+	});
+	if (corpus._tag === "OwnedEditablePreset" && (canonicalOwnedPresetSources.get(id) !== corpus.provenance.sourcePath || corpus.retention.policy !== "retain-until-withdrawn" || facets.brandProvenance.some((value) => value !== "samva-original"))) return Result.fail({
+		id,
+		message: "owned presets require a canonical editable TSX source"
+	});
+	if (corpus._tag === "InspirationReference" && (!isHttpsUrl(corpus.provenance.sourceUrl) || corpus.retention.policy !== "retain-while-linked" || facets.brandProvenance.some((value) => value !== "third-party-reference"))) return Result.fail({
+		id,
+		message: "inspiration references require an HTTPS source and third-party provenance facet"
+	});
+	for (const dimension of requiredFacetDimensions) {
+		const values = facets[dimension];
+		if (values.length === 0 || new Set(values).size !== values.length) return Result.fail({
+			id,
+			message: `facet ${dimension} must be populated without duplicates`
+		});
+	}
+	return Result.succeed({
+		id,
+		corpus,
+		facets
+	});
+};
+const TemplateFacetQuery = Schema.Struct({
+	jobType: Schema.optionalKey(Schema.Array(JobTypeFacet)),
+	lifecycle: Schema.optionalKey(Schema.Array(LifecycleFacet)),
+	industry: Schema.optionalKey(Schema.Array(IndustryFacet)),
+	season: Schema.optionalKey(Schema.Array(SeasonFacet)),
+	audience: Schema.optionalKey(Schema.Array(AudienceFacet)),
+	design: Schema.optionalKey(Schema.Array(DesignFacet)),
+	brandProvenance: Schema.optionalKey(Schema.Array(BrandProvenanceFacet))
+});
+/** Strict intersection: every selected value in every selected dimension must match. */
+const matchesTemplateFacets = (facets, query) => requiredFacetDimensions.every((dimension) => {
+	const selected = query[dimension];
+	const available = new Set(facets[dimension]);
+	return selected === void 0 || selected.every((value) => available.has(value));
+});
+//#endregion
+export { InspirationReference, OwnedEditablePreset, TemplateCorpusKind, TemplateCorpusRecord, TemplateFacetQuery, TemplateFacetSet, matchesTemplateFacets, registerPublicCorpusEntry, templateFacetOptions };
+
+//# sourceMappingURL=corpus.js.map