@localess/richtext 3.4.1 → 4.0.0-dev.20260905083404

package/dist/index.mjs

@@ -1,86 +1,136 @@
 //#region src/escape.ts
-var e = {
+var TEXT_ESCAPES = {
 	"&": "&",
 	"<": "&lt;",
 	">": "&gt;"
-}, t = {
-	...e,
+};
+var ATTR_ESCAPES = {
+	...TEXT_ESCAPES,
 	"\"": "&quot;"
 };
-function n(t) {
-	return t.replace(/[&<>]/g, (t) => e[t]);
+/**
+* Escapes text content for safe HTML output. The escape set (`& < >`) matches
+* TipTap's `generateHTML` DOM serialization — parity-tested; do not widen it
+* without updating the parity fixtures.
+*/
+function escapeHtml(text) {
+	return text.replace(/[&<>]/g, (ch) => TEXT_ESCAPES[ch]);
 }
-function r(e) {
-	return e.replace(/[&"<>]/g, (e) => t[e]);
+/** Escapes an attribute value for safe double-quoted HTML output (`& " < >`). */
+function escapeAttr(value) {
+	return value.replace(/[&"<>]/g, (ch) => ATTR_ESCAPES[ch]);
 }
-var i = /^(?:https?:|mailto:|tel:)/i, a = /^[a-z][a-z0-9+.-]*:/i;
-function o(e) {
-	let t = e.trim();
-	return t === "" ? "" : i.test(t) || !a.test(t) ? t : "";
+var SAFE_SCHEME = /^(?:https?:|mailto:|tel:)/i;
+var HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+/**
+* Allowlist URL sanitizer for link hrefs: `http:`, `https:`, `mailto:`, `tel:`
+* and scheme-less (relative/protocol-relative/fragment/query) URLs pass;
+* everything else (e.g. `javascript:`, `data:`) becomes `''`.
+*/
+function sanitizeUrl(url) {
+	const trimmed = url.trim();
+	if (trimmed === "") return "";
+	if (SAFE_SCHEME.test(trimmed)) return trimmed;
+	if (!HAS_SCHEME.test(trimmed)) return trimmed;
+	return "";
 }
 //#endregion
 //#region src/attrs.ts
-function s(e, t, n = {}) {
-	let r = {}, i = (e) => n.attrMap?.[e] ?? e, a = (e, t) => {
-		t != null && t !== "" && (r[i(e)] = t);
+/**
+* Normalizes a node/mark's stored attrs into the attributes to emit, in the
+* order TipTap's `generateHTML` emits them (parity-tested — adjust order here
+* and in the fixtures together if the parity test disagrees).
+*/
+function processAttrs(type, attrs, options = {}) {
+	const out = {};
+	const name = (key) => options.attrMap?.[key] ?? key;
+	const put = (key, value) => {
+		if (value === null || value === void 0 || value === "") return;
+		out[name(key)] = value;
 	};
-	if (!t) return r;
-	switch (e) {
+	if (!attrs) return out;
+	switch (type) {
 		case "orderedList":
-			t.start !== null && t.start !== void 0 && t.start !== 1 && a("start", t.start);
+			if (attrs.start !== null && attrs.start !== void 0 && attrs.start !== 1) put("start", attrs.start);
 			break;
 		case "codeBlock":
-			t.language && a("class", `language-${t.language}`);
+			if (attrs.language) put("class", `language-${attrs.language}`);
 			break;
-		case "link": a("target", t.target), a("rel", t.rel), r[i("href")] = o(String(t.href ?? "")), a("class", t.class);
+		case "link":
+			put("target", attrs.target);
+			put("rel", attrs.rel);
+			out[name("href")] = sanitizeUrl(String(attrs.href ?? ""));
+			put("class", attrs.class);
 	}
-	return r;
+	return out;
 }
 //#endregion
 //#region src/marks.ts
-function c(e, t) {
-	return e.type === t.type && JSON.stringify(e.attrs ?? {}) === JSON.stringify(t.attrs ?? {});
+/** Deep equality of two marks (type + attrs). Attr key order must match, which holds for editor-produced documents. */
+function marksEqual(a, b) {
+	return a.type === b.type && JSON.stringify(a.attrs ?? {}) === JSON.stringify(b.attrs ?? {});
 }
-function l(e) {
-	let t = [], n = [];
-	for (let r of e) {
-		let e = r.marks ?? [], i = 0;
-		for (; i < n.length && i < e.length && c(n[i].mark, e[i]);) i++;
-		n.length = i;
-		for (let r = i; r < e.length; r++) {
-			let i = {
+/**
+* Folds a run of consecutive text nodes into a tree in which adjacent nodes
+* sharing the same outer marks share one wrapper — the same merging
+* ProseMirror's DOM serializer performs, so output matches TipTap's
+* `generateHTML` (one `<a>` per link span, `<strong>a<em>b</em></strong>`
+* instead of sibling `<strong>` wrappers).
+*/
+function buildMarkTree(nodes) {
+	const root = [];
+	const stack = [];
+	for (const node of nodes) {
+		const marks = node.marks ?? [];
+		let depth = 0;
+		while (depth < stack.length && depth < marks.length && marksEqual(stack[depth].mark, marks[depth])) depth++;
+		stack.length = depth;
+		for (let i = depth; i < marks.length; i++) {
+			const segment = {
 				kind: "mark",
-				mark: e[r],
+				mark: marks[i],
 				children: []
 			};
-			(n.length > 0 ? n[n.length - 1].children : t).push(i), n.push(i);
+			(stack.length > 0 ? stack[stack.length - 1].children : root).push(segment);
+			stack.push(segment);
 		}
-		(n.length > 0 ? n[n.length - 1].children : t).push({
+		(stack.length > 0 ? stack[stack.length - 1].children : root).push({
 			kind: "text",
-			text: r.text
+			text: node.text
 		});
 	}
-	return t;
+	return root;
 }
 //#endregion
 //#region src/normalize.ts
-function u(e, t = {}) {
-	let n;
-	return n = e ? Array.isArray(e) ? e : e.type === "doc" ? e.content ?? [] : typeof e.type == "string" ? [e] : [] : [], t.withKeys ? d(n, {}) : n;
+/**
+* Flattens any accepted rich text input (document, node, node array, or the
+* loose `ContentRichText` shape from `@localess/model`) into a node list.
+* Never throws; malformed input yields `[]`.
+*/
+function normalizeInput(input, options = {}) {
+	let nodes;
+	if (!input) nodes = [];
+	else if (Array.isArray(input)) nodes = input;
+	else if (input.type === "doc") nodes = input.content ?? [];
+	else if (typeof input.type === "string") nodes = [input];
+	else nodes = [];
+	return options.withKeys ? addKeys(nodes, {}) : nodes;
 }
-function d(e, t) {
-	return e.map((e) => {
-		t[e.type] = (t[e.type] ?? 0) + 1;
-		let n = {
-			...e,
-			_key: `${e.type}-${t[e.type]}`
+function addKeys(nodes, counters) {
+	return nodes.map((node) => {
+		counters[node.type] = (counters[node.type] ?? 0) + 1;
+		const keyed = {
+			...node,
+			_key: `${node.type}-${counters[node.type]}`
 		};
-		return Array.isArray(n.content) && (n.content = d(n.content, t)), n;
+		if (Array.isArray(keyed.content)) keyed.content = addKeys(keyed.content, counters);
+		return keyed;
 	});
 }
 //#endregion
 //#region src/render-map.ts
-var f = [
+var HEADING_LEVELS = [
 	1,
 	2,
 	3,
@@ -88,149 +138,175 @@ var f = [
 	5,
 	6
 ];
-function p(e) {
-	let t = e?.level;
-	return `h${f.includes(t) ? t : 1}`;
+/** Invalid levels fall back to h1, matching TipTap's first-configured-level behavior. */
+function resolveHeadingTag(attrs) {
+	const level = attrs?.level;
+	return `h${HEADING_LEVELS.includes(level) ? level : 1}`;
 }
-var m = {
+/** `null` = transparent (render children only, no element). Missing key = unknown type. */
+var NODE_RENDER_MAP = {
 	doc: null,
 	text: null,
 	paragraph: {
 		tag: "p",
-		content: !0
+		content: true
 	},
 	heading: {
-		resolve: p,
-		content: !0
+		resolve: resolveHeadingTag,
+		content: true
 	},
 	bulletList: {
 		tag: "ul",
-		content: !0
+		content: true
 	},
 	orderedList: {
 		tag: "ol",
-		content: !0
+		content: true
 	},
 	listItem: {
 		tag: "li",
-		content: !0
+		content: true
 	},
 	codeBlock: {
 		tag: "pre",
 		children: [{
 			tag: "code",
-			content: !0
+			content: true
 		}]
 	}
-}, h = {
+};
+var MARK_RENDER_MAP = {
 	bold: {
 		tag: "strong",
-		content: !0
+		content: true
 	},
 	italic: {
 		tag: "em",
-		content: !0
+		content: true
 	},
 	strike: {
 		tag: "s",
-		content: !0
+		content: true
 	},
 	underline: {
 		tag: "u",
-		content: !0
+		content: true
 	},
 	code: {
 		tag: "code",
-		content: !0
+		content: true
 	},
 	link: {
 		tag: "a",
-		content: !0
+		content: true
 	}
 };
 //#endregion
 //#region src/render-html.ts
-function g(e, t = {}) {
-	return _(u(e), {
-		renderers: t.renderers,
+/**
+* Renders Localess rich text JSON to an HTML string. Framework-neutral,
+* dependency-free, and byte-compatible with TipTap's `generateHTML` for the
+* node set the Localess Studio editor produces.
+*/
+function renderRichTextToHtml(input, options = {}) {
+	return renderNodes(normalizeInput(input), {
+		renderers: options.renderers,
 		warned: /* @__PURE__ */ new Set()
 	});
 }
-function _(e, t) {
-	let n = "", r = 0;
-	for (; r < e.length;) {
-		let i = e[r];
-		if (i.type === "text" && !t.renderers?.text) {
-			let i = [];
-			for (; r < e.length && e[r].type === "text";) i.push(e[r]), r++;
-			n += y(l(i), t);
-		} else n += v(i, t), r++;
+function renderNodes(nodes, ctx) {
+	let result = "";
+	let i = 0;
+	while (i < nodes.length) {
+		const node = nodes[i];
+		if (node.type === "text" && !ctx.renderers?.text) {
+			const run = [];
+			while (i < nodes.length && nodes[i].type === "text") {
+				run.push(nodes[i]);
+				i++;
+			}
+			result += renderSegments(buildMarkTree(run), ctx);
+		} else {
+			result += renderNode(node, ctx);
+			i++;
+		}
 	}
-	return n;
+	return result;
 }
-function v(e, t) {
-	let r = t.renderers?.[e.type];
-	if (r) {
-		let i = {
-			...t.renderers,
-			[e.type]: void 0
-		}, a = {
-			renderers: i,
-			warned: t.warned
-		}, o = e.type === "text" ? n(e.text ?? "") : _(e.content ?? [], a);
-		return r({
-			...e,
-			children: o,
-			context: { renderers: i }
+function renderNode(node, ctx) {
+	const custom = ctx.renderers?.[node.type];
+	if (custom) {
+		const childRenderers = {
+			...ctx.renderers,
+			[node.type]: void 0
+		};
+		const childCtx = {
+			renderers: childRenderers,
+			warned: ctx.warned
+		};
+		const children = node.type === "text" ? escapeHtml(node.text ?? "") : renderNodes(node.content ?? [], childCtx);
+		return custom({
+			...node,
+			children,
+			context: { renderers: childRenderers }
 		});
 	}
-	if (e.type === "text") return y(l([e]), t);
-	let i = m[e.type];
-	if (i === void 0) return x(t, e.type), "";
-	if (i === null) return _(e.content ?? [], t);
-	let a = s(e.type, e.attrs), o = _(e.content ?? [], t);
-	if (i.children) {
-		let e = o;
-		for (let t = i.children.length - 1; t >= 0; t--) {
-			let n = i.children[t];
-			e = b(n.tag, n.content ? a : {}, e);
+	if (node.type === "text") return renderSegments(buildMarkTree([node]), ctx);
+	const spec = NODE_RENDER_MAP[node.type];
+	if (spec === void 0) {
+		warnUnknown(ctx, node.type);
+		return "";
+	}
+	if (spec === null) return renderNodes(node.content ?? [], ctx);
+	const attrs = processAttrs(node.type, node.attrs);
+	const children = renderNodes(node.content ?? [], ctx);
+	if (spec.children) {
+		let inner = children;
+		for (let i = spec.children.length - 1; i >= 0; i--) {
+			const child = spec.children[i];
+			inner = wrapTag(child.tag, child.content ? attrs : {}, inner);
 		}
-		return b(i.tag, {}, e);
+		return wrapTag(spec.tag, {}, inner);
 	}
-	return b(i.resolve ? i.resolve(e.attrs) : i.tag, a, o);
+	return wrapTag(spec.resolve ? spec.resolve(node.attrs) : spec.tag, attrs, children);
 }
-function y(e, t) {
-	let r = "";
-	for (let i of e) {
-		if (i.kind === "text") {
-			r += n(i.text);
+function renderSegments(segments, ctx) {
+	let out = "";
+	for (const segment of segments) {
+		if (segment.kind === "text") {
+			out += escapeHtml(segment.text);
 			continue;
 		}
-		let e = y(i.children, t), a = t.renderers?.[i.mark.type];
-		if (a) {
-			r += a({
-				...i.mark,
-				children: e,
-				context: { renderers: t.renderers }
+		const children = renderSegments(segment.children, ctx);
+		const custom = ctx.renderers?.[segment.mark.type];
+		if (custom) {
+			out += custom({
+				...segment.mark,
+				children,
+				context: { renderers: ctx.renderers }
 			});
 			continue;
 		}
-		let o = h[i.mark.type];
-		if (!o) {
-			x(t, i.mark.type), r += e;
+		const spec = MARK_RENDER_MAP[segment.mark.type];
+		if (!spec) {
+			warnUnknown(ctx, segment.mark.type);
+			out += children;
 			continue;
 		}
-		r += b(o.tag, s(i.mark.type, i.mark.attrs), e);
+		out += wrapTag(spec.tag, processAttrs(segment.mark.type, segment.mark.attrs), children);
 	}
-	return r;
+	return out;
 }
-function b(e, t, n) {
-	let i = `<${e}`;
-	for (let [e, n] of Object.entries(t)) i += ` ${e}="${r(String(n))}"`;
-	return `${i}>${n}</${e}>`;
+function wrapTag(tag, attrs, children) {
+	let open = `<${tag}`;
+	for (const [name, value] of Object.entries(attrs)) open += ` ${name}="${escapeAttr(String(value))}"`;
+	return `${open}>${children}</${tag}>`;
 }
-function x(e, t) {
-	typeof process < "u" && process.env && process.env.NODE_ENV === "production" || e.warned.has(t) || (e.warned.add(t), console.warn(`[@localess/richtext] Unknown rich text element "${t}" was skipped. Provide a custom renderer to handle it.`));
+function warnUnknown(ctx, type) {
+	if (typeof process !== "undefined" && process.env && process.env.NODE_ENV === "production") return;
+	if (ctx.warned.has(type)) return;
+	ctx.warned.add(type);
+	console.warn(`[@localess/richtext] Unknown rich text element "${type}" was skipped. Provide a custom renderer to handle it.`);
 }
 //#endregion
-export { h as MARK_RENDER_MAP, m as NODE_RENDER_MAP, l as buildMarkTree, r as escapeAttr, n as escapeHtml, c as marksEqual, u as normalizeInput, s as processAttrs, g as renderRichTextToHtml, p as resolveHeadingTag, o as sanitizeUrl };
+export { MARK_RENDER_MAP, NODE_RENDER_MAP, buildMarkTree, escapeAttr, escapeHtml, marksEqual, normalizeInput, processAttrs, renderRichTextToHtml, resolveHeadingTag, sanitizeUrl };

package/dist/model.d.ts

@@ -1,3 +1,4 @@
+import { ContentRichText } from '@localess/model';
 /**
  * Attributes of a `link` mark as stored by the Localess Studio editor
  * (TipTap Link extension JSON).
@@ -71,16 +72,12 @@ export interface LocalessRichTextDocument {
     content?: LocalessRichTextNode[];
 }
 /**
- * Structural stand-in for `@localess/client`'s `ContentRichText` so client
- * values pass without casting. Deliberately not imported — this package has
- * zero dependencies.
+ * Re-exported from `@localess/model` so `LocalessRichTextInput` accepts
+ * `ContentRichText` values without casting.
  */
-export interface ContentRichTextLike {
-    type?: string;
-    content?: ContentRichTextLike[];
-}
+export type { ContentRichText };
 /** Anything a render function accepts. */
-export type LocalessRichTextInput = LocalessRichTextDocument | LocalessRichTextNode | LocalessRichTextNode[] | ContentRichTextLike | null | undefined;
+export type LocalessRichTextInput = LocalessRichTextDocument | LocalessRichTextNode | LocalessRichTextNode[] | ContentRichText | null | undefined;
 /** Union of every known node and mark type name. */
 export type LocalessRichTextElement = LocalessRichTextNode['type'] | LocalessRichTextMark['type'] | 'doc';
 /**

package/dist/normalize.d.ts

@@ -5,7 +5,7 @@ export interface NormalizeInputOptions {
 }
 /**
  * Flattens any accepted rich text input (document, node, node array, or the
- * loose `ContentRichText` shape from `@localess/client`) into a node list.
+ * loose `ContentRichText` shape from `@localess/model`) into a node list.
  * Never throws; malformed input yields `[]`.
  */
 export declare function normalizeInput(input: LocalessRichTextInput, options?: NormalizeInputOptions): LocalessRichTextNodeWithKey[];