@maizzle/framework 6.0.0-rc.2 → 6.0.0-rc.21

package/dist/transformers/columnWidth.js

@@ -0,0 +1,546 @@
+import { walk } from "../utils/ast/walker.js";
+import "../utils/ast/index.js";
+import postcss from "postcss";
+import safeParser from "postcss-safe-parser";
+//#region src/transformers/columnWidth.ts
+const RE_PERCENT = /^[\d.]+%$/;
+const NO_BORDER_STYLES = new Set(["none", "hidden"]);
+/**
+* Stringify decls into a `; `-joined inline-style attribute. PostCSS raws
+* preserve the original source spacing, which mixes poorly with
+* the fresh decls we inject — plain join keeps output uniform.
+*/
+function serializeStyle(root) {
+	const parts = [];
+	root.walkDecls((d) => {
+		parts.push(`${d.prop}: ${d.value}${d.important ? " !important" : ""}`);
+	});
+	return parts.join("; ");
+}
+function firstDeclValue(root, prop) {
+	let found;
+	root.walkDecls(prop, (d) => {
+		found = d.value;
+		return false;
+	});
+	return found;
+}
+/**
+* Find the user-set `min-width:` value on a column. Juice keeps both ours
+* and the one inlined from a class like `min-w-1/3` — we skip any
+* min-width whose value still contains our placeholder token,
+* returning the first remaining user value, or null.
+*/
+function findUserMinWidth(root) {
+	let userVal = null;
+	root.walkDecls("min-width", (d) => {
+		if (!d.value.includes("__MAIZZLE_COLW_")) {
+			userVal = d.value;
+			return false;
+		}
+	});
+	return userVal;
+}
+function resolveLength(value) {
+	const trimmed = value.trim();
+	if (RE_PERCENT.test(trimmed)) return trimmed;
+	const m = trimmed.match(/^([\d.]+)(px|rem|em|pt)?$/i);
+	if (!m) return null;
+	const n = parseFloat(m[1]);
+	switch ((m[2] || "px").toLowerCase()) {
+		case "px": return `${Math.round(n)}px`;
+		case "rem":
+		case "em": return `${Math.round(n * 16)}px`;
+		case "pt": return `${Math.round(n * 1.333)}px`;
+		default: return null;
+	}
+}
+function lengthToPx(value) {
+	const m = value.trim().match(/^([\d.]+)(px|rem|em|pt)?$/i);
+	if (!m) return null;
+	const n = parseFloat(m[1]);
+	switch ((m[2] || "px").toLowerCase()) {
+		case "px": return n;
+		case "rem":
+		case "em": return n * 16;
+		case "pt": return n * 1.333;
+		default: return null;
+	}
+}
+function divideLength(value, divisor) {
+	const m = value.match(/^([\d.]+)(px|%)$/);
+	if (!m || divisor < 1) return null;
+	const n = parseFloat(m[1]);
+	return `${parseFloat((n / divisor).toFixed(2))}${m[2]}`;
+}
+function subtractInsetPx(width, insetPx) {
+	if (insetPx <= 0) return width;
+	const m = width.match(/^([\d.]+)(px|%)$/);
+	if (!m) return width;
+	if (m[2] === "%") return width;
+	const n = parseFloat(m[1]) - insetPx;
+	return `${Math.max(0, Math.round(n))}px`;
+}
+/**
+* Return the smaller of two px lengths. Clamps our count-based min-width
+* down to the user's `max-width:` so the cap is never silently
+* violated when our computed min would exceed the user's max.
+*/
+function minPxLength(a, b) {
+	const am = a.match(/^([\d.]+)px$/);
+	const bm = b.match(/^([\d.]+)px$/);
+	if (!am || !bm) return a;
+	return parseFloat(am[1]) < parseFloat(bm[1]) ? a : b;
+}
+/**
+* Expand a 1-4 token CSS shorthand (T R B L) into a left/right pair:
+*   1: all sides
+*   2: TB RL
+*   3: T RL B
+*   4: T R B L
+*/
+function shorthandSides(value) {
+	const parts = value.trim().split(/\s+/);
+	switch (parts.length) {
+		case 1: return {
+			left: parts[0],
+			right: parts[0]
+		};
+		case 2:
+		case 3: return {
+			left: parts[1],
+			right: parts[1]
+		};
+		case 4: return {
+			left: parts[3],
+			right: parts[1]
+		};
+		default: return {};
+	}
+}
+/**
+* Read horizontal padding (left + right) px from a parsed style root.
+* Percentages are skipped — they'd need a known container width.
+*/
+function horizontalPaddingPx(root) {
+	let left = null;
+	let right = null;
+	root.walkDecls((d) => {
+		switch (d.prop) {
+			case "padding": {
+				const { left: l, right: r } = shorthandSides(d.value);
+				if (l) left = lengthToPx(l);
+				if (r) right = lengthToPx(r);
+				break;
+			}
+			case "padding-left":
+				left = lengthToPx(d.value);
+				break;
+			case "padding-right":
+				right = lengthToPx(d.value);
+				break;
+		}
+	});
+	return (left ?? 0) + (right ?? 0);
+}
+/**
+* Extract a px length from a CSS border shorthand (e.g. `1px solid red` → 1).
+* Returns null when the value indicates no border — `none` or `hidden`.
+* Defaults to 3px (CSS `medium`) when a visible style is set but
+* no explicit width token is present in the shorthand value.
+*/
+function shorthandBorderWidthPx(value) {
+	const tokens = value.trim().split(/\s+/);
+	if (tokens.some((t) => NO_BORDER_STYLES.has(t.toLowerCase()))) return null;
+	for (const t of tokens) {
+		const px = lengthToPx(t);
+		if (px != null) return px;
+	}
+	return 3;
+}
+/**
+* Read horizontal border widths (left + right) px from a parsed style root.
+* Per-side `border-style: none|hidden` overrides count as zero
+* contribution. Returns total px or 0 when nothing resolves.
+*/
+function horizontalBorderPx(root) {
+	let left = null;
+	let right = null;
+	let leftNone = false;
+	let rightNone = false;
+	root.walkDecls((d) => {
+		switch (d.prop) {
+			case "border": {
+				const w = shorthandBorderWidthPx(d.value);
+				if (w == null) leftNone = rightNone = true;
+				else {
+					left = right = w;
+					leftNone = rightNone = false;
+				}
+				break;
+			}
+			case "border-width": {
+				const { left: l, right: r } = shorthandSides(d.value);
+				if (l) left = lengthToPx(l) ?? left;
+				if (r) right = lengthToPx(r) ?? right;
+				break;
+			}
+			case "border-style": {
+				const { left: l, right: r } = shorthandSides(d.value);
+				if (l && NO_BORDER_STYLES.has(l.toLowerCase())) leftNone = true;
+				if (r && NO_BORDER_STYLES.has(r.toLowerCase())) rightNone = true;
+				break;
+			}
+			case "border-left": {
+				const w = shorthandBorderWidthPx(d.value);
+				if (w == null) leftNone = true;
+				else {
+					left = w;
+					leftNone = false;
+				}
+				break;
+			}
+			case "border-right": {
+				const w = shorthandBorderWidthPx(d.value);
+				if (w == null) rightNone = true;
+				else {
+					right = w;
+					rightNone = false;
+				}
+				break;
+			}
+			case "border-left-width":
+				left = lengthToPx(d.value) ?? left;
+				break;
+			case "border-right-width":
+				right = lengthToPx(d.value) ?? right;
+				break;
+			case "border-left-style":
+				if (NO_BORDER_STYLES.has(d.value.trim().toLowerCase())) leftNone = true;
+				break;
+			case "border-right-style":
+				if (NO_BORDER_STYLES.has(d.value.trim().toLowerCase())) rightNone = true;
+				break;
+		}
+	});
+	return (leftNone ? 0 : left ?? 0) + (rightNone ? 0 : right ?? 0);
+}
+function depth(node) {
+	let d = 0;
+	let cur = node.parent;
+	while (cur) {
+		d++;
+		cur = cur.parent ?? null;
+	}
+	return d;
+}
+function readWidthFromRoot(root) {
+	const raw = firstDeclValue(root, "max-width") ?? firstDeclValue(root, "width") ?? firstDeclValue(root, "min-width");
+	return raw ? resolveLength(raw) : null;
+}
+function readHeightFromRoot(root) {
+	const raw = firstDeclValue(root, "max-height") ?? firstDeclValue(root, "height") ?? firstDeclValue(root, "min-height");
+	return raw ? resolveLength(raw) : null;
+}
+function readWidthSource(el, root) {
+	const explicit = el.attribs?.["data-maizzle-cw"];
+	if (explicit) {
+		const r = resolveLength(explicit);
+		if (r) return r;
+	}
+	return root ? readWidthFromRoot(root) : null;
+}
+/**
+* Convert a user-supplied length to absolute px against the column's source
+* width (post-inset). Percentages multiply against the source while
+* absolute units pass through `resolveLength`. Returns null when
+* the value or source can't be expressed in px.
+*/
+function userValueToPx(rawValue, sourcePx) {
+	const trimmed = rawValue.trim();
+	if (trimmed.match(/^([\d.]+)(px|rem|em|pt)$/i)) return resolveLength(trimmed);
+	const pctMatch = trimmed.match(/^([\d.]+)%$/);
+	if (!pctMatch || !sourcePx) return null;
+	const sourceMatch = sourcePx.match(/^([\d.]+)px$/);
+	if (!sourceMatch) return null;
+	const pct = parseFloat(pctMatch[1]);
+	const src = parseFloat(sourceMatch[1]);
+	return `${Math.round(pct / 100 * src)}px`;
+}
+/**
+* Resolve `__MAIZZLE_COLW_{id}__` and `__MAIZZLE_OH_{id}__` placeholders.
+*
+* COLW (column width) — emitted by `<Column>` and `<Overlap>`. Walks up to
+* the nearest ancestor marked `data-maizzle-cw` (Container, Section,
+* Row, or another Column already resolved) and divides the source
+* width by `data-maizzle-cw-count`. With `data-maizzle-cw-self`,
+* reads from the element's own inlined max/width/min-width
+* instead — used by `<Overlap>` with its own width class.
+*
+* OH (overlap height) — emitted by `<Overlap>`. Reads max-height, height,
+* or min-height from the element's own inlined style.
+*
+* Resolution rules:
+* - Style placeholders for `min-width`: replaced when resolvable, otherwise
+*   the entire `min-width` declaration is stripped.
+* - Other style placeholders (Overlap td `width`, etc.): replaced when
+*   resolvable, otherwise replaced with the count-based fallback or `100%`.
+* - Comment placeholders: same fallback chain.
+*
+* Resolved column widths are written back to `data-maizzle-cw` so nested
+* rows cascade. All `data-maizzle-cw*` and `data-maizzle-oh-*` are
+* stripped at the end of the second walk pass.
+*/
+function columnWidth(dom) {
+	/**
+	* Cache parsed style ASTs for this columnWidth invocation. The walk-up
+	* loop visits the same Section/Container once per column of a Row,
+	* so without caching each column re-parses every ancestor's style.
+	* Cache is function-local — no cross-build leak via the WeakMap.
+	*/
+	const styleCache = /* @__PURE__ */ new WeakMap();
+	const parseElStyle = (el) => {
+		const cached = styleCache.get(el);
+		if (cached) return cached;
+		const style = el.attribs?.style ?? "";
+		const root = style ? safeParser(style) : postcss.root();
+		styleCache.set(el, root);
+		return root;
+	};
+	const columns = [];
+	const heightTargets = [];
+	walk(dom, (node) => {
+		const el = node;
+		if (!el.attribs) return;
+		const id = el.attribs["data-maizzle-cw-id"];
+		if (id) {
+			const count = parseInt(el.attribs["data-maizzle-cw-count"] || "1", 10);
+			const self = "data-maizzle-cw-self" in el.attribs;
+			columns.push({
+				el,
+				id,
+				count,
+				d: depth(node),
+				self
+			});
+		}
+		const ohId = el.attribs["data-maizzle-oh-id"];
+		if (ohId) heightTargets.push({
+			el,
+			id: ohId
+		});
+	});
+	columns.sort((a, b) => a.d - b.d);
+	const widthResolutions = /* @__PURE__ */ new Map();
+	const widthFallbacks = /* @__PURE__ */ new Map();
+	/**
+	* Column ids whose absolute user `width:` was promoted to `min-width:`
+	* — the original `width:` declaration must be stripped from the
+	* column's style (otherwise it'd compete with the min-width).
+	*/
+	const stripWidth = /* @__PURE__ */ new Set();
+	/**
+	* Column ids where the user wrote a percentage `width:` (e.g. `w-1/2`) —
+	* explicit opt-out of px-based stacking. Keep the user's `width: X%`
+	* and drop our `min-width:` placeholder so the column stays at
+	* that percentage of its parent forever and never stacks.
+	*/
+	const dropMinWidth = /* @__PURE__ */ new Set();
+	/**
+	* Column ids where the user wrote their own `min-width:` (via `min-w-1/3`).
+	* Juice inlines theirs after ours, so two `min-width:` decls land in
+	* the style — we strip the user's after using its value as the
+	* column's resolution, leaving our placeholder as last word.
+	*/
+	const stripUserMinWidth = /* @__PURE__ */ new Set();
+	/**
+	* Column ids where the user already supplied a `max-width:` of their own.
+	* Our default `max-width: 100%` would just be shadowed by it via
+	* last-wins and bloat the style — so we skip emitting it.
+	*/
+	const userHasMaxWidth = /* @__PURE__ */ new Set();
+	for (const { id, count } of columns) widthFallbacks.set(id, `${Math.round(100 / Math.max(count, 1))}%`);
+	for (const { el, id, count, self } of columns) {
+		const ownRoot = parseElStyle(el);
+		let sourceWidth = null;
+		let accumulatedInsetPx = 0;
+		if (self) {
+			sourceWidth = readWidthFromRoot(ownRoot);
+			accumulatedInsetPx = horizontalPaddingPx(ownRoot) + horizontalBorderPx(ownRoot);
+		} else {
+			/**
+			* Walk up through every ancestor with attribs, accumulating horizontal
+			* padding+border along the way (including the source). Stop at the
+			* first `data-maizzle-cw` ancestor whose width is resolvable.
+			* Markers without a resolvable width (Row emitted empty after
+			* Tailwind dropped a bogus class) shouldn't shadow a real
+			* width on a higher ancestor like `<Container>`.
+			*
+			* With CSS content-box this is technically generous toward the
+			* source's own padding/border, but matches user expectations
+			* when they put `px-9` or `border-2` on a wrapper.
+			*/
+			let cur = el.parent;
+			while (cur) {
+				const parentEl = cur;
+				if (parentEl.attribs) {
+					let pRoot = null;
+					if (parentEl.attribs.style) {
+						pRoot = parseElStyle(parentEl);
+						accumulatedInsetPx += horizontalPaddingPx(pRoot) + horizontalBorderPx(pRoot);
+					}
+					if ("data-maizzle-cw" in parentEl.attribs) {
+						const w = readWidthSource(parentEl, pRoot);
+						if (w) {
+							sourceWidth = w;
+							break;
+						}
+					}
+				}
+				cur = cur.parent ?? null;
+			}
+		}
+		const adjusted = sourceWidth ? subtractInsetPx(sourceWidth, accumulatedInsetPx) : null;
+		const countBased = adjusted ? divideLength(adjusted, count) : null;
+		/**
+		* Four user-override paths, decided by which CSS property the user
+		* actually wrote:
+		*
+		*   - `min-width: X` → user's value wins. Convert to px against
+		*                     the source (if %), use as the column's
+		*                     resolution, and strip the user's min-width
+		*                     declaration so our placeholder substitution
+		*                     remains the last `min-width:` in style.
+		*   - `width: X%`   → opt-out of px stacking. Keep `width:` in
+		*                     style, drop our `min-width:` placeholder.
+		*                     Cols stay at X% of parent forever, never stack.
+		*   - `width: Xpx` (or rem/em/pt) → fixed pixel column. Promote to
+		*                     `min-width:`, strip the original `width:` so
+		*                     it doesn't compete.
+		*   - `max-width: X` → CSS cap. Keep the `max-width:` declaration;
+		*                     clamp our count-based min-width *down* to
+		*                     the user's max-width when our min would
+		*                     otherwise violate it.
+		*/
+		const userMinRaw = findUserMinWidth(ownRoot);
+		const widthRaw = firstDeclValue(ownRoot, "width");
+		const maxRaw = firstDeclValue(ownRoot, "max-width");
+		if (userMinRaw) {
+			const minPx = userValueToPx(userMinRaw, adjusted) ?? resolveLength(userMinRaw);
+			if (minPx) {
+				widthResolutions.set(id, minPx);
+				el.attribs["data-maizzle-cw"] = minPx;
+				stripUserMinWidth.add(id);
+				continue;
+			}
+		}
+		if (widthRaw) {
+			const widthVal = resolveLength(widthRaw);
+			if (widthVal?.endsWith("%")) {
+				widthResolutions.set(id, widthVal);
+				el.attribs["data-maizzle-cw"] = widthVal;
+				dropMinWidth.add(id);
+				continue;
+			}
+			if (widthVal) {
+				widthResolutions.set(id, widthVal);
+				el.attribs["data-maizzle-cw"] = widthVal;
+				stripWidth.add(id);
+				continue;
+			}
+		}
+		if (maxRaw && countBased) {
+			const maxPx = userValueToPx(maxRaw, adjusted);
+			if (maxPx) {
+				const cappedMin = countBased.endsWith("px") ? minPxLength(countBased, maxPx) : maxPx;
+				widthResolutions.set(id, cappedMin);
+				el.attribs["data-maizzle-cw"] = cappedMin;
+				userHasMaxWidth.add(id);
+				continue;
+			}
+		}
+		if (countBased) {
+			widthResolutions.set(id, countBased);
+			el.attribs["data-maizzle-cw"] = countBased;
+		}
+	}
+	const heightResolutions = /* @__PURE__ */ new Map();
+	for (const { el, id } of heightTargets) {
+		if (!el.attribs?.style) continue;
+		const h = readHeightFromRoot(parseElStyle(el));
+		if (h) heightResolutions.set(id, h);
+	}
+	walk(dom, (node) => {
+		if (node.type === "comment") {
+			const data = node.data;
+			if (!data || !data.includes("__MAIZZLE_COLW_") && !data.includes("__MAIZZLE_OH_")) return;
+			node.data = data.replace(/__MAIZZLE_COLW_([^_]+)__/g, (_m, mid) => widthResolutions.get(mid) ?? widthFallbacks.get(mid) ?? "100%").replace(/__MAIZZLE_OH_([^_]+)__/g, (_m, hid) => heightResolutions.get(hid) ?? "100%");
+			return;
+		}
+		const el = node;
+		if (!el.attribs) return;
+		const style = el.attribs.style;
+		if (style && (style.includes("__MAIZZLE_COLW_") || style.includes("__MAIZZLE_OH_"))) {
+			const root = parseElStyle(el);
+			const cwId = el.attribs["data-maizzle-cw-id"];
+			/**
+			* Strip user dups BEFORE substitution — last-wins CSS would
+			* otherwise shadow our resolved values in the output.
+			*/
+			if (cwId && stripUserMinWidth.has(cwId)) root.walkDecls("min-width", (d) => {
+				if (!d.value.includes("__MAIZZLE_COLW_")) d.remove();
+			});
+			if (cwId && stripWidth.has(cwId)) root.walkDecls("width", (d) => {
+				d.remove();
+			});
+			/**
+			* Substitute the column's `min-width:` placeholder with `width: <res>;
+			* max-width: 100%`. Width gives the same stacking trigger as
+			* min-width — inline-block wraps when children sum > parent
+			* — and the `max-width: 100%` clamp keeps the column from
+			* overflowing the viewport once it drops to its own row on
+			* mobile. Skip the clamp when the user supplied their own.
+			*
+			* Other placeholders (Overlap td `width`, comment markers,
+			* OH height) get a plain value substitution.
+			*/
+			root.walkDecls((d) => {
+				if (d.prop === "min-width") {
+					const m = d.value.match(/^__MAIZZLE_COLW_([^_]+)__$/);
+					if (m) {
+						const mid = m[1];
+						if (dropMinWidth.has(mid) || !widthResolutions.has(mid)) {
+							d.remove();
+							return;
+						}
+						const resolved = widthResolutions.get(mid);
+						const repl = [postcss.decl({
+							prop: "width",
+							value: resolved
+						})];
+						if (!userHasMaxWidth.has(mid)) repl.push(postcss.decl({
+							prop: "max-width",
+							value: "100%"
+						}));
+						d.replaceWith(...repl);
+						return;
+					}
+				}
+				if (d.value.includes("__MAIZZLE_COLW_") || d.value.includes("__MAIZZLE_OH_")) d.value = d.value.replace(/__MAIZZLE_COLW_([^_]+)__/g, (_m, mid) => widthResolutions.get(mid) ?? widthFallbacks.get(mid) ?? "100%").replace(/__MAIZZLE_OH_([^_]+)__/g, (_m, hid) => heightResolutions.get(hid) ?? "100%");
+			});
+			const out = serializeStyle(root);
+			if (out) el.attribs.style = out;
+			else delete el.attribs.style;
+		}
+		delete el.attribs["data-maizzle-cw"];
+		delete el.attribs["data-maizzle-cw-id"];
+		delete el.attribs["data-maizzle-cw-count"];
+		delete el.attribs["data-maizzle-cw-self"];
+		delete el.attribs["data-maizzle-oh-id"];
+	});
+	return dom;
+}
+//#endregion
+export { columnWidth };
+
+//# sourceMappingURL=columnWidth.js.map

package/dist/transformers/columnWidth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnWidth.js","names":[],"sources":["../../src/transformers/columnWidth.ts"],"sourcesContent":["import postcss, { type Root, type Declaration } from 'postcss'\nimport safeParser from 'postcss-safe-parser'\nimport { walk } from '../utils/ast/index.ts'\nimport type { ChildNode, Element, ParentNode } from 'domhandler'\n\nconst RE_PERCENT = /^[\\d.]+%$/\nconst NO_BORDER_STYLES = new Set(['none', 'hidden'])\n\n/**\n * Stringify decls into a `; `-joined inline-style attribute. PostCSS raws\n * preserve the original source spacing, which mixes poorly with\n * the fresh decls we inject — plain join keeps output uniform.\n */\nfunction serializeStyle(root: Root): string {\n  const parts: string[] = []\n  root.walkDecls((d) => {\n    parts.push(`${d.prop}: ${d.value}${d.important ? ' !important' : ''}`)\n  })\n  return parts.join('; ')\n}\n\nfunction firstDeclValue(root: Root, prop: string): string | undefined {\n  let found: string | undefined\n  root.walkDecls(prop, (d) => {\n    found = d.value\n    return false\n  })\n  return found\n}\n\n/**\n * Find the user-set `min-width:` value on a column. Juice keeps both ours\n * and the one inlined from a class like `min-w-1/3` — we skip any\n * min-width whose value still contains our placeholder token,\n * returning the first remaining user value, or null.\n */\nfunction findUserMinWidth(root: Root): string | null {\n  let userVal: string | null = null\n  root.walkDecls('min-width', (d) => {\n    if (!d.value.includes('__MAIZZLE_COLW_')) {\n      userVal = d.value\n      return false\n    }\n  })\n  return userVal\n}\n\nfunction resolveLength(value: string): string | null {\n  const trimmed = value.trim()\n  if (RE_PERCENT.test(trimmed)) return trimmed\n  const m = trimmed.match(/^([\\d.]+)(px|rem|em|pt)?$/i)\n  if (!m) return null\n  const n = parseFloat(m[1])\n  switch ((m[2] || 'px').toLowerCase()) {\n    case 'px': return `${Math.round(n)}px`\n    case 'rem':\n    case 'em': return `${Math.round(n * 16)}px`\n    case 'pt': return `${Math.round(n * 1.333)}px`\n    default: return null\n  }\n}\n\nfunction lengthToPx(value: string): number | null {\n  const m = value.trim().match(/^([\\d.]+)(px|rem|em|pt)?$/i)\n  if (!m) return null\n  const n = parseFloat(m[1])\n  switch ((m[2] || 'px').toLowerCase()) {\n    case 'px': return n\n    case 'rem':\n    case 'em': return n * 16\n    case 'pt': return n * 1.333\n    default: return null\n  }\n}\n\nfunction divideLength(value: string, divisor: number): string | null {\n  const m = value.match(/^([\\d.]+)(px|%)$/)\n  if (!m || divisor < 1) return null\n  const n = parseFloat(m[1])\n  return `${parseFloat((n / divisor).toFixed(2))}${m[2]}`\n}\n\nfunction subtractInsetPx(width: string, insetPx: number): string {\n  if (insetPx <= 0) return width\n  const m = width.match(/^([\\d.]+)(px|%)$/)\n  if (!m) return width\n  // Don't subtract px from percentage widths — units don't match.\n  if (m[2] === '%') return width\n  const n = parseFloat(m[1]) - insetPx\n  return `${Math.max(0, Math.round(n))}px`\n}\n\n/**\n * Return the smaller of two px lengths. Clamps our count-based min-width\n * down to the user's `max-width:` so the cap is never silently\n * violated when our computed min would exceed the user's max.\n */\nfunction minPxLength(a: string, b: string): string {\n  const am = a.match(/^([\\d.]+)px$/)\n  const bm = b.match(/^([\\d.]+)px$/)\n  if (!am || !bm) return a\n  return parseFloat(am[1]) < parseFloat(bm[1]) ? a : b\n}\n\n/**\n * Expand a 1-4 token CSS shorthand (T R B L) into a left/right pair:\n *   1: all sides\n *   2: TB RL\n *   3: T RL B\n *   4: T R B L\n */\nfunction shorthandSides(value: string): { left?: string; right?: string } {\n  const parts = value.trim().split(/\\s+/)\n  switch (parts.length) {\n    case 1: return { left: parts[0], right: parts[0] }\n    case 2:\n    case 3: return { left: parts[1], right: parts[1] }\n    case 4: return { left: parts[3], right: parts[1] }\n    default: return {}\n  }\n}\n\n/**\n * Read horizontal padding (left + right) px from a parsed style root.\n * Percentages are skipped — they'd need a known container width.\n */\nfunction horizontalPaddingPx(root: Root): number {\n  let left: number | null = null\n  let right: number | null = null\n\n  // Shorthand applies first; longhand overrides per side.\n  root.walkDecls((d) => {\n    switch (d.prop) {\n      case 'padding': {\n        const { left: l, right: r } = shorthandSides(d.value)\n        if (l) left = lengthToPx(l)\n        if (r) right = lengthToPx(r)\n        break\n      }\n      case 'padding-left':\n        left = lengthToPx(d.value)\n        break\n      case 'padding-right':\n        right = lengthToPx(d.value)\n        break\n    }\n  })\n\n  return (left ?? 0) + (right ?? 0)\n}\n\n/**\n * Extract a px length from a CSS border shorthand (e.g. `1px solid red` → 1).\n * Returns null when the value indicates no border — `none` or `hidden`.\n * Defaults to 3px (CSS `medium`) when a visible style is set but\n * no explicit width token is present in the shorthand value.\n */\nfunction shorthandBorderWidthPx(value: string): number | null {\n  const tokens = value.trim().split(/\\s+/)\n  if (tokens.some((t) => NO_BORDER_STYLES.has(t.toLowerCase()))) return null\n  for (const t of tokens) {\n    const px = lengthToPx(t)\n    if (px != null) return px\n  }\n  // Visible style, no explicit width → CSS default `medium` = 3px.\n  return 3\n}\n\n/**\n * Read horizontal border widths (left + right) px from a parsed style root.\n * Per-side `border-style: none|hidden` overrides count as zero\n * contribution. Returns total px or 0 when nothing resolves.\n */\nfunction horizontalBorderPx(root: Root): number {\n  let left: number | null = null\n  let right: number | null = null\n  let leftNone = false\n  let rightNone = false\n\n  root.walkDecls((d) => {\n    switch (d.prop) {\n      case 'border': {\n        const w = shorthandBorderWidthPx(d.value)\n        if (w == null) {\n          leftNone = rightNone = true\n        }\n        else {\n          left = right = w\n          leftNone = rightNone = false\n        }\n        break\n      }\n      case 'border-width': {\n        const { left: l, right: r } = shorthandSides(d.value)\n        if (l) left = lengthToPx(l) ?? left\n        if (r) right = lengthToPx(r) ?? right\n        break\n      }\n      case 'border-style': {\n        const { left: l, right: r } = shorthandSides(d.value)\n        if (l && NO_BORDER_STYLES.has(l.toLowerCase())) leftNone = true\n        if (r && NO_BORDER_STYLES.has(r.toLowerCase())) rightNone = true\n        break\n      }\n      case 'border-left': {\n        const w = shorthandBorderWidthPx(d.value)\n        if (w == null) leftNone = true\n        else { left = w; leftNone = false }\n        break\n      }\n      case 'border-right': {\n        const w = shorthandBorderWidthPx(d.value)\n        if (w == null) rightNone = true\n        else { right = w; rightNone = false }\n        break\n      }\n      case 'border-left-width':\n        left = lengthToPx(d.value) ?? left\n        break\n      case 'border-right-width':\n        right = lengthToPx(d.value) ?? right\n        break\n      case 'border-left-style':\n        if (NO_BORDER_STYLES.has(d.value.trim().toLowerCase())) leftNone = true\n        break\n      case 'border-right-style':\n        if (NO_BORDER_STYLES.has(d.value.trim().toLowerCase())) rightNone = true\n        break\n    }\n  })\n\n  return (leftNone ? 0 : (left ?? 0)) + (rightNone ? 0 : (right ?? 0))\n}\n\nfunction depth(node: ChildNode): number {\n  let d = 0\n  let cur: ParentNode | null = node.parent\n  while (cur) {\n    d++\n    cur = (cur as any).parent ?? null\n  }\n  return d\n}\n\nfunction readWidthFromRoot(root: Root): string | null {\n  const raw = firstDeclValue(root, 'max-width')\n    ?? firstDeclValue(root, 'width')\n    ?? firstDeclValue(root, 'min-width')\n  return raw ? resolveLength(raw) : null\n}\n\nfunction readHeightFromRoot(root: Root): string | null {\n  const raw = firstDeclValue(root, 'max-height')\n    ?? firstDeclValue(root, 'height')\n    ?? firstDeclValue(root, 'min-height')\n  return raw ? resolveLength(raw) : null\n}\n\nfunction readWidthSource(el: Element, root: Root | null): string | null {\n  const explicit = el.attribs?.['data-maizzle-cw']\n  if (explicit) {\n    const r = resolveLength(explicit)\n    if (r) return r\n  }\n  return root ? readWidthFromRoot(root) : null\n}\n\n/**\n * Convert a user-supplied length to absolute px against the column's source\n * width (post-inset). Percentages multiply against the source while\n * absolute units pass through `resolveLength`. Returns null when\n * the value or source can't be expressed in px.\n */\nfunction userValueToPx(rawValue: string, sourcePx: string | null): string | null {\n  const trimmed = rawValue.trim()\n\n  const absMatch = trimmed.match(/^([\\d.]+)(px|rem|em|pt)$/i)\n  if (absMatch) return resolveLength(trimmed)\n\n  const pctMatch = trimmed.match(/^([\\d.]+)%$/)\n  if (!pctMatch || !sourcePx) return null\n  const sourceMatch = sourcePx.match(/^([\\d.]+)px$/)\n  if (!sourceMatch) return null\n  const pct = parseFloat(pctMatch[1])\n  const src = parseFloat(sourceMatch[1])\n  return `${Math.round((pct / 100) * src)}px`\n}\n\n/**\n * Resolve `__MAIZZLE_COLW_{id}__` and `__MAIZZLE_OH_{id}__` placeholders.\n *\n * COLW (column width) — emitted by `<Column>` and `<Overlap>`. Walks up to\n * the nearest ancestor marked `data-maizzle-cw` (Container, Section,\n * Row, or another Column already resolved) and divides the source\n * width by `data-maizzle-cw-count`. With `data-maizzle-cw-self`,\n * reads from the element's own inlined max/width/min-width\n * instead — used by `<Overlap>` with its own width class.\n *\n * OH (overlap height) — emitted by `<Overlap>`. Reads max-height, height,\n * or min-height from the element's own inlined style.\n *\n * Resolution rules:\n * - Style placeholders for `min-width`: replaced when resolvable, otherwise\n *   the entire `min-width` declaration is stripped.\n * - Other style placeholders (Overlap td `width`, etc.): replaced when\n *   resolvable, otherwise replaced with the count-based fallback or `100%`.\n * - Comment placeholders: same fallback chain.\n *\n * Resolved column widths are written back to `data-maizzle-cw` so nested\n * rows cascade. All `data-maizzle-cw*` and `data-maizzle-oh-*` are\n * stripped at the end of the second walk pass.\n */\nexport function columnWidth(dom: ChildNode[]): ChildNode[] {\n  /**\n   * Cache parsed style ASTs for this columnWidth invocation. The walk-up\n   * loop visits the same Section/Container once per column of a Row,\n   * so without caching each column re-parses every ancestor's style.\n   * Cache is function-local — no cross-build leak via the WeakMap.\n   */\n  const styleCache = new WeakMap<Element, Root>()\n  const parseElStyle = (el: Element): Root => {\n    const cached = styleCache.get(el)\n    if (cached) return cached\n    const style = el.attribs?.style ?? ''\n    const root = style ? safeParser(style) : postcss.root()\n    styleCache.set(el, root)\n    return root\n  }\n\n  const columns: { el: Element; id: string; count: number; d: number; self: boolean }[] = []\n  const heightTargets: { el: Element; id: string }[] = []\n\n  walk(dom, (node) => {\n    const el = node as Element\n    if (!el.attribs) return\n\n    const id = el.attribs['data-maizzle-cw-id']\n    if (id) {\n      const count = parseInt(el.attribs['data-maizzle-cw-count'] || '1', 10)\n      const self = 'data-maizzle-cw-self' in el.attribs\n      columns.push({ el, id, count, d: depth(node), self })\n    }\n\n    const ohId = el.attribs['data-maizzle-oh-id']\n    if (ohId) heightTargets.push({ el, id: ohId })\n  })\n\n  columns.sort((a, b) => a.d - b.d)\n\n  const widthResolutions = new Map<string, string>()\n  const widthFallbacks = new Map<string, string>()\n  /**\n   * Column ids whose absolute user `width:` was promoted to `min-width:`\n   * — the original `width:` declaration must be stripped from the\n   * column's style (otherwise it'd compete with the min-width).\n   */\n  const stripWidth = new Set<string>()\n  /**\n   * Column ids where the user wrote a percentage `width:` (e.g. `w-1/2`) —\n   * explicit opt-out of px-based stacking. Keep the user's `width: X%`\n   * and drop our `min-width:` placeholder so the column stays at\n   * that percentage of its parent forever and never stacks.\n   */\n  const dropMinWidth = new Set<string>()\n  /**\n   * Column ids where the user wrote their own `min-width:` (via `min-w-1/3`).\n   * Juice inlines theirs after ours, so two `min-width:` decls land in\n   * the style — we strip the user's after using its value as the\n   * column's resolution, leaving our placeholder as last word.\n   */\n  const stripUserMinWidth = new Set<string>()\n  /**\n   * Column ids where the user already supplied a `max-width:` of their own.\n   * Our default `max-width: 100%` would just be shadowed by it via\n   * last-wins and bloat the style — so we skip emitting it.\n   */\n  const userHasMaxWidth = new Set<string>()\n\n  for (const { id, count } of columns) {\n    widthFallbacks.set(id, `${Math.round(100 / Math.max(count, 1))}%`)\n  }\n\n  for (const { el, id, count, self } of columns) {\n    const ownRoot = parseElStyle(el)\n\n    let sourceWidth: string | null = null\n    let accumulatedInsetPx = 0\n\n    if (self) {\n      sourceWidth = readWidthFromRoot(ownRoot)\n      accumulatedInsetPx = horizontalPaddingPx(ownRoot) + horizontalBorderPx(ownRoot)\n    }\n    else {\n      /**\n       * Walk up through every ancestor with attribs, accumulating horizontal\n       * padding+border along the way (including the source). Stop at the\n       * first `data-maizzle-cw` ancestor whose width is resolvable.\n       * Markers without a resolvable width (Row emitted empty after\n       * Tailwind dropped a bogus class) shouldn't shadow a real\n       * width on a higher ancestor like `<Container>`.\n       *\n       * With CSS content-box this is technically generous toward the\n       * source's own padding/border, but matches user expectations\n       * when they put `px-9` or `border-2` on a wrapper.\n       */\n      let cur: ParentNode | null = el.parent\n      while (cur) {\n        const parentEl = cur as Element\n        if (parentEl.attribs) {\n          let pRoot: Root | null = null\n          if (parentEl.attribs.style) {\n            pRoot = parseElStyle(parentEl)\n            accumulatedInsetPx += horizontalPaddingPx(pRoot) + horizontalBorderPx(pRoot)\n          }\n          if ('data-maizzle-cw' in parentEl.attribs) {\n            const w = readWidthSource(parentEl, pRoot)\n            if (w) {\n              sourceWidth = w\n              break\n            }\n          }\n        }\n        cur = (cur as any).parent ?? null\n      }\n    }\n\n    const adjusted = sourceWidth ? subtractInsetPx(sourceWidth, accumulatedInsetPx) : null\n    const countBased = adjusted ? divideLength(adjusted, count) : null\n\n    /**\n     * Four user-override paths, decided by which CSS property the user\n     * actually wrote:\n     *\n     *   - `min-width: X` → user's value wins. Convert to px against\n     *                     the source (if %), use as the column's\n     *                     resolution, and strip the user's min-width\n     *                     declaration so our placeholder substitution\n     *                     remains the last `min-width:` in style.\n     *   - `width: X%`   → opt-out of px stacking. Keep `width:` in\n     *                     style, drop our `min-width:` placeholder.\n     *                     Cols stay at X% of parent forever, never stack.\n     *   - `width: Xpx` (or rem/em/pt) → fixed pixel column. Promote to\n     *                     `min-width:`, strip the original `width:` so\n     *                     it doesn't compete.\n     *   - `max-width: X` → CSS cap. Keep the `max-width:` declaration;\n     *                     clamp our count-based min-width *down* to\n     *                     the user's max-width when our min would\n     *                     otherwise violate it.\n     */\n    const userMinRaw = findUserMinWidth(ownRoot)\n    const widthRaw = firstDeclValue(ownRoot, 'width')\n    const maxRaw = firstDeclValue(ownRoot, 'max-width')\n\n    if (userMinRaw) {\n      const minPx = userValueToPx(userMinRaw, adjusted) ?? resolveLength(userMinRaw)\n      if (minPx) {\n        widthResolutions.set(id, minPx)\n        el.attribs['data-maizzle-cw'] = minPx\n        stripUserMinWidth.add(id)\n        continue\n      }\n    }\n\n    if (widthRaw) {\n      const widthVal = resolveLength(widthRaw)\n      if (widthVal?.endsWith('%')) {\n        widthResolutions.set(id, widthVal)\n        el.attribs['data-maizzle-cw'] = widthVal\n        dropMinWidth.add(id)\n        continue\n      }\n      if (widthVal) {\n        widthResolutions.set(id, widthVal)\n        el.attribs['data-maizzle-cw'] = widthVal\n        stripWidth.add(id)\n        continue\n      }\n    }\n\n    if (maxRaw && countBased) {\n      const maxPx = userValueToPx(maxRaw, adjusted)\n      if (maxPx) {\n        const cappedMin = countBased.endsWith('px')\n          ? minPxLength(countBased, maxPx)\n          : maxPx\n        widthResolutions.set(id, cappedMin)\n        el.attribs['data-maizzle-cw'] = cappedMin\n        userHasMaxWidth.add(id)\n        continue\n      }\n    }\n\n    if (countBased) {\n      widthResolutions.set(id, countBased)\n      el.attribs['data-maizzle-cw'] = countBased\n    }\n  }\n\n  const heightResolutions = new Map<string, string>()\n  for (const { el, id } of heightTargets) {\n    if (!el.attribs?.style) continue\n    const h = readHeightFromRoot(parseElStyle(el))\n    if (h) heightResolutions.set(id, h)\n  }\n\n  walk(dom, (node) => {\n    if (node.type === 'comment') {\n      const data = (node as any).data as string\n      if (!data || (!data.includes('__MAIZZLE_COLW_') && !data.includes('__MAIZZLE_OH_'))) return\n      ;(node as any).data = data\n        .replace(/__MAIZZLE_COLW_([^_]+)__/g,\n          (_m, mid) => widthResolutions.get(mid) ?? widthFallbacks.get(mid) ?? '100%')\n        .replace(/__MAIZZLE_OH_([^_]+)__/g,\n          (_m, hid) => heightResolutions.get(hid) ?? '100%')\n      return\n    }\n\n    const el = node as Element\n    if (!el.attribs) return\n\n    const style = el.attribs.style\n    if (style && (style.includes('__MAIZZLE_COLW_') || style.includes('__MAIZZLE_OH_'))) {\n      const root = parseElStyle(el)\n      const cwId = el.attribs['data-maizzle-cw-id']\n\n      /**\n       * Strip user dups BEFORE substitution — last-wins CSS would\n       * otherwise shadow our resolved values in the output.\n       */\n      if (cwId && stripUserMinWidth.has(cwId)) {\n        root.walkDecls('min-width', (d) => {\n          if (!d.value.includes('__MAIZZLE_COLW_')) d.remove()\n        })\n      }\n      if (cwId && stripWidth.has(cwId)) {\n        root.walkDecls('width', (d) => { d.remove() })\n      }\n\n      /**\n       * Substitute the column's `min-width:` placeholder with `width: <res>;\n       * max-width: 100%`. Width gives the same stacking trigger as\n       * min-width — inline-block wraps when children sum > parent\n       * — and the `max-width: 100%` clamp keeps the column from\n       * overflowing the viewport once it drops to its own row on\n       * mobile. Skip the clamp when the user supplied their own.\n       *\n       * Other placeholders (Overlap td `width`, comment markers,\n       * OH height) get a plain value substitution.\n       */\n      root.walkDecls((d) => {\n        if (d.prop === 'min-width') {\n          const m = d.value.match(/^__MAIZZLE_COLW_([^_]+)__$/)\n          if (m) {\n            const mid = m[1]\n            if (dropMinWidth.has(mid) || !widthResolutions.has(mid)) {\n              d.remove()\n              return\n            }\n            const resolved = widthResolutions.get(mid)!\n            const repl: Declaration[] = [postcss.decl({ prop: 'width', value: resolved })]\n            if (!userHasMaxWidth.has(mid)) {\n              repl.push(postcss.decl({ prop: 'max-width', value: '100%' }))\n            }\n            d.replaceWith(...repl)\n            return\n          }\n        }\n        if (d.value.includes('__MAIZZLE_COLW_') || d.value.includes('__MAIZZLE_OH_')) {\n          d.value = d.value\n            .replace(/__MAIZZLE_COLW_([^_]+)__/g,\n              (_m, mid) => widthResolutions.get(mid) ?? widthFallbacks.get(mid) ?? '100%')\n            .replace(/__MAIZZLE_OH_([^_]+)__/g,\n              (_m, hid) => heightResolutions.get(hid) ?? '100%')\n        }\n      })\n\n      const out = serializeStyle(root)\n      if (out) el.attribs.style = out\n      else delete el.attribs.style\n    }\n\n    delete el.attribs['data-maizzle-cw']\n    delete el.attribs['data-maizzle-cw-id']\n    delete el.attribs['data-maizzle-cw-count']\n    delete el.attribs['data-maizzle-cw-self']\n    delete el.attribs['data-maizzle-oh-id']\n  })\n\n  return dom\n}\n"],"mappings":"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"}

package/dist/transformers/entities.d.ts

@@ -0,0 +1,37 @@
+import { EntitiesConfig } from "../types/config.js";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/entities.d.ts
+/**
+ * Replace literal Unicode characters in text nodes with their HTML entity
+ * equivalents (zero-width joiners, non-breaking spaces, smart quotes,
+ * dashes, etc.) for better email-client rendering.
+ *
+ * @param html   HTML string to transform.
+ * @param custom Extra entries merged on top of the built-in entity map, or
+ *               `false` to disable the transform. Defaults to `true`
+ *               (built-ins only).
+ * @returns      The transformed HTML string.
+ *
+ * @example
+ * import { entities } from '@maizzle/framework'
+ *
+ * // Defaults only
+ * entities('hello world') // → 'hello world'
+ *
+ * // Add a custom mapping
+ * entities('© Maizzle', { '©': '©' })
+ *
+ * // Disable the transform
+ * entities('hello world', false)
+ */
+declare function entities(html: string, custom?: EntitiesConfig): string;
+/**
+ * DOM-form of {@link entities} used by the internal transformer pipeline.
+ * Takes a parsed DOM, returns a parsed DOM — avoids redundant
+ * serialize/parse round-trips when chained with other transformers.
+ */
+declare function entitiesDom(dom: ChildNode[], custom?: EntitiesConfig): ChildNode[];
+//#endregion
+export { entities, entitiesDom };
+//# sourceMappingURL=entities.d.ts.map

package/dist/transformers/entities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entities.d.ts","names":[],"sources":["../../src/transformers/entities.ts"],"mappings":";;;;;;;AAqDA;;;;;;;;;AASA;;;;;;;;;;;iBATgB,QAAA,CAAS,IAAA,UAAc,MAAA,GAAQ,cAAA;;;;;;iBAS/B,WAAA,CAAY,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,cAAA,GAAwB,SAAA"}