@samva/markup 0.8.0 → 0.9.0

package/dist/email/components.js

@@ -1,4 +1,4 @@
-import { jsx, rawMarkup, reportEmailDiagnostic } from "./jsx-runtime.js";
+import { EmailNode, Fragment, jsx, normalizeChildren, rawMarkup, reportEmailDiagnostic } from "./jsx-runtime.js";
 import { escapeAttribute, escapeText } from "./html.js";
 //#region src/email/components.ts
 /** Marks the hidden preview block so the renderer can read it back and the text lane can keep it. */
@@ -34,7 +34,7 @@ const preheaderNode = (text) => jsx("div", {
 	})]
 });
 /** Document shell: the head every target client needs, plus the body content cell. */
-const Email = ({ className, lang = "en", dir = "ltr", title, preheader, backgroundColor, style, children }) => jsx("html", {
+const Email = ({ className, lang = "en", dir = "ltr", title, backgroundColor, style, children }) => jsx("html", {
 	lang,
 	dir,
 	xmlns: "http://www.w3.org/1999/xhtml",
@@ -66,7 +66,7 @@ const Email = ({ className, lang = "en", dir = "ltr", title, preheader, backgrou
 			padding: 0,
 			...backgroundColor === void 0 ? {} : { backgroundColor }
 		},
-		children: [preheader === void 0 ? null : preheaderNode(preheader), presentation({
+		children: [presentation({
 			align: "center",
 			width: "100%",
 			...backgroundColor === void 0 ? {} : { bgcolor: backgroundColor }
@@ -88,13 +88,48 @@ const Section = ({ className, align = "center", width = "100%", bgcolor, style,
 	...style === void 0 ? {} : { style },
 	children
 }));
-/** A row of side-by-side `Column`s. No flex or grid conversion happens here. */
-const Columns = ({ className, align = "center", width = "100%", style, children }) => presentation({
-	className,
-	align,
-	width,
-	...style === void 0 ? {} : { style }
-}, children, { style: { width: "100%" } });
+/** The equal share of a row that each of `count` cells takes, whole percent rounded down. */
+const equalColumnWidth = (count) => `${Math.floor(100 / count)}%`;
+/** Give a `Column` that states no width its equal share, keeping the primitive's attribute order. */
+const withColumnWidth = (node, width) => {
+	if (node.type === "Fragment") return EmailNode.Fragment({ children: node.children.map((child) => withColumnWidth(child, width)) });
+	if (node.type !== "Element" || node.tag !== "td" || node.props.width !== void 0) return node;
+	const props = {};
+	for (const [key, value] of Object.entries(node.props)) {
+		if (key === "style") props.width = width;
+		props[key] = value;
+	}
+	if (props.width === void 0) props.width = width;
+	return EmailNode.Element({
+		...node,
+		props
+	});
+};
+/**
+* A row of side-by-side `Column`s. No flex or grid conversion happens here. With `each` it repeats
+* its cells over a list, `per` to a row, and splits the row equally between cells that state no
+* width.
+*/
+const Columns = ({ className, align = "center", width = "100%", style, each, per, children }) => {
+	const table = {
+		className,
+		align,
+		width,
+		...style === void 0 ? {} : { style }
+	};
+	if (each === void 0 || typeof children !== "function") return presentation(table, children, { style: { width: "100%" } });
+	if (per !== void 0 && (!Number.isInteger(per) || per < 1)) reportEmailDiagnostic({
+		code: "invalid-columns-per",
+		severity: "error",
+		message: "<Columns per> must be a positive integer."
+	});
+	const size = per !== void 0 && Number.isInteger(per) && per >= 1 ? per : void 0;
+	const chunks = [];
+	if (size === void 0) chunks.push(each);
+	else for (let at = 0; at < each.length; at += size) chunks.push(each.slice(at, at + size));
+	const share = equalColumnWidth(size ?? Math.max(each.length, 1));
+	return jsx(Fragment, { children: chunks.map((chunk) => presentation(table, chunk.flatMap((item, index) => normalizeChildren(children(item, index)).map((cell) => withColumnWidth(cell, share))), { style: { width: "100%" } })) });
+};
 /** One cell of a `Columns` row. */
 const Column = ({ className, align, valign, width, style, children }) => jsx("td", {
 	className,
@@ -235,6 +270,6 @@ const Link = ({ className, href, target = "_blank", rel = "noopener noreferrer",
 	children
 });
 //#endregion
-export { Button, Column, Columns, Divider, Email, Image, Link, PREHEADER_ATTRIBUTE, Section, Spacer, preheaderNode };
+export { Button, Column, Columns, Divider, Email, Image, Link, PREHEADER_ATTRIBUTE, Section, Spacer, equalColumnWidth, preheaderNode };
 
 //# sourceMappingURL=components.js.map

package/dist/email/diagnostics.d.ts

@@ -1,2 +1,2 @@
-import { a as formatEmailDiagnostic, i as EmailDiagnosticSeverity, n as EmailCompileError, o as hasBlockingDiagnostic, r as EmailDiagnostic, t as EmailCompatibilityAssessment } from "../diagnostics-BMYtBCQk.js";
-export { EmailCompatibilityAssessment, EmailCompileError, EmailDiagnostic, EmailDiagnosticSeverity, formatEmailDiagnostic, hasBlockingDiagnostic };
+import { a as TemplateDiagnostic, i as EmailDiagnosticSeverity, n as EmailCompileError, o as formatEmailDiagnostic, r as EmailDiagnostic, s as hasBlockingDiagnostic, t as EmailCompatibilityAssessment } from "../diagnostics-B-Gym34R.js";
+export { EmailCompatibilityAssessment, EmailCompileError, EmailDiagnostic, EmailDiagnosticSeverity, TemplateDiagnostic, formatEmailDiagnostic, hasBlockingDiagnostic };

package/dist/email/diagnostics.js

@@ -11,7 +11,8 @@ var EmailCompileError = class extends TaggedError("EmailCompileError") {
 /** `emails/welcome.tsx:12:3 unsupported-element: …` — the shape agents iterate on. */
 const formatEmailDiagnostic = (diagnostic) => {
 	const origin = diagnostic.origins[0];
-	return `${origin === void 0 ? "<unknown source>" : `${origin.fileName}:${origin.lineNumber}:${origin.columnNumber}`} ${diagnostic.code}: ${diagnostic.message}`;
+	const head = `${origin === void 0 ? "<unknown source>" : `${origin.fileName}:${origin.lineNumber}:${origin.columnNumber}`} ${diagnostic.code}: ${diagnostic.message}`;
+	return diagnostic.fix === void 0 ? head : `${head}\n  Fix: ${diagnostic.fix}`;
 };
 /** True when a set of findings must stop the compile or refuse a publication. */
 const hasBlockingDiagnostic = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error");

package/dist/email/elements.d.ts

@@ -1,2 +1,2 @@
-import { a as EmailGlobalProps, c as EmailStyle, d as isUrlAttribute, i as EmailElementSpec, l as EmailTag, n as EMAIL_GLOBAL_ATTRIBUTES, o as EmailIntrinsicElements, r as EmailAttributeSpec, s as EmailLayout, t as EMAIL_ELEMENTS, u as emailElement } from "../elements-BzjjnoCS.js";
+import { a as EmailGlobalProps, c as EmailStyle, d as isUrlAttribute, i as EmailElementSpec, l as EmailTag, n as EMAIL_GLOBAL_ATTRIBUTES, o as EmailIntrinsicElements, r as EmailAttributeSpec, s as EmailLayout, t as EMAIL_ELEMENTS, u as emailElement } from "../elements-cqldpaJt.js";
 export { EMAIL_ELEMENTS, EMAIL_GLOBAL_ATTRIBUTES, EmailAttributeSpec, EmailElementSpec, EmailGlobalProps, EmailIntrinsicElements, EmailLayout, EmailStyle, EmailTag, emailElement, isUrlAttribute };

package/dist/email/html.d.ts

@@ -1,2 +1,2 @@
-import { a as escapeText, i as escapeAttribute, n as SerializeEmailOptions, o as kebab, r as declarationValue, s as serializeEmailHtml, t as EmailHtmlOutput } from "../html-Bl9BAdqc.js";
-export { EmailHtmlOutput, SerializeEmailOptions, declarationValue, escapeAttribute, escapeText, kebab, serializeEmailHtml };
+import { a as escapeAttribute, c as serializeEmailHtml, i as declarationValue, l as serializeStyle, n as SerializeEmailOptions, o as escapeText, r as checkAttribute, s as kebab, t as EmailHtmlOutput } from "../html-BJepOwZ4.js";
+export { EmailHtmlOutput, SerializeEmailOptions, checkAttribute, declarationValue, escapeAttribute, escapeText, kebab, serializeEmailHtml, serializeStyle };

package/dist/email/html.js

@@ -1,7 +1,7 @@
 import { n as isObject } from "../guards-eV1qLbf2.js";
 import { i as UNSUBSCRIBE_URL_PLACEHOLDER, n as RESERVED_FOOTER_ATTRIBUTES, r as UNSUBSCRIBE_LINK, t as BRAND_FOOTER_MARKER } from "../unsubscribe-link-CoesnQDU.js";
 import { EMAIL_ELEMENTS, EMAIL_GLOBAL_ATTRIBUTES, emailElement } from "./elements.js";
-import { INSTANCE_PATH_ATTRIBUTE } from "./selection.js";
+import { INSTANCE_PATH_ATTRIBUTE } from "../preview.js";
 //#region src/email/html.ts
 /** Escape a value for element content. */
 const escapeText = (value) => value.replace(/[&<>]/g, (character) => ({
@@ -272,7 +272,50 @@ const serializeEmailHtml = (node, options = {}) => {
 		positions: sink.positions
 	};
 };
+/** An authored style object as a declaration list, checked by the same rules as a serialized tree. */
+const serializeStyle = (style, origins) => {
+	const sink = {
+		diagnostics: [],
+		positions: [],
+		written: 0,
+		relativeUrls: false,
+		instancePaths: false
+	};
+	return {
+		css: declarations(sink, style, origins),
+		diagnostics: sink.diagnostics
+	};
+};
+/**
+* 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.
+*/
+const checkAttribute = (tag, name, value, origins) => {
+	const sink = {
+		diagnostics: [],
+		positions: [],
+		written: 0,
+		relativeUrls: false,
+		instancePaths: false
+	};
+	const element = emailElement(tag);
+	const globals = EMAIL_GLOBAL_ATTRIBUTES;
+	const attributeSpec = () => {
+		if (/^(data|aria)-[a-z0-9-]+$/.test(name)) return { type: "string" };
+		if (Object.hasOwn(globals, name)) return globals[name];
+		if (element !== void 0 && Object.hasOwn(element.attributes, name)) return element.attributes[name];
+	};
+	const spec = attributeSpec();
+	if (spec === void 0) return {
+		text: void 0,
+		diagnostics: sink.diagnostics
+	};
+	return {
+		text: attributeValue(sink, tag, name, spec, value, origins),
+		diagnostics: sink.diagnostics
+	};
+};
 //#endregion
-export { declarationValue, escapeAttribute, escapeText, kebab, serializeEmailHtml };
+export { checkAttribute, declarationValue, escapeAttribute, escapeText, kebab, serializeEmailHtml, serializeStyle };
 
 //# sourceMappingURL=html.js.map

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

@@ -1,5 +1,5 @@
-import { r as JsxSource } from "../source-locations-DrCM82Ym.js";
-import { g as JSX, h as Fragment, m as EmailNode, p as EmailComponent } from "../elements-BzjjnoCS.js";
+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";
 //#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-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-BzjjnoCS.js";
+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";
 export { EmailChild, EmailComponent, EmailNode, Fragment, JSX, currentEmailOrigins, drainEmailDiagnostics, jsx, jsxs, normalizeChildren, rawMarkup, reportEmailDiagnostic };

package/dist/email/render.d.ts

@@ -1,9 +1,9 @@
-import { r as EmailDiagnostic } from "../diagnostics-BMYtBCQk.js";
-import { m as EmailNode } from "../elements-BzjjnoCS.js";
-import { n as EmittedPosition } from "../selection-CCArx9lU.js";
-import { n as SerializeEmailOptions } from "../html-Bl9BAdqc.js";
-import { r as TemplateDefinition, t as EmailContent } from "../template-DWftqh4x.js";
-import { i as Stylesheet } from "../css-CS2jLID6.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";
+import { n as SerializeEmailOptions } from "../html-BJepOwZ4.js";
+import { n as EmailContent } from "../template-_QE_rQND.js";
+import { i as Stylesheet } from "../css-BVQKICKC.js";
 //#region src/email/render.d.ts
 /** Classic Outlook lays a document out correctly only under a transitional doctype. */
 declare const EMAIL_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
@@ -30,21 +30,11 @@ interface RenderedEmail {
   readonly diagnostics: readonly EmailDiagnostic[];
   readonly positions: readonly EmittedPosition[];
 }
-/** Render one validated input through the template's only content function. Host isolation is required for untrusted source. */
-declare const renderEmail: <Input>(template: TemplateDefinition<Input>, data: unknown, options?: SerializeEmailOptions) => RenderedEmail;
-/**
- * A render bound to the sheets registered so far. A compiled project's wrapper
- * calls this once its own stylesheet imports have run, so a later project
- * loaded into the same process cannot restyle an entry that is rendered again.
- */
-declare const bindStylesheets: (stylesheet?: Stylesheet | undefined) => typeof renderEmail;
 /**
  * Render authored content against a stylesheet: inline what a client honors,
- * keep the rest for `<head>`, and lower to HTML and text. `renderEmail` runs a
- * validated template through it; a host that composes content without a
- * template definition calls it directly.
+ * keep the rest for `<head>`, and lower to HTML and text.
  */
 declare const renderEmailContent: (stylesheet: Stylesheet | undefined, render: () => EmailContent, options?: SerializeEmailOptions) => RenderedEmail;
 //#endregion
-export { EMAIL_DOCTYPE, EmailCompileOutput, RenderedEmail, bindStylesheets, compileEmail, renderEmail, renderEmailContent };
+export { EMAIL_DOCTYPE, EmailCompileOutput, RenderedEmail, compileEmail, renderEmailContent };
 //# sourceMappingURL=render.d.ts.map

package/dist/email/render.js

@@ -1,3 +1,163 @@
-import { a as renderEmailContent, i as renderEmail, n as bindStylesheets, r as compileEmail, t as EMAIL_DOCTYPE } from "../render-vAv_4r9v.js";
-import "./diagnostics.js";
-export { EMAIL_DOCTYPE, bindStylesheets, compileEmail, renderEmail, renderEmailContent };
+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-Bl9BAdqc.d.ts → html-BJepOwZ4.d.ts}

@@ -1,6 +1,7 @@
-import { r as EmailDiagnostic } from "./diagnostics-BMYtBCQk.js";
-import { m as EmailNode } from "./elements-BzjjnoCS.js";
-import { n as EmittedPosition } from "./selection-CCArx9lU.js";
+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;
@@ -37,6 +38,19 @@ interface SerializeEmailOptions {
 }
 /** 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 { escapeText as a, escapeAttribute as i, SerializeEmailOptions as n, kebab as o, declarationValue as r, serializeEmailHtml as s, EmailHtmlOutput as t };
-//# sourceMappingURL=html-Bl9BAdqc.d.ts.map
+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 };