@samva/markup 0.7.0 → 0.9.0

package/dist/email/render.js

@@ -1,6 +1,163 @@
-import { i as renderEmail, n as bindStylesheets, r as compileEmail, t as EMAIL_DOCTYPE } from "../render-aaJBnsXK.js";
-import "./html.js";
-import "./diagnostics.js";
-import "./stylesheets.js";
-import "./text.js";
-export { EMAIL_DOCTYPE, bindStylesheets, compileEmail, renderEmail };
+import { EmailCompileError, hasBlockingDiagnostic } from "./diagnostics.js";
+import { EmailNode, drainEmailDiagnostics } from "./jsx-runtime.js";
+import { t as applyStylesheet } from "../cascade-t6kxlgEI.js";
+import { serializeEmailHtml } from "./html.js";
+import { preheaderNode } from "./components.js";
+import { deriveEmailText } from "./text.js";
+//#region src/email/render.ts
+/** Classic Outlook lays a document out correctly only under a transitional doctype. */
+const EMAIL_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
+const settle = (diagnostics) => {
+	if (hasBlockingDiagnostic(diagnostics)) throw new EmailCompileError({ diagnostics });
+	return diagnostics;
+};
+/** Lower the derived tree to HTML and its plain-text alternative. */
+const compileEmail = (node, options = {}) => {
+	const serialized = serializeEmailHtml(node, options);
+	const diagnostics = settle([...drainEmailDiagnostics(), ...serialized.diagnostics]);
+	return {
+		html: serialized.html,
+		text: deriveEmailText(node),
+		diagnostics,
+		positions: serialized.positions
+	};
+};
+/** Put the hidden preview block first inside `<body>`, or first overall when there is no shell. */
+const withPreheader = (node, text) => {
+	const insert = (current) => {
+		if (current.type === "Fragment") {
+			for (const [index, child] of current.children.entries()) {
+				const replaced = insert(child);
+				if (replaced !== void 0) return EmailNode.Fragment({ children: current.children.with(index, replaced) });
+			}
+			return;
+		}
+		if (current.type !== "Element") return void 0;
+		if (current.tag === "body") return EmailNode.Element({
+			...current,
+			children: [preheaderNode(text), ...current.children]
+		});
+		for (const [index, child] of current.children.entries()) {
+			const replaced = insert(child);
+			if (replaced !== void 0) return EmailNode.Element({
+				...current,
+				children: current.children.with(index, replaced)
+			});
+		}
+	};
+	return insert(node) ?? EmailNode.Fragment({ children: [preheaderNode(text), node] });
+};
+const headStyle = (css, origins) => EmailNode.Element({
+	tag: "style",
+	props: {},
+	children: [EmailNode.Text({ value: css })],
+	origins,
+	authored: false
+});
+/**
+* Put the retained rules in a `<style>` at the end of `<head>`, and project
+* `@font-face` rules in a sibling classic Outlook cannot see. Outlook for
+* Windows registers a face it cannot load and then renders the family in Times
+* New Roman, ignoring the stack; hidden, the family is merely missing and the
+* stack's fallback applies.
+*/
+const withHeadCss = (node, css, fontFaceCss) => {
+	const insert = (current) => {
+		if (current.type === "Fragment") {
+			for (const [index, child] of current.children.entries()) {
+				const replaced = insert(child);
+				if (replaced !== void 0) return EmailNode.Fragment({ children: current.children.with(index, replaced) });
+			}
+			return;
+		}
+		if (current.type !== "Element") return void 0;
+		if (current.tag === "head") return EmailNode.Element({
+			...current,
+			children: [
+				...current.children,
+				...css === "" ? [] : [headStyle(css, current.origins)],
+				...fontFaceCss === "" ? [] : [
+					EmailNode.Raw({
+						html: "<!--[if !mso]><!-->",
+						text: "",
+						origins: []
+					}),
+					headStyle(fontFaceCss, current.origins),
+					EmailNode.Raw({
+						html: "<!--<![endif]-->",
+						text: "",
+						origins: []
+					})
+				]
+			]
+		});
+		for (const [index, child] of current.children.entries()) {
+			const replaced = insert(child);
+			if (replaced !== void 0) return EmailNode.Element({
+				...current,
+				children: current.children.with(index, replaced)
+			});
+		}
+	};
+	return insert(node);
+};
+/**
+* Render authored content against a stylesheet: inline what a client honors,
+* keep the rest for `<head>`, and lower to HTML and text.
+*/
+const renderEmailContent = (stylesheet, render, options = {}) => {
+	drainEmailDiagnostics();
+	const content = render();
+	const invalid = [];
+	const fail = (code, message) => invalid.push({
+		code,
+		severity: "error",
+		message,
+		origins: []
+	});
+	if (typeof content.subject !== "string" || /[\r\n\u0000]/.test(content.subject)) fail("invalid-subject", "Invalid email subject: it must be one line of text.");
+	if (content.preheader !== void 0 && typeof content.preheader !== "string") fail("invalid-preheader", "Invalid email preheader: it must be a string.");
+	if (content.text !== void 0 && typeof content.text !== "string") fail("invalid-text", "Invalid plain text: it must be a string.");
+	settle(invalid);
+	const base = content.preheader === void 0 ? content.body : withPreheader(content.body, content.preheader);
+	const styled = stylesheet === void 0 ? {
+		tree: base,
+		headCss: "",
+		fontFaceCss: "",
+		diagnostics: []
+	} : applyStylesheet(base, stylesheet);
+	const style = [...styled.diagnostics];
+	let tree = styled.tree;
+	if (styled.headCss !== "" || styled.fontFaceCss !== "") {
+		const placed = withHeadCss(tree, styled.headCss, styled.fontFaceCss);
+		if (placed === void 0) style.push({
+			code: "missing-head",
+			severity: "error",
+			message: "Styles that cannot be inlined — media queries, dark-scheme rules and pseudo-selectors — need a <head> to live in. Wrap the message in <Email>, or write those declarations as inline styles.",
+			origins: []
+		});
+		else tree = placed;
+	}
+	settle(style);
+	const compiled = compileEmail(tree, options);
+	const prefix = compiled.html.startsWith("<html") ? EMAIL_DOCTYPE : "";
+	const html = `${prefix}${compiled.html}`;
+	const positions = prefix === "" ? compiled.positions : compiled.positions.map((position) => ({
+		...position,
+		start: position.start + prefix.length,
+		end: position.end + prefix.length
+	}));
+	return {
+		subject: content.subject,
+		preheader: content.preheader,
+		html,
+		text: content.text ?? compiled.text,
+		tree,
+		diagnostics: [...style, ...compiled.diagnostics],
+		positions
+	};
+};
+//#endregion
+export { EMAIL_DOCTYPE, compileEmail, renderEmailContent };
+
+//# sourceMappingURL=render.js.map

package/dist/email/text.d.ts

@@ -1,4 +1,4 @@
-import { m as EmailNode } from "../elements-BzjjnoCS.js";
+import { m as EmailNode } from "../elements-cqldpaJt.js";
 //#region src/email/text.d.ts
 /** Derive the plain-text alternative from the semantic tree in reading order. */
 declare const deriveEmailText: (node: EmailNode) => string;

package/dist/fmt.d.ts

@@ -0,0 +1,32 @@
+//#region src/fmt.d.ts
+declare const DEFAULT_LOCALE = "en-US";
+declare const DEFAULT_TIME_ZONE = "UTC";
+interface FormatContext {
+  readonly locale?: string | undefined;
+  readonly timeZone?: string | undefined;
+}
+type DateStyle = "short" | "medium" | "long" | "full";
+interface PluralForms {
+  readonly zero?: string;
+  readonly one?: string;
+  readonly two?: string;
+  readonly few?: string;
+  readonly many?: string;
+  readonly other: string;
+}
+interface Fmt {
+  money(amount: number, currency: string, locale?: string): string;
+  number(value: number, options?: Intl.NumberFormatOptions, locale?: string): string;
+  date(iso: string, style?: DateStyle, locale?: string): string;
+  time(iso: string, style?: DateStyle, locale?: string): string;
+  plural(count: number, forms: PluralForms, locale?: string): string;
+  list(values: readonly string[], locale?: string): string;
+}
+declare const FORMATTER_NAMES: readonly ["money", "number", "date", "time", "plural", "list"];
+declare const createFmt: (context?: FormatContext) => Fmt;
+declare const withFormatContext: <T>(context: FormatContext, run: () => T) => T;
+declare const fmt: Fmt;
+declare const callFormatter: (formatter: Fmt, name: string, args: readonly unknown[]) => string;
+//#endregion
+export { DEFAULT_LOCALE, DEFAULT_TIME_ZONE, DateStyle, FORMATTER_NAMES, Fmt, FormatContext, PluralForms, callFormatter, createFmt, fmt, withFormatContext };
+//# sourceMappingURL=fmt.d.ts.map

package/dist/fmt.js

@@ -0,0 +1,174 @@
+//#region src/fmt.ts
+const DEFAULT_LOCALE = "en-US";
+const DEFAULT_TIME_ZONE = "UTC";
+const FORMATTER_NAMES = [
+	"money",
+	"number",
+	"date",
+	"time",
+	"plural",
+	"list"
+];
+const CACHE_LIMIT = 200;
+const cache = /* @__PURE__ */ new Map();
+const cached = (kind, locale, options, make) => {
+	const key = `${kind}\u0000${locale}\u0000${options === void 0 ? "" : JSON.stringify(options)}`;
+	const hit = cache.get(key);
+	if (hit !== void 0) return hit;
+	const value = make();
+	if (cache.size >= CACHE_LIMIT) cache.clear();
+	cache.set(key, value);
+	return value;
+};
+const assertFinite = (value, what) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${what} must be a finite number.`);
+};
+const DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+const parseIso = (iso) => {
+	if (typeof iso !== "string") throw new TypeError("ISO date must be a string.");
+	const date = new Date(DATE_ONLY.test(iso) ? `${iso}T00:00:00Z` : iso);
+	if (Number.isNaN(date.getTime())) throw new RangeError(`Cannot parse "${iso}" as an ISO 8601 date.`);
+	return date;
+};
+const createFmt = (context = {}) => {
+	const defaultLocale = context.locale ?? "en-US";
+	const timeZone = context.timeZone ?? "UTC";
+	const pick = (locale) => locale ?? defaultLocale;
+	return {
+		money: (amount, currency, locale) => {
+			assertFinite(amount, "money amount");
+			const l = pick(locale);
+			return cached("money", l, currency, () => new Intl.NumberFormat(l, {
+				style: "currency",
+				currency
+			})).format(amount);
+		},
+		number: (value, options, locale) => {
+			assertFinite(value, "number value");
+			const l = pick(locale);
+			return cached("number", l, options, () => new Intl.NumberFormat(l, options)).format(value);
+		},
+		date: (iso, style = "medium", locale) => {
+			const d = parseIso(iso);
+			const l = pick(locale);
+			return cached("date", l, {
+				style,
+				timeZone
+			}, () => new Intl.DateTimeFormat(l, {
+				dateStyle: style,
+				timeZone
+			})).format(d);
+		},
+		time: (iso, style = "short", locale) => {
+			const d = parseIso(iso);
+			const l = pick(locale);
+			return cached("time", l, {
+				style,
+				timeZone
+			}, () => new Intl.DateTimeFormat(l, {
+				timeStyle: style,
+				timeZone
+			})).format(d);
+		},
+		plural: (count, forms, locale) => {
+			assertFinite(count, "plural count");
+			const l = pick(locale);
+			return forms[cached("plural", l, void 0, () => new Intl.PluralRules(l)).select(count)] ?? forms.other;
+		},
+		list: (values, locale) => {
+			const l = pick(locale);
+			return cached("list", l, void 0, () => new Intl.ListFormat(l, {
+				type: "conjunction",
+				style: "long"
+			})).format(values);
+		}
+	};
+};
+let ambient = {};
+const withFormatContext = (context, run) => {
+	const previous = ambient;
+	ambient = context;
+	try {
+		return run();
+	} finally {
+		ambient = previous;
+	}
+};
+const fmt = {
+	money: (a, c, l) => createFmt(ambient).money(a, c, l),
+	number: (v, o, l) => createFmt(ambient).number(v, o, l),
+	date: (i, s, l) => createFmt(ambient).date(i, s, l),
+	time: (i, s, l) => createFmt(ambient).time(i, s, l),
+	plural: (c, f, l) => createFmt(ambient).plural(c, f, l),
+	list: (v, l) => createFmt(ambient).list(v, l)
+};
+const STYLES = [
+	"short",
+	"medium",
+	"long",
+	"full"
+];
+const PLURAL_KEYS = [
+	"zero",
+	"one",
+	"two",
+	"few",
+	"many",
+	"other"
+];
+const arity = (name, args, min, max) => {
+	if (args.length < min || args.length > max) {
+		const expected = min === max ? `${min}` : `${min} to ${max}`;
+		throw new TypeError(`${name} takes ${expected} arguments but received ${args.length}.`);
+	}
+};
+const str = (name, index, value, optional = false) => {
+	if (value === void 0 && optional) return void 0;
+	if (typeof value !== "string") throw new TypeError(`${name} argument ${index + 1} must be a string.`);
+	return value;
+};
+const num = (name, index, value) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${name} argument ${index + 1} must be a finite number.`);
+	return value;
+};
+const style = (name, index, value) => {
+	if (value === void 0) return void 0;
+	if (typeof value !== "string" || !STYLES.includes(value)) throw new TypeError(`${name} argument ${index + 1} must be one of ${STYLES.join(", ")}.`);
+	return value;
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const callFormatter = (formatter, name, args) => {
+	switch (name) {
+		case "money":
+			arity(name, args, 2, 3);
+			return formatter.money(num(name, 0, args[0]), str(name, 1, args[1]), str(name, 2, args[2], true));
+		case "number": {
+			arity(name, args, 1, 3);
+			const options = args[1];
+			if (options !== void 0 && !isRecord(options)) throw new TypeError("number argument 2 must be an options object.");
+			return formatter.number(num(name, 0, args[0]), options, str(name, 2, args[2], true));
+		}
+		case "date":
+		case "time":
+			arity(name, args, 1, 3);
+			return formatter[name](str(name, 0, args[0]), style(name, 1, args[1]), str(name, 2, args[2], true));
+		case "plural": {
+			arity(name, args, 2, 3);
+			const forms = args[1];
+			if (!isRecord(forms) || typeof forms.other !== "string") throw new TypeError("plural argument 2 must be an object with a string `other` form.");
+			for (const key of PLURAL_KEYS) if (forms[key] !== void 0 && typeof forms[key] !== "string") throw new TypeError(`plural argument 2 form \`${key}\` must be a string.`);
+			return formatter.plural(num(name, 0, args[0]), forms, str(name, 2, args[2], true));
+		}
+		case "list": {
+			arity(name, args, 1, 2);
+			const values = args[0];
+			if (!Array.isArray(values) || values.some((v) => typeof v !== "string")) throw new TypeError("list argument 1 must be an array of strings.");
+			return formatter.list(values, str(name, 1, args[1], true));
+		}
+		default: throw new TypeError(`Unknown formatter "${name}".`);
+	}
+};
+//#endregion
+export { DEFAULT_LOCALE, DEFAULT_TIME_ZONE, FORMATTER_NAMES, callFormatter, createFmt, fmt, withFormatContext };
+
+//# sourceMappingURL=fmt.js.map

package/dist/html-BJepOwZ4.d.ts

@@ -0,0 +1,56 @@
+import { r as JsxSourceLocation } from "./source-locations-C8wCsiAy.js";
+import { r as EmailDiagnostic } from "./diagnostics-B-Gym34R.js";
+import { m as EmailNode } from "./elements-cqldpaJt.js";
+import { n as EmittedPosition } from "./preview-Ekdg1dXG.js";
+//#region src/email/html.d.ts
+/** Escape a value for element content. */
+declare const escapeText: (value: string) => string;
+/** Escape a value for a double-quoted attribute. */
+declare const escapeAttribute: (value: string) => string;
+/** camelCase to kebab-case; already-kebab names pass through unchanged. */
+declare const kebab: (property: string) => string;
+/** A bare number is pixels for every property that takes a length. */
+declare const declarationValue: (property: string, value: string | number) => string;
+interface EmailHtmlOutput {
+  readonly html: string;
+  readonly diagnostics: readonly EmailDiagnostic[];
+  /**
+   * Each emitted element's offset range and origins. A compatibility finding
+   * carries a position in the emitted document, and this is what turns that
+   * back into the authoring element the author can edit.
+   */
+  readonly positions: readonly EmittedPosition[];
+}
+/** How this document will be consumed. Delivery is the default; export is opt-in. */
+interface SerializeEmailOptions {
+  /**
+   * Accept relative references. A local export serves assets from a relative
+   * base beside the file; a delivered message has no directory to resolve one
+   * against, so this stays off for anything that will be sent.
+   */
+  readonly relativeUrls?: boolean | undefined;
+  /**
+   * Stamp every element with its instance path, so an editor preview can
+   * resolve a click in the rendered document to exactly one rendered element.
+   * A delivered message never carries it.
+   */
+  readonly instancePaths?: boolean | undefined;
+}
+/** Lower the derived tree to email HTML, reporting every unsupported construct with its origin. */
+declare const serializeEmailHtml: (node: EmailNode, options?: SerializeEmailOptions) => EmailHtmlOutput;
+/** An authored style object as a declaration list, checked by the same rules as a serialized tree. */
+declare const serializeStyle: (style: Readonly<Record<string, unknown>>, origins: readonly JsxSourceLocation[]) => {
+  readonly css: string;
+  readonly diagnostics: readonly EmailDiagnostic[];
+};
+/**
+ * Check one static attribute value against its element's spec, as serialization does. Returns
+ * the text that would be emitted, or `undefined` when the attribute is dropped or invalid.
+ */
+declare const checkAttribute: (tag: string, name: string, value: unknown, origins: readonly JsxSourceLocation[]) => {
+  readonly text: string | undefined;
+  readonly diagnostics: readonly EmailDiagnostic[];
+};
+//#endregion
+export { escapeAttribute as a, serializeEmailHtml as c, declarationValue as i, serializeStyle as l, SerializeEmailOptions as n, escapeText as o, checkAttribute as r, kebab as s, EmailHtmlOutput as t };
+//# sourceMappingURL=html-BJepOwZ4.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { i as TEMPLATE_ID_PATTERN, o as TemplateInput, r as SmlTemplate, s as defineTemplate, t as EmailChannel } from "./template-_QE_rQND.js";
+export { type EmailChannel, type SmlTemplate, TEMPLATE_ID_PATTERN, type TemplateInput, defineTemplate };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { TEMPLATE_ID_PATTERN, defineTemplate } from "./template.js";
+export { TEMPLATE_ID_PATTERN, defineTemplate };