@samva/markup 0.8.0 → 0.9.0

package/dist/channel-edit.js

@@ -0,0 +1,609 @@
+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 { parse } from "@babel/parser";
+//#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) : [];
+const nodeOf = (parent, key) => {
+	const value = parent[key];
+	return isNode(value) ? value : null;
+};
+const parseSource = (source) => {
+	try {
+		const result = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+		return isNode(result) ? result : null;
+	} catch {
+		return null;
+	}
+};
+const walk = (value, visit) => {
+	if (Array.isArray(value)) {
+		for (const item of value) walk(item, visit);
+		return;
+	}
+	if (!isNode(value)) return;
+	if (visit(value) === false) return;
+	for (const [key, child] of Object.entries(value)) if (key !== "loc" && key !== "extra" && key !== "comments") walk(child, visit);
+};
+const jsxName = (name) => {
+	if (name === null) return "";
+	if (name.type === "JSXIdentifier") return typeof name.name === "string" ? name.name : "";
+	if (name.type === "JSXMemberExpression") return `${jsxName(nodeOf(name, "object"))}.${jsxName(nodeOf(name, "property"))}`;
+	return "";
+};
+const elementOf = (node) => {
+	if (node.type !== "JSXElement") return null;
+	const opening = nodeOf(node, "openingElement");
+	if (opening === null) return null;
+	const closing = nodeOf(node, "closingElement");
+	return {
+		node,
+		opening,
+		closing,
+		tag: jsxName(nodeOf(opening, "name")),
+		children: nodeList(node.children),
+		attributes: nodeList(opening.attributes),
+		selfClosing: opening.selfClosing === true,
+		contentStart: opening.end,
+		contentEnd: closing === null ? opening.end : closing.start
+	};
+};
+const returnedElement = (fn) => {
+	const body = nodeOf(fn, "body");
+	if (body === null) return null;
+	if (body.type === "JSXElement") return body;
+	if (body.type !== "BlockStatement") return null;
+	const statements = nodeList(body.body).filter((statement) => statement.type !== "EmptyStatement");
+	const only = statements.length === 1 ? statements[0] : void 0;
+	const argument = only?.type === "ReturnStatement" && only !== void 0 ? nodeOf(only, "argument") : null;
+	return argument !== null && argument.type === "JSXElement" ? argument : null;
+};
+const propertyName = (property) => {
+	if (property.computed === true) return null;
+	const key = nodeOf(property, "key");
+	if (key === null) return null;
+	if (key.type === "Identifier") return typeof key.name === "string" ? key.name : null;
+	return key.type === "StringLiteral" && typeof key.value === "string" ? key.value : null;
+};
+/** The function behind `defineTemplate({ [channel]: … })`, when it is written in place. */
+const channelFunction = (tree, channel) => {
+	let found = null;
+	walk(tree, (call) => {
+		if (found !== null) return false;
+		if (call.type !== "CallExpression") return;
+		const callee = nodeOf(call, "callee");
+		if (callee?.type !== "Identifier" || callee.name !== "defineTemplate") return;
+		const definition = nodeList(call.arguments)[0];
+		if (definition?.type !== "ObjectExpression") return false;
+		for (const property of nodeList(definition.properties)) {
+			if (propertyName(property) !== channel) continue;
+			const fn = property.type === "ObjectMethod" ? property : property.type === "ObjectProperty" ? nodeOf(property, "value") : null;
+			if (fn === null || fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression" && fn.type !== "ObjectMethod") return false;
+			const returned = returnedElement(fn);
+			const root = returned === null ? null : elementOf(returned);
+			if (root !== null) found = {
+				root,
+				parameter: nodeList(fn.params)[0] ?? null
+			};
+			return false;
+		}
+		return false;
+	});
+	return found;
+};
+/** The name an import binds a component to, or the component's own name when nothing is imported. */
+const importedAs = (tree, specifier, imported) => {
+	let local = imported;
+	walk(tree, (node) => {
+		if (node.type !== "ImportDeclaration") return;
+		if (nodeOf(node, "source")?.value !== specifier) return false;
+		for (const item of nodeList(node.specifiers)) {
+			const name = nodeOf(item, "imported");
+			const alias = nodeOf(item, "local");
+			if (item.type === "ImportSpecifier" && (name?.name === imported || name?.value === imported)) local = typeof alias?.name === "string" ? alias.name : imported;
+		}
+		return false;
+	});
+	return local;
+};
+/** JSX text as the compiler reads it: lines are trimmed and joined, blank lines dropped. */
+const jsxTextValue = (value) => {
+	const lines = value.split(/\r\n|\n|\r/);
+	let lastNonEmpty = 0;
+	lines.forEach((line, index) => {
+		if (/[^ \t]/.test(line)) lastNonEmpty = index;
+	});
+	let result = "";
+	lines.forEach((line, index) => {
+		let trimmed = line.replace(/\t/g, " ");
+		if (index !== 0) trimmed = trimmed.replace(/^ +/, "");
+		if (index !== lines.length - 1) trimmed = trimmed.replace(/ +$/, "");
+		if (trimmed === "") return;
+		result += index === lastNonEmpty ? trimmed : `${trimmed} `;
+	});
+	return result;
+};
+/** The value of a container that holds only a string, or null for any other expression. */
+const stringContainerValue = (container) => {
+	const expression = nodeOf(container, "expression");
+	if (expression === null) return null;
+	if (expression.type === "StringLiteral" && typeof expression.value === "string") return expression.value;
+	if (expression.type === "TemplateLiteral" && nodeList(expression.expressions).length === 0) {
+		const cooked = nodeList(expression.quasis)[0]?.value;
+		return isObject(cooked) && typeof cooked.cooked === "string" ? cooked.cooked : null;
+	}
+	return null;
+};
+const summarize = (source, node) => {
+	const text = source.slice(node.start, node.end).replace(/\s+/g, " ").trim();
+	return text.length > 60 ? `${text.slice(0, 59)}…` : text;
+};
+/**
+* The editable text and locked expressions of an element's children, in order. Text is a segment
+* between locked children, so a text segment exists (possibly empty) before, between and after
+* them.
+*/
+const segmentsOf = (source, element) => {
+	const segments = [];
+	let start = element.contentStart;
+	let text = "";
+	const flush = (end) => {
+		segments.push({
+			kind: "text",
+			text,
+			start,
+			end
+		});
+		text = "";
+	};
+	for (const child of element.children) {
+		if (child.type === "JSXText") {
+			text += jsxTextValue(typeof child.value === "string" ? child.value : "");
+			continue;
+		}
+		if (child.type === "JSXExpressionContainer") {
+			const value = stringContainerValue(child);
+			if (value !== null) {
+				text += value;
+				continue;
+			}
+		}
+		flush(child.start);
+		segments.push({
+			kind: "locked",
+			summary: summarize(source, child),
+			start: child.start,
+			end: child.end
+		});
+		start = child.end;
+	}
+	flush(element.contentEnd);
+	return segments;
+};
+const isSafeRun = (char) => !/[{}<>&\r\n\t]/.test(char);
+/**
+* JSX for the given text. Characters JSX text cannot carry, and whitespace at an edge the
+* compiler would trim, are written as string expressions; the rest stays plain text.
+*/
+const encodeText = (text, trimStart, trimEnd) => {
+	const chars = [...text];
+	const unsafe = chars.map((char) => !isSafeRun(char));
+	if (trimStart) for (let i = 0; i < chars.length && /\s/.test(chars[i]); i++) unsafe[i] = true;
+	if (trimEnd) for (let i = chars.length - 1; i >= 0 && /\s/.test(chars[i]); i--) unsafe[i] = true;
+	let result = "";
+	let run = "";
+	let runUnsafe = false;
+	const flush = () => {
+		if (run === "") return;
+		result += runUnsafe ? `{${JSON.stringify(run)}}` : run;
+		run = "";
+	};
+	chars.forEach((char, index) => {
+		if (run !== "" && unsafe[index] !== runUnsafe) flush();
+		runUnsafe = unsafe[index];
+		run += char;
+	});
+	flush();
+	return result;
+};
+/** Write `text` over the gap at `segment`, keeping the newlines and indentation around it. */
+const writeText = (source, element, segments, index, text) => {
+	const segment = segments[index];
+	if (segment?.kind !== "text") return {
+		ok: false,
+		reason: "That part of the body is locked."
+	};
+	if (segment.text === text) return {
+		ok: true,
+		edits: []
+	};
+	if (element.selfClosing) {
+		const opening = element.opening;
+		let start = opening.end - 2;
+		while (start > opening.start && /\s/.test(source[start - 1])) start--;
+		return {
+			ok: true,
+			edits: [{
+				start,
+				end: opening.end,
+				before: source.slice(start, opening.end),
+				after: `>${encodeText(text, false, false)}</${element.tag}>`
+			}]
+		};
+	}
+	const raw = source.slice(segment.start, segment.end);
+	const leading = /^\s*/.exec(raw)?.[0] ?? "";
+	const prefix = /[\r\n]/.test(leading) ? leading : "";
+	const rest = raw.slice(prefix.length);
+	const trailing = /\s*$/.exec(rest)?.[0] ?? "";
+	const suffix = /[\r\n]/.test(trailing) ? trailing : "";
+	const start = segment.start + prefix.length;
+	const end = segment.end - suffix.length;
+	return {
+		ok: true,
+		edits: [{
+			start,
+			end,
+			before: source.slice(start, end),
+			after: encodeText(text, prefix !== "", suffix !== "")
+		}]
+	};
+};
+const attributeNamed = (element, name) => element.attributes.find((attribute) => attribute.type === "JSXAttribute" && jsxName(nodeOf(attribute, "name")) === name) ?? null;
+const attributeState = (source, element, name) => {
+	const attribute = attributeNamed(element, name);
+	if (attribute === null) return { kind: "absent" };
+	const value = nodeOf(attribute, "value");
+	if (value?.type === "StringLiteral" && typeof value.value === "string") return {
+		kind: "literal",
+		value: value.value
+	};
+	if (value?.type === "JSXExpressionContainer") {
+		const literal = stringContainerValue(value);
+		if (literal !== null) return {
+			kind: "literal",
+			value: literal
+		};
+	}
+	return {
+		kind: "expression",
+		source: summarize(source, value ?? attribute)
+	};
+};
+const encodeAttribute = (value) => /["&\\\r\n]/.test(value) ? `{${JSON.stringify(value)}}` : `"${value}"`;
+const replacement = (source, start, end, after) => ({
+	start,
+	end,
+	before: source.slice(start, end),
+	after
+});
+/** Set, add or remove one string attribute of an element. */
+const setAttribute = (source, element, name, value) => {
+	const attribute = attributeNamed(element, name);
+	if (attribute === null) {
+		if (value === void 0) return {
+			ok: true,
+			edits: []
+		};
+		const anchor = element.attributes.at(-1)?.end ?? nodeOf(element.opening, "name")?.end ?? element.opening.end;
+		return {
+			ok: true,
+			edits: [replacement(source, anchor, anchor, ` ${name}=${encodeAttribute(value)}`)]
+		};
+	}
+	if (attributeState(source, element, name).kind === "expression") return {
+		ok: false,
+		reason: `\`${name}\` reads the input. Edit it in Source.`
+	};
+	if (value === void 0) {
+		let start = attribute.start;
+		while (start > element.opening.start && /\s/.test(source[start - 1])) start--;
+		return {
+			ok: true,
+			edits: [replacement(source, start, attribute.end, "")]
+		};
+	}
+	const literal = nodeOf(attribute, "value");
+	return {
+		ok: true,
+		edits: literal === null ? [replacement(source, attribute.end, attribute.end, `=${encodeAttribute(value)}`)] : [replacement(source, literal.start, literal.end, encodeAttribute(value))]
+	};
+};
+const INDENT = "  ";
+/** The indentation of the line `position` is on, when only whitespace precedes it there. */
+const ownLineIndent = (source, position) => {
+	const lineStart = source.lastIndexOf("\n", position - 1) + 1;
+	const lead = source.slice(lineStart, position);
+	return /^[ \t]*$/.test(lead) ? lead : null;
+};
+/** Remove a child, and its line when it is alone on one. */
+const removeChild = (source, node) => {
+	const indent = ownLineIndent(source, node.start);
+	const after = /^[ \t]*(\r?\n)/.exec(source.slice(node.end));
+	if (indent === null || after === null) return replacement(source, node.start, node.end, "");
+	const start = node.start - indent.length;
+	return replacement(source, start, node.end + after[0].length, "");
+};
+/** Insert markup on its own line before or after a sibling, or inline when the sibling is not alone. */
+const insertBeside = (source, sibling, side, text) => {
+	const indent = ownLineIndent(source, sibling.start);
+	if (side === "before") return replacement(source, sibling.start, sibling.start, indent === null ? text : `${text}\n${indent}`);
+	return replacement(source, sibling.end, sibling.end, indent === null ? text : `\n${indent}${text}`);
+};
+/** The input fields read by the expressions inside `root`, as dotted paths. */
+const variablesOf = (source, root, parameter) => {
+	const names = /* @__PURE__ */ new Set();
+	const scan = (text) => {
+		if (parameter?.type === "Identifier" && typeof parameter.name === "string") {
+			const pattern = new RegExp(`\\b${parameter.name}((?:\\??\\.[A-Za-z_$][\\w$]*)+)`, "g");
+			for (const match of text.matchAll(pattern)) names.add(match[1].replace(/\?/g, "").slice(1));
+		} else if (parameter?.type === "ObjectPattern") for (const property of nodeList(parameter.properties)) {
+			const key = nodeOf(property, "key");
+			if (key?.type === "Identifier" && typeof key.name === "string") {
+				if (new RegExp(`\\b${key.name}\\b`).test(text)) names.add(key.name);
+			}
+		}
+	};
+	walk(root.node, (node) => {
+		if (node.type === "JSXExpressionContainer" && stringContainerValue(node) === null) scan(source.slice(node.start, node.end));
+	});
+	return [...names].sort();
+};
+const smsChannel = (source) => {
+	const tree = parseSource(source);
+	if (tree === null) return null;
+	const channel = channelFunction(tree, "sms");
+	if (channel === null || channel.root.tag !== importedAs(tree, "@samva/markup/sms", "Sms")) return null;
+	return {
+		...channel,
+		tree
+	};
+};
+/** The form model of the template's SMS body, or null when it is not a `<Sms>` written in place. */
+const readSmsChannel = (source) => {
+	const channel = smsChannel(source);
+	if (channel === null) return null;
+	return {
+		category: attributeState(source, channel.root, "category"),
+		segments: segmentsOf(source, channel.root),
+		variables: variablesOf(source, channel.root, channel.parameter)
+	};
+};
+/** The source replacements that apply one form change to the SMS body. */
+const editSmsChannel = (source, edit) => {
+	const channel = smsChannel(source);
+	if (channel === null) return {
+		ok: false,
+		reason: "The SMS body is not editable here."
+	};
+	if (edit.kind === "category") {
+		if (edit.value !== void 0 && !SMS_CATEGORIES.includes(edit.value)) return {
+			ok: false,
+			reason: `\`${edit.value}\` is not an SMS category.`
+		};
+		return setAttribute(source, channel.root, "category", edit.value);
+	}
+	return writeText(source, channel.root, segmentsOf(source, channel.root), edit.segment, edit.text);
+};
+const BUTTON_TAGS = {
+	"quick-reply": "QuickReplyButton",
+	url: "UrlButton",
+	phone: "PhoneButton",
+	"copy-code": "CopyCodeButton"
+};
+const BUTTON_DEFAULTS = {
+	"quick-reply": "Reply",
+	url: "Visit site",
+	phone: "Call us",
+	"copy-code": "CODE"
+};
+const kindOfTag = (tag, local) => {
+	if (!tag.startsWith(`${local}.`)) return null;
+	const part = tag.slice(local.length + 1);
+	return Object.keys(BUTTON_TAGS).find((kind) => BUTTON_TAGS[kind] === part) ?? null;
+};
+const whatsappChannel = (source) => {
+	const tree = parseSource(source);
+	if (tree === null) return null;
+	const channel = channelFunction(tree, "whatsapp");
+	const local = importedAs(tree, "@samva/markup/whatsapp", "WhatsApp");
+	if (channel === null || channel.root.tag !== local) return null;
+	const part = (name) => {
+		for (const child of channel.root.children) {
+			const element = elementOf(child);
+			if (element?.tag === `${local}.${name}`) return element;
+		}
+		return null;
+	};
+	return {
+		...channel,
+		local,
+		header: part("Header"),
+		body: part("Body"),
+		footer: part("Footer"),
+		buttons: part("Buttons")
+	};
+};
+const buttonRows = (source, channel) => {
+	if (channel.buttons === null) return [];
+	const rows = [];
+	for (const child of channel.buttons.children) {
+		if (child.type === "JSXText" && jsxTextValue(String(child.value ?? "")) === "") continue;
+		const element = elementOf(child);
+		const kind = element === null ? null : kindOfTag(element.tag, channel.local);
+		if (element === null || kind === null) {
+			rows.push({
+				row: {
+					kind: "locked",
+					summary: summarize(source, child)
+				},
+				node: child
+			});
+			continue;
+		}
+		const segments = segmentsOf(source, element);
+		const label = segments[0];
+		rows.push({
+			node: child,
+			row: segments.length === 1 && label?.kind === "text" ? {
+				kind: "editable",
+				type: kind,
+				text: label.text,
+				url: attributeState(source, element, "url"),
+				phone: attributeState(source, element, "phone")
+			} : {
+				kind: "locked",
+				summary: summarize(source, child)
+			}
+		});
+	}
+	return rows;
+};
+/** The form model of the template's WhatsApp body, or null when it is not a `<WhatsApp>` written in place. */
+const readWhatsAppChannel = (source) => {
+	const channel = whatsappChannel(source);
+	if (channel === null || channel.body === null) return null;
+	const { root } = channel;
+	return {
+		name: attributeState(source, root, "name"),
+		language: attributeState(source, root, "language"),
+		category: attributeState(source, root, "category"),
+		header: channel.header === null ? null : segmentsOf(source, channel.header),
+		headerType: channel.header === null ? { kind: "absent" } : attributeState(source, channel.header, "type"),
+		body: segmentsOf(source, channel.body),
+		footer: channel.footer === null ? null : segmentsOf(source, channel.footer),
+		buttons: buttonRows(source, channel).map(({ row }) => row),
+		variables: variablesOf(source, root, channel.parameter)
+	};
+};
+const buttonMarkup = (local, type, text, attributes) => {
+	const tag = `${local}.${BUTTON_TAGS[type]}`;
+	return `<${tag}${type === "url" && attributes.url !== void 0 ? ` url=${encodeAttribute(attributes.url)}` : type === "phone" && attributes.phone !== void 0 ? ` phone=${encodeAttribute(attributes.phone)}` : ""}>${encodeText(text, false, false)}</${tag}>`;
+};
+const newButton = (local, type) => buttonMarkup(local, type, BUTTON_DEFAULTS[type], {
+	url: "https://example.com",
+	phone: "+15555550100"
+});
+const editPart = (source, channel, part, index, text) => {
+	const element = channel[part];
+	if (element === null) {
+		if (part === "body" || text === "" || index !== 0) return {
+			ok: true,
+			edits: []
+		};
+		const tag = `${channel.local}.${part === "header" ? "Header" : "Footer"}`;
+		const markup = `<${tag}>${encodeText(text, false, false)}</${tag}>`;
+		const anchor = part === "header" ? channel.body.node : channel.buttons?.node ?? channel.body.node;
+		return {
+			ok: true,
+			edits: [insertBeside(source, anchor, part === "header" ? "before" : "after", markup)]
+		};
+	}
+	const segments = segmentsOf(source, element);
+	if (part !== "body" && text === "" && segments.length === 1) return {
+		ok: true,
+		edits: [removeChild(source, element.node)]
+	};
+	return writeText(source, element, segments, index, text);
+};
+/** The source replacements that apply one form change to the WhatsApp body. */
+const editWhatsAppChannel = (source, edit) => {
+	const channel = whatsappChannel(source);
+	if (channel === null || channel.body === null) return {
+		ok: false,
+		reason: "The WhatsApp body is not editable here."
+	};
+	const { root, local } = channel;
+	switch (edit.kind) {
+		case "attribute": {
+			if (edit.name === "category" && !WHATSAPP_CATEGORIES.includes(edit.value ?? "")) return {
+				ok: false,
+				reason: "Choose a WhatsApp category."
+			};
+			const value = edit.name === "name" && edit.value === "" ? void 0 : edit.value ?? "";
+			return setAttribute(source, root, edit.name, value);
+		}
+		case "headerType":
+			if (channel.header === null) return {
+				ok: false,
+				reason: "Add the header text before choosing its type."
+			};
+			if (!WHATSAPP_HEADER_TYPES.includes(edit.value)) return {
+				ok: false,
+				reason: `\`${edit.value}\` is not a header type.`
+			};
+			return setAttribute(source, channel.header, "type", edit.value === "text" ? void 0 : edit.value);
+		case "text": return editPart(source, channel, edit.part, edit.segment, edit.text);
+		case "buttonAdd": {
+			const button = newButton(local, edit.type);
+			const buttons = channel.buttons;
+			if (buttons === null) {
+				const anchor = channel.footer ?? channel.body;
+				const tag = `${local}.Buttons`;
+				const indent = ownLineIndent(source, anchor.node.start);
+				const markup = indent === null ? `<${tag}>${button}</${tag}>` : `<${tag}>\n${indent}${INDENT}${button}\n${indent}</${tag}>`;
+				return {
+					ok: true,
+					edits: [insertBeside(source, anchor.node, "after", markup)]
+				};
+			}
+			if (buttons.selfClosing) {
+				const tag = `${local}.Buttons`;
+				const indent = ownLineIndent(source, buttons.node.start);
+				const markup = indent === null ? `<${tag}>${button}</${tag}>` : `<${tag}>\n${indent}${INDENT}${button}\n${indent}</${tag}>`;
+				return {
+					ok: true,
+					edits: [replacement(source, buttons.node.start, buttons.node.end, markup)]
+				};
+			}
+			const last = buttons.children.findLast((child) => child.type !== "JSXText" || jsxTextValue(String(child.value ?? "")) !== "");
+			if (last !== void 0) return {
+				ok: true,
+				edits: [insertBeside(source, last, "after", button)]
+			};
+			const indent = ownLineIndent(source, buttons.node.start);
+			return {
+				ok: true,
+				edits: [replacement(source, buttons.contentStart, buttons.contentEnd, indent === null ? button : `\n${indent}${INDENT}${button}\n${indent}`)]
+			};
+		}
+	}
+	const rows = buttonRows(source, channel);
+	const target = rows[edit.button];
+	if (target === void 0 || channel.buttons === null) return {
+		ok: false,
+		reason: "That button no longer exists."
+	};
+	if (edit.kind === "buttonRemove") return {
+		ok: true,
+		edits: [removeChild(source, rows.length === 1 ? channel.buttons.node : target.node)]
+	};
+	const element = elementOf(target.node);
+	if (target.row.kind === "locked" || element === null) return {
+		ok: false,
+		reason: "That button is locked. Edit it in Source."
+	};
+	switch (edit.kind) {
+		case "buttonText": return writeText(source, element, segmentsOf(source, element), 0, edit.text);
+		case "buttonAttribute": return setAttribute(source, element, edit.name, edit.value);
+		default: {
+			const { row } = target;
+			const keep = (state) => state.kind === "literal" ? state.value : void 0;
+			const markup = buttonMarkup(local, edit.type, row.text, {
+				url: keep(row.url) ?? "https://example.com",
+				phone: keep(row.phone) ?? "+15555550100"
+			});
+			return {
+				ok: true,
+				edits: [replacement(source, target.node.start, target.node.end, markup)]
+			};
+		}
+	}
+};
+//#endregion
+export { editSmsChannel, editWhatsAppChannel, readSmsChannel, readWhatsAppChannel };
+
+//# sourceMappingURL=channel-edit.js.map

package/dist/channel-specs-B6M_HlaV.js

@@ -0,0 +1,29 @@
+//#region src/channel-specs.ts
+const SMS_CATEGORIES = [
+	"transactional",
+	"promotional",
+	"service_implicit"
+];
+const WHATSAPP_CATEGORIES = [
+	"marketing",
+	"utility",
+	"authentication"
+];
+const WHATSAPP_HEADER_TYPES = [
+	"text",
+	"image",
+	"video",
+	"document"
+];
+/** The attributes `<Sms>` accepts. */
+const SMS_ATTRIBUTES = ["category"];
+/** The attributes `<WhatsApp>` accepts. */
+const WHATSAPP_ATTRIBUTES = [
+	"name",
+	"language",
+	"category"
+];
+//#endregion
+export { WHATSAPP_HEADER_TYPES as a, WHATSAPP_CATEGORIES as i, SMS_CATEGORIES as n, WHATSAPP_ATTRIBUTES as r, SMS_ATTRIBUTES as t };
+
+//# sourceMappingURL=channel-specs-B6M_HlaV.js.map

package/dist/channel-specs-C2feJwuP.d.ts

@@ -0,0 +1,13 @@
+//#region src/channel-specs.d.ts
+declare const SMS_CATEGORIES: readonly ["transactional", "promotional", "service_implicit"];
+declare const WHATSAPP_CATEGORIES: readonly ["marketing", "utility", "authentication"];
+declare const WHATSAPP_HEADER_TYPES: readonly ["text", "image", "video", "document"];
+/** The SMS categories `<Sms category>` accepts. */
+type SmsCategory = (typeof SMS_CATEGORIES)[number];
+/** The Meta template categories `<WhatsApp category>` accepts. */
+type WhatsAppCategory = (typeof WHATSAPP_CATEGORIES)[number];
+/** The header kinds `<WhatsApp.Header type>` accepts. */
+type WhatsAppHeaderType = (typeof WHATSAPP_HEADER_TYPES)[number];
+//#endregion
+export { WhatsAppCategory as n, WhatsAppHeaderType as r, SmsCategory as t };
+//# sourceMappingURL=channel-specs-C2feJwuP.d.ts.map