@samva/markup 0.9.0 → 0.11.0

package/dist/{channel-edit.js → edit.js}

@@ -1,6 +1,344 @@
 import { n as isObject } from "./guards-eV1qLbf2.js";
-import { a as WHATSAPP_HEADER_TYPES, i as WHATSAPP_CATEGORIES, n as SMS_CATEGORIES } from "./channel-specs-B6M_HlaV.js";
+import { d as completeJsxSourceLocation, u as JSX_SOURCE_LOCATION_PROP } from "./jsx-runtime-CBlexoeR.js";
+import { t as buildLineMap } from "./diagnostic-model-DJtqbETd.js";
+import { c as WHATSAPP_HEADER_TYPES, n as introducedProfileErrors, o as SMS_CATEGORIES, s as WHATSAPP_CATEGORIES, t as checkStaticProfile } from "./profile-PUfi3GPH.js";
 import { parse } from "@babel/parser";
+//#region src/source-edit.ts
+const node = (value) => isObject(value) && "type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number" && "end" in value && typeof value.end === "number";
+const children = (value) => Array.isArray(value) ? value.filter(node) : [];
+const walk$1 = (value, visit, parent = null) => {
+	if (Array.isArray(value)) {
+		for (const item of value) walk$1(item, visit, parent);
+		return;
+	}
+	if (!node(value)) return;
+	visit(value, parent);
+	for (const [key, child] of Object.entries(value)) if (key !== "loc" && key !== "extra" && key !== "comments") walk$1(child, visit, value);
+};
+const parsed = (source) => {
+	try {
+		const result = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+		return node(result) ? result : null;
+	} catch {
+		return null;
+	}
+};
+const binding = (value) => value.type === "Identifier" || value.type === "MemberExpression" && value.computed === false && node(value.object) && binding(value.object);
+/** JSX trims each line of text and joins the non-empty lines with one space. */
+const collapseJsxText = (value) => value.split(/\r\n|\n|\r|\u2028|\u2029/).map((line) => line.trim()).filter((line) => line !== "").join(" ");
+const property = (name, value, source, syntax) => {
+	const expression = value.type === "JSXExpressionContainer" && node(value.expression) ? value.expression : value;
+	const literal = expression.type === "StringLiteral" || expression.type === "NumericLiteral" || expression.type === "BooleanLiteral" || expression.type === "JSXText";
+	const raw = source.slice(expression.start, expression.end);
+	const inset = expression.type === "JSXText" ? {
+		start: expression.start + (raw.length - raw.trimStart().length),
+		end: expression.end - (raw.length - raw.trimEnd().length)
+	} : {
+		start: value.start,
+		end: value.end
+	};
+	return {
+		name,
+		literalType: expression.type === "NumericLiteral" ? "number" : expression.type === "BooleanLiteral" ? "boolean" : "string",
+		kind: literal ? "literal" : binding(expression) ? "binding" : "computed",
+		value: literal && expression.type === "JSXText" && typeof expression.value === "string" ? collapseJsxText(expression.value) : literal && (typeof expression.value === "string" || typeof expression.value === "number" || typeof expression.value === "boolean") ? String(expression.value) : source.slice(expression.start, expression.end),
+		start: inset.start,
+		end: inset.end,
+		syntax
+	};
+};
+/** The JSX elements directly before and after `element` in its parent's child list. */
+const siblingsOf = (element, parent, source) => {
+	if (parent?.type !== "JSXElement" && parent?.type !== "JSXFragment") return {
+		previous: null,
+		next: null
+	};
+	const list = children(parent.children).filter((child) => child.type !== "JSXText" || source.slice(child.start, child.end).trim() !== "");
+	const index = list.findIndex((child) => child.start === element.start);
+	const range = (child) => child?.type === "JSXElement" ? {
+		start: child.start,
+		end: child.end
+	} : null;
+	return {
+		previous: range(list[index - 1]),
+		next: range(list[index + 1])
+	};
+};
+/** Resolve a renderer origin against the unchanged authored entry, never against HTML offsets. */
+const inspectSourceElement = (source, file, origin) => {
+	if (file !== origin.fileName) return null;
+	const tree = parsed(source);
+	if (tree === null) return null;
+	const lines = buildLineMap(source);
+	const lineStart = lines[origin.lineNumber - 1];
+	if (lineStart === void 0 || !Number.isInteger(origin.columnNumber) || origin.columnNumber < 1) return null;
+	const offset = lineStart + origin.columnNumber - 1;
+	if (offset >= (lines[origin.lineNumber] ?? source.length)) return null;
+	let found = null;
+	walk$1(tree, (element, parent) => {
+		if (element.type !== "JSXElement" || element.start !== offset || !node(element.openingElement)) return;
+		const opening = element.openingElement;
+		const properties = [];
+		for (const attribute of children(opening.attributes)) if (attribute.type === "JSXAttribute" && node(attribute.name) && typeof attribute.name.name === "string" && node(attribute.value)) {
+			const value = attribute.value;
+			const expression = value.type === "JSXExpressionContainer" && node(value.expression) ? value.expression : null;
+			if (attribute.name.name === "style" && expression?.type === "ObjectExpression" && !children(expression.properties).some((member) => member.type === "SpreadElement")) for (const member of children(expression.properties)) {
+				if (member.type !== "ObjectProperty" || member.computed === true || !node(member.key) || !node(member.value)) continue;
+				const key = member.key.type === "Identifier" ? member.key.name : member.key.value;
+				if (typeof key === "string") properties.push(property(`style.${key}`, member.value, source, "value"));
+			}
+			else properties.push(property(attribute.name.name, value, source, "attribute"));
+		}
+		const meaningful = children(element.children).filter((child) => child.type !== "JSXText" || source.slice(child.start, child.end).trim() !== "");
+		if (meaningful.length === 1 && meaningful[0] !== void 0 && meaningful[0].type !== "JSXElement" && meaningful[0].type !== "JSXFragment") properties.unshift(property("children", meaningful[0], source, "child"));
+		else if (meaningful.length > 1) {
+			const texts = meaningful.flatMap((child, index) => child.type === "JSXText" ? [property(`text.${index}`, child, source, "child")] : []);
+			properties.unshift(...texts);
+		}
+		found = {
+			start: element.start,
+			end: element.end,
+			contentStart: opening.selfClosing === true ? null : opening.end,
+			contentEnd: node(element.closingElement) ? element.closingElement.start : null,
+			tag: node(opening.name) ? source.slice(opening.name.start, opening.name.end) : "element",
+			properties,
+			attributeInsertion: (() => {
+				const last = children(opening.attributes).at(-1);
+				if (last !== void 0) return last.end;
+				return node(opening.name) ? opening.name.end : opening.end - 1;
+			})(),
+			hasSpread: children(opening.attributes).some((attribute) => attribute.type === "JSXSpreadAttribute"),
+			structural: parent?.type === "JSXElement" || parent?.type === "JSXFragment",
+			...siblingsOf(element, parent, source)
+		};
+	});
+	return found;
+};
+const PLAIN_JSX_TEXT = /^[^\s{}<>&](?:[^{}<>&\r\n\u2028\u2029]*[^\s{}<>&])?$/;
+/** Literal controls cannot overwrite a binding or computed expression. */
+const literalReplacement = (source, field, value) => {
+	if (field.kind !== "literal") return null;
+	if (field.literalType === "number" && (value.trim() === "" || !Number.isFinite(Number(value)))) return null;
+	if (field.literalType === "boolean" && value !== "true" && value !== "false") return null;
+	const literal = field.literalType === "string" ? JSON.stringify(value) : field.literalType === "number" ? String(Number(value)) : value;
+	const before = source.slice(field.start, field.end);
+	const plainText = field.syntax === "child" && !before.startsWith("{") && PLAIN_JSX_TEXT.test(value);
+	return {
+		start: field.start,
+		end: field.end,
+		before,
+		after: plainText ? value : field.syntax === "child" || field.syntax === "attribute" && field.literalType !== "string" ? `{${literal}}` : literal
+	};
+};
+/** Explicit expression changes are proposals: callers show before/after and require Apply. */
+const expressionReplacement = (source, field, expression) => ({
+	start: field.start,
+	end: field.end,
+	before: source.slice(field.start, field.end),
+	after: field.syntax === "value" ? expression : `{${expression}}`
+});
+const profileRefusal = (source, result, guard) => {
+	const file = guard.file ?? guard.entry;
+	const project = (content) => ({
+		...guard.files,
+		[file]: content
+	});
+	const introduced = introducedProfileErrors(checkStaticProfile(project(source), guard.entry), checkStaticProfile(project(result), guard.entry));
+	const first = introduced[0];
+	if (first === void 0) return null;
+	const more = introduced.length > 1 ? ` (and ${introduced.length - 1} more)` : "";
+	return `This change leaves the static profile: ${first.message}${first.fix === void 0 ? "" : ` ${first.fix}`}${more}`;
+};
+/** Apply exact, nonoverlapping edits and refuse syntax damage without changing the original. */
+const applySourceReplacements = (source, edits, options = {}) => {
+	const sorted = [...edits].sort((a, b) => b.start - a.start);
+	let boundary = source.length;
+	let result = source;
+	for (const edit of sorted) {
+		if (edit.start < 0 || edit.end < edit.start || edit.end > boundary || source.slice(edit.start, edit.end) !== edit.before) return {
+			ok: false,
+			reason: "Source changed at this target. Select it again before applying the edit."
+		};
+		result = result.slice(0, edit.start) + edit.after + result.slice(edit.end);
+		boundary = edit.start;
+	}
+	if (parsed(result) === null) return {
+		ok: false,
+		reason: "This change is not valid TSX. Review it in Source."
+	};
+	if (options.profile !== void 0 && result !== source) {
+		const refusal = profileRefusal(source, result, options.profile);
+		if (refusal !== null) return {
+			ok: false,
+			reason: refusal
+		};
+	}
+	return {
+		ok: true,
+		source: result
+	};
+};
+const indentation = (source, offset) => {
+	const lineStart = Math.max(source.lastIndexOf("\n", offset - 1), source.lastIndexOf("\r", offset - 1));
+	const lead = source.slice(lineStart + 1, offset);
+	return /^[ \t]*$/.test(lead) ? lead : null;
+};
+/** The whole lines an element alone occupies, so removing it leaves no blank line behind. */
+const ownLines = (source, element) => {
+	if (indentation(source, element.start) === null) return element;
+	const trailing = /^[ \t]*(\r\n|\n|\r)/.exec(source.slice(element.end));
+	if (trailing === null) return element;
+	return {
+		start: element.start - (indentation(source, element.start) ?? "").length,
+		end: element.end + trailing[0].length
+	};
+};
+/** Structural edits name a whole authored block; loop iterations are never source nodes. */
+const structuralReplacements = (source, element, operation) => {
+	if (operation.kind === "insert") {
+		if (element.contentEnd === null) return null;
+		return [{
+			start: element.contentEnd,
+			end: element.contentEnd,
+			before: "",
+			after: operation.tsx
+		}];
+	}
+	if (!element.structural) return null;
+	const text = source.slice(element.start, element.end);
+	if (operation.kind === "duplicate") {
+		const indent = indentation(source, element.start);
+		return [{
+			start: element.end,
+			end: element.end,
+			before: "",
+			after: indent === null ? text : `\n${indent}${text}`
+		}];
+	}
+	if (operation.kind === "reorder") {
+		const neighbour = operation.direction === "before" ? element.previous : element.next;
+		if (neighbour === null) return null;
+		return [{
+			start: neighbour.start,
+			end: neighbour.end,
+			before: source.slice(neighbour.start, neighbour.end),
+			after: text
+		}, {
+			start: element.start,
+			end: element.end,
+			before: text,
+			after: source.slice(neighbour.start, neighbour.end)
+		}];
+	}
+	const removal = ownLines(source, element);
+	const removed = {
+		start: removal.start,
+		end: removal.end,
+		before: source.slice(removal.start, removal.end),
+		after: ""
+	};
+	if (operation.kind === "delete") return [removed];
+	const destination = operation.destination.contentEnd;
+	if (destination === null || destination >= element.start && destination <= element.end) return null;
+	return [removed, {
+		start: destination,
+		end: destination,
+		before: "",
+		after: text
+	}];
+};
+/** The object literal a top-level `const name = { ... }` holds. */
+const topLevelObject = (tree, name) => {
+	const program = tree.program;
+	if (!node(program)) return null;
+	for (const item of children(program.body)) {
+		const declaration = item.type === "ExportNamedDeclaration" && node(item.declaration) ? item.declaration : item;
+		if (declaration.type !== "VariableDeclaration") continue;
+		for (const declarator of children(declaration.declarations)) if (node(declarator.id) && declarator.id.name === name && node(declarator.init) && declarator.init.type === "ObjectExpression") return declarator.init;
+	}
+	return null;
+};
+/** Declared fixture values are separate source targets from body bindings and literals. */
+const inspectSourceFixtures = (source) => {
+	const tree = parsed(source);
+	if (tree === null) return [];
+	const found = [];
+	walk$1(tree, (call) => {
+		if (call.type !== "CallExpression" || !node(call.callee) || call.callee.type !== "Identifier" || call.callee.name !== "defineTemplate") return;
+		const definition = children(call.arguments)[0];
+		if (definition?.type !== "ObjectExpression") return;
+		const fixtures = children(definition.properties).find((field) => field.type === "ObjectProperty" && node(field.key) && field.key.name === "fixtures" && field.computed !== true);
+		if (fixtures === void 0 || !node(fixtures.value) || fixtures.value.type !== "ObjectExpression") return;
+		for (const field of children(fixtures.value.properties)) {
+			if (field.type !== "ObjectProperty" || field.computed === true || !node(field.key) || !node(field.value)) continue;
+			const name = field.key.type === "Identifier" ? field.key.name : field.key.value;
+			const value = field.value.type === "Identifier" && typeof field.value.name === "string" ? topLevelObject(tree, field.value.name) ?? field.value : field.value;
+			if (typeof name === "string") found.push({
+				name,
+				start: value.start,
+				end: value.end,
+				source: source.slice(value.start, value.end)
+			});
+		}
+	});
+	return found;
+};
+const tokens = (value) => value.split(/\s+/).filter((item) => item !== "");
+/**
+* Edit an element's class list where it is written. A literal `className` is replaced, extended or
+* trimmed in place; a missing one is added; one that is a condition or any other expression is
+* refused, because rewriting it would discard the choice the author encoded.
+*/
+const classNameEdit = (source, element, operation) => {
+	const field = element.properties.find((item) => item.name === "className");
+	const next = (current) => {
+		if (operation.kind === "set") return tokens(operation.value).join(" ");
+		const wanted = tokens(operation.tokens);
+		return operation.kind === "add" ? [...current, ...wanted.filter((item) => !current.includes(item))].join(" ") : current.filter((item) => !wanted.includes(item)).join(" ");
+	};
+	if (field === void 0) {
+		if (element.hasSpread) return {
+			ok: false,
+			reason: "A spread attribute can supply className here, so a class list cannot be added safely. Edit it in Source."
+		};
+		if (operation.kind === "remove") return {
+			ok: true,
+			edits: []
+		};
+		const value = next([]);
+		if (value === "") return {
+			ok: true,
+			edits: []
+		};
+		return {
+			ok: true,
+			edits: [{
+				start: element.attributeInsertion,
+				end: element.attributeInsertion,
+				before: "",
+				after: ` className=${JSON.stringify(value)}`
+			}]
+		};
+	}
+	if (field.kind !== "literal" || field.literalType !== "string") return {
+		ok: false,
+		reason: `className is ${field.kind === "binding" ? "bound to" : "computed from"} \`${field.value}\`, so editing it would discard that choice. Change the literal classes inside it in Source.`
+	};
+	const value = next(tokens(field.value));
+	return {
+		ok: true,
+		edits: [{
+			start: field.start,
+			end: field.end,
+			before: source.slice(field.start, field.end),
+			after: JSON.stringify(value)
+		}]
+	};
+};
+//#endregion
 //#region src/channel-edit.ts
 const isNode = (value) => isObject(value) && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
 const nodeList = (value) => Array.isArray(value) ? value.filter(isNode) : [];
@@ -604,6 +942,6 @@ const editWhatsAppChannel = (source, edit) => {
 	}
 };
 //#endregion
-export { editSmsChannel, editWhatsAppChannel, readSmsChannel, readWhatsAppChannel };
+export { JSX_SOURCE_LOCATION_PROP, applySourceReplacements, classNameEdit, completeJsxSourceLocation, editSmsChannel, editWhatsAppChannel, expressionReplacement, inspectSourceElement, inspectSourceFixtures, literalReplacement, readSmsChannel, readWhatsAppChannel, structuralReplacements };
 
-//# sourceMappingURL=channel-edit.js.map
+//# sourceMappingURL=edit.js.map

package/dist/email/jsx-dev-runtime.d.ts

@@ -1,5 +1,5 @@
 import { n as JsxSource } from "../source-locations-C8wCsiAy.js";
-import { g as JSX, h as Fragment, m as EmailNode, p as EmailComponent } from "../elements-cqldpaJt.js";
+import { a as JSX, i as Fragment, n as EmailComponent, r as EmailNode } from "../jsx-runtime-ylIOnaSf.js";
 //#region src/email/jsx-dev-runtime.d.ts
 /** Development JSX retains compiler-provided origins directly on the semantic tree. */
 declare const jsxDEV: (type: string | EmailComponent<Record<string, unknown>> | typeof Fragment, props: Record<string, unknown> | null, _key?: unknown, _staticChildren?: boolean, source?: JsxSource) => EmailNode;

package/dist/email/jsx-dev-runtime.js

@@ -1,5 +1,4 @@
-import { JSX_SOURCE_LOCATION_PROP } from "../source-locations.js";
-import { Fragment, jsx } from "./jsx-runtime.js";
+import { a as jsx, n as Fragment, u as JSX_SOURCE_LOCATION_PROP } from "../jsx-runtime-CBlexoeR.js";
 //#region src/email/jsx-dev-runtime.ts
 /** Development JSX retains compiler-provided origins directly on the semantic tree. */
 const jsxDEV = (type, props, _key, _staticChildren, source) => jsx(type, {

package/dist/email/jsx-runtime.d.ts

@@ -1,2 +1,2 @@
-import { C as reportEmailDiagnostic, S as rawMarkup, _ as currentEmailOrigins, b as jsxs, f as EmailChild, g as JSX, h as Fragment, m as EmailNode, p as EmailComponent, v as drainEmailDiagnostics, x as normalizeChildren, y as jsx } from "../elements-cqldpaJt.js";
+import { a as JSX, c as jsx, d as rawMarkup, f as reportEmailDiagnostic, i as Fragment, l as jsxs, n as EmailComponent, o as currentEmailOrigins, r as EmailNode, s as drainEmailDiagnostics, t as EmailChild, u as normalizeChildren } from "../jsx-runtime-ylIOnaSf.js";
 export { EmailChild, EmailComponent, EmailNode, Fragment, JSX, currentEmailOrigins, drainEmailDiagnostics, jsx, jsxs, normalizeChildren, rawMarkup, reportEmailDiagnostic };

package/dist/email/jsx-runtime.js

@@ -1,86 +1,2 @@
-import { t as hasProperty } from "../guards-eV1qLbf2.js";
-import { JSX_SOURCE_LOCATION_PROP, completeJsxSourceLocation } from "../source-locations.js";
-//#region src/email/jsx-runtime.ts
-/** Constructors for the authoring tree. The tree is data; nothing here validates it. */
-const EmailNode = {
-	Text: (fields) => ({
-		type: "Text",
-		...fields
-	}),
-	Element: (fields) => ({
-		type: "Element",
-		...fields
-	}),
-	Fragment: (fields) => ({
-		type: "Fragment",
-		...fields
-	}),
-	Raw: (fields) => ({
-		type: "Raw",
-		...fields
-	})
-};
-const EMAIL_NODE_TYPES = /* @__PURE__ */ new Set([
-	"Text",
-	"Element",
-	"Fragment",
-	"Raw"
-]);
-/** True for a node this runtime built; anything else is not a child it can place. */
-const isEmailNode = (input) => hasProperty(input, "type") && typeof input.type === "string" && EMAIL_NODE_TYPES.has(input.type);
-const Fragment = Symbol.for("@samva/markup/email/Fragment");
-const callSites = [];
-/** Call sites enclosing the element being built, innermost first. */
-const currentEmailOrigins = () => [...callSites].reverse();
-const reported = [];
-/** Record a finding from inside a compiler primitive, located at the authoring call site. */
-const reportEmailDiagnostic = (diagnostic) => {
-	reported.push({
-		...diagnostic,
-		origins: currentEmailOrigins()
-	});
-};
-/** Take and clear the findings primitives reported during a render. */
-const drainEmailDiagnostics = () => reported.splice(0);
-/** Normalize actual values without interpolation or recording proxies. */
-const normalizeChildren = (input) => {
-	if (input === null || input === void 0 || typeof input === "boolean") return [];
-	if (typeof input === "string") return [EmailNode.Text({ value: input })];
-	if (typeof input === "number" && Number.isFinite(input)) return [EmailNode.Text({ value: String(input) })];
-	if (Array.isArray(input)) return input.flatMap(normalizeChildren);
-	if (isEmailNode(input)) return [input];
-	throw new TypeError("Email children must be synchronous text, finite numbers, elements, or arrays");
-};
-/** Compatibility markup emitted by a compiler primitive, with the text it stands for. */
-const rawMarkup = (html, text = "") => EmailNode.Raw({
-	html,
-	text,
-	origins: currentEmailOrigins()
-});
-/** Automatic JSX factory for ordinary HTML and synchronous imported components. */
-const jsx = (type, props) => {
-	const { children, [JSX_SOURCE_LOCATION_PROP]: source, ...attributes } = props ?? {};
-	const origin = completeJsxSourceLocation(source);
-	if (type === Fragment) return EmailNode.Fragment({ children: normalizeChildren(children) });
-	if (typeof type === "string") return EmailNode.Element({
-		tag: type,
-		props: attributes,
-		children: normalizeChildren(children),
-		origins: origin === void 0 ? currentEmailOrigins() : [origin, ...currentEmailOrigins()],
-		authored: origin !== void 0
-	});
-	if (origin !== void 0) callSites.push(origin);
-	try {
-		return EmailNode.Fragment({ children: normalizeChildren(type({
-			...attributes,
-			children
-		})) });
-	} finally {
-		if (origin !== void 0) callSites.pop();
-	}
-};
-const jsxs = jsx;
-//#endregion
+import { a as jsx, c as rawMarkup, i as drainEmailDiagnostics, l as reportEmailDiagnostic, n as Fragment, o as jsxs, r as currentEmailOrigins, s as normalizeChildren, t as EmailNode } from "../jsx-runtime-CBlexoeR.js";
 export { EmailNode, Fragment, currentEmailOrigins, drainEmailDiagnostics, jsx, jsxs, normalizeChildren, rawMarkup, reportEmailDiagnostic };
-
-//# sourceMappingURL=jsx-runtime.js.map

package/dist/{email/components.d.ts → email.d.ts}

@@ -1,4 +1,4 @@
-import { c as EmailStyle, f as EmailChild, m as EmailNode } from "../elements-cqldpaJt.js";
+import { b as EmailStyle, r as EmailNode, t as EmailChild } from "./jsx-runtime-ylIOnaSf.js";
 //#region src/email/components.d.ts
 /** Marks the hidden preview block so the renderer can read it back and the text lane can keep it. */
 declare const PREHEADER_ATTRIBUTE = "data-samva-preheader";
@@ -133,4 +133,4 @@ interface LinkProps {
 declare const Link: ({ className, href, target, rel, style, children }: LinkProps) => EmailNode;
 //#endregion
 export { Button, ButtonProps, Column, ColumnProps, Columns, ColumnsProps, Divider, DividerProps, Email, EmailProps, Image, ImageProps, Link, LinkProps, PREHEADER_ATTRIBUTE, Section, SectionProps, Spacer, SpacerProps, equalColumnWidth, preheaderNode };
-//# sourceMappingURL=components.d.ts.map
+//# sourceMappingURL=email.d.ts.map

package/dist/email.js

@@ -0,0 +1,2 @@
+import { a as Email, c as PREHEADER_ATTRIBUTE, d as equalColumnWidth, f as preheaderNode, i as Divider, l as Section, n as Column, o as Image, r as Columns, s as Link, t as Button, u as Spacer } from "./components-Bl6DT21n.js";
+export { Button, Column, Columns, Divider, Email, Image, Link, PREHEADER_ATTRIBUTE, Section, Spacer, equalColumnWidth, preheaderNode };