@effected/markdown 0.6.3 → 0.7.0

package/internal/phrasing.js

@@ -0,0 +1,57 @@
+import { Point, Position } from "../MarkdownNode.js";
+import { preprocessLines } from "./preprocess.js";
+import { LineIndex } from "./lineIndex.js";
+import { parseInlines } from "./inlineParser.js";
+import { trimWithSegments } from "./rawInline.js";
+
+//#region src/internal/phrasing.ts
+const EMPTY_REFMAP = /* @__PURE__ */ new Map();
+const EMPTY_FOOTNOTE_LABELS = /* @__PURE__ */ new Set();
+/**
+* Parse a text fragment as a single paragraph's inline content.
+*/
+const parsePhrasingText = (text, dialect) => {
+	const lines = preprocessLines(text);
+	const segments = [];
+	let content = "";
+	for (const line of lines) {
+		segments.push({
+			textOffset: content.length,
+			sourceOffset: line.start,
+			length: line.text.length
+		});
+		content += `${line.text}\n`;
+	}
+	const trimmed = trimWithSegments(content, segments, /\s/);
+	if (trimmed.text.length === 0) return [];
+	const first = trimmed.segments[0];
+	const startOffset = first === void 0 ? 0 : first.sourceOffset;
+	const lineIndex = LineIndex.fromLineStarts(text, lines.map((line) => line.start));
+	const sourceLength = text.length;
+	const positionOf = (start, end) => {
+		const clampedStart = Math.min(Math.max(start, 0), sourceLength);
+		const clampedEnd = Math.min(Math.max(end, clampedStart), sourceLength);
+		const startPoint = lineIndex.positionAt(clampedStart);
+		const endPoint = lineIndex.positionAt(clampedEnd);
+		return Position.make({
+			start: Point.make({
+				line: startPoint.line,
+				column: startPoint.column,
+				offset: clampedStart
+			}),
+			end: Point.make({
+				line: endPoint.line,
+				column: endPoint.column,
+				offset: clampedEnd
+			})
+		});
+	};
+	return parseInlines({
+		text: trimmed.text,
+		startOffset,
+		segments: trimmed.segments
+	}, EMPTY_REFMAP, positionOf, dialect, EMPTY_FOOTNOTE_LABELS);
+};
+
+//#endregion
+export { parsePhrasingText };

package/internal/rawInline.js

@@ -6,6 +6,8 @@ const reCmarkSpace = /[ \t\n\r]/;
 /**
 * Trim `text` the way commonmark.js does before inline parsing, carrying the
 * segment table along so the surviving characters keep their source offsets.
+* Exported for the phrasing-level parse entry point (`phrasing.ts`), which
+* prepares content the same way a paragraph does.
 */
 const trimWithSegments = (text, segments, whitespace) => {
 	let start = 0;
@@ -54,4 +56,4 @@ const prepareInline = (block, position, refmap, dialect = "commonmark", footnote
 };
 
 //#endregion
-export { prepareInline };
+export { prepareInline, trimWithSegments };

package/internal/stringify.js

@@ -72,7 +72,7 @@ const isSchemeColon = (value, index) => {
 * Escape one text value into `out`, tracking line starts. Returns whether the
 * emission ended at a line start.
 */
-const escapeText = (value, context, atLineStart) => {
+const escapeText = (value, context, atLineStart, mdx) => {
 	let out = "";
 	let lineStart = atLineStart;
 	for (let index = 0; index < value.length; index += 1) {
@@ -125,6 +125,10 @@ const escapeText = (value, context, atLineStart) => {
 			out += `\\${char}`;
 			continue;
 		}
+		if (mdx && char === "{") {
+			out += "\\{";
+			continue;
+		}
 		if (context.inHeading && char === "#") {
 			out += "\\#";
 			continue;
@@ -214,7 +218,7 @@ const serializeInlines = (children, context, state, startsLine, junctionGuard) =
 		};
 		switch (child.type) {
 			case "text": {
-				const escaped = escapeText(child.value, context, atLineStart);
+				const escaped = escapeText(child.value, context, atLineStart, state.mdx);
 				out += escaped.text;
 				atLineStart = escaped.atLineStart;
 				break;
@@ -291,12 +295,126 @@ const serializeInlines = (children, context, state, startsLine, junctionGuard) =
 			case "footnoteReference":
 				out += `[^${escapeLabel(child.label ?? child.identifier)}]`;
 				atLineStart = false;
+				break;
+			case "mdxJsxTextElement":
+				out += serializeMdxJsxText(child, context, state);
+				atLineStart = false;
+				break;
+			case "mdxTextExpression":
+				out += mdxExpression(child.value);
+				atLineStart = false;
 		}
 		index += 1;
 		unguard(state);
 	}
 	return out;
 };
+/** The tag string of every MDX node type. */
+const MDX_NODE_TYPES = /* @__PURE__ */ new Set([
+	"mdxJsxFlowElement",
+	"mdxJsxTextElement",
+	"mdxFlowExpression",
+	"mdxTextExpression",
+	"mdxjsEsm"
+]);
+/** Whether the tree carries any MDX node — iterative, deliberately unguarded. */
+const treeContainsMdx = (root) => {
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (MDX_NODE_TYPES.has(node.type)) return true;
+		if (node.children !== void 0) for (const child of node.children) stack.push(child);
+	}
+	return false;
+};
+/**
+* The oracle's `indentLines` line model (mdast-util-to-markdown
+* `lib/util/indent-lines.js`): lines split on every terminator spelling
+* (`\r\n`, `\n`, bare `\r`), terminators preserved verbatim between the
+* mapped lines, and `blank` meaning an empty line — so a blank CRLF line
+* stays bare instead of having a retained `\r` treated as content.
+*/
+const mapMdxLines = (value, map) => {
+	const eol = /\r?\n|\r/g;
+	const result = [];
+	let start = 0;
+	let index = 0;
+	for (let match = eol.exec(value); match !== null; match = eol.exec(value)) {
+		const line = value.slice(start, match.index);
+		result.push(map(line, index, line === ""), match[0]);
+		start = match.index + match[0].length;
+		index += 1;
+	}
+	const last = value.slice(start);
+	result.push(map(last, index, last === ""));
+	return result.join("");
+};
+/**
+* Serialize an MDX expression body between braces. Continuation lines take
+* the oracle's two-space indent; the first line and blank lines take none.
+*/
+const mdxExpression = (value) => `{${mapMdxLines(value, (line, index, blank) => index === 0 || blank ? line : `  ${line}`)}}`;
+/**
+* Serialize one JSX attribute. A `null` or absent value is a boolean
+* attribute; a string value is quoted with `"` (the oracle default), the
+* quote itself escaped as `&#x22;` exactly as `stringify-entities` spells
+* it; an expression value goes between braces.
+*/
+const serializeMdxAttribute = (attribute) => {
+	if (attribute.type === "mdxJsxExpressionAttribute") return `{${attribute.value}}`;
+	const value = attribute.value;
+	if (value === void 0 || value === null) return attribute.name;
+	if (typeof value === "string") return `${attribute.name}="${value.replaceAll("\"", "&#x22;")}"`;
+	return `${attribute.name}={${value.value}}`;
+};
+/** Serialize a text (phrasing) JSX element. */
+const serializeMdxJsxText = (node, context, state) => {
+	const attributes = node.attributes.map(serializeMdxAttribute);
+	const selfClosing = node.name !== null && node.children.length === 0;
+	let out = `<${node.name ?? ""}`;
+	if (attributes.length > 0) out += ` ${attributes.join(" ")}`;
+	if (selfClosing) return `${out} />`;
+	out += ">";
+	out += serializeInlines(node.children, context, state, false);
+	out += `</${node.name ?? ""}>`;
+	return out;
+};
+/** Prefix every line of a rendered child block; blank lines stay bare. */
+const indentBlockLines = (content, indent) => mapMdxLines(content, (line, _index, blank) => blank ? line : `${indent}${line}`);
+/**
+* Serialize a flow (block) JSX element: opening tag (attributes on their own
+* lines when one carries a line ending), children as indented block layout,
+* closing tag — the oracle's `mdxElement` flow branch.
+*/
+const serializeMdxJsxFlow = (node, state) => {
+	const currentIndent = "  ".repeat(state.jsxDepth);
+	const attributes = node.attributes.map(serializeMdxAttribute);
+	const selfClosing = node.name !== null && node.children.length === 0;
+	const attributesOnOneLine = attributes.join(" ");
+	const attributesOnTheirOwnLine = /[\r\n]/.test(attributesOnOneLine);
+	let value = `${currentIndent}<${node.name ?? ""}`;
+	if (attributesOnTheirOwnLine) value += `\n${attributes.map((attribute) => `${currentIndent}  ${attribute}`).join("\n")}\n${currentIndent}`;
+	else if (attributesOnOneLine !== "") value += ` ${attributesOnOneLine}`;
+	if (selfClosing) value += `${attributesOnTheirOwnLine ? "" : " "}/`;
+	value += ">";
+	if (node.children.length > 0) {
+		state.jsxDepth += 1;
+		const childIndent = "  ".repeat(state.jsxDepth);
+		const parts = node.children.map((child) => {
+			if (child.type === "mdxJsxFlowElement") {
+				guard(state, child);
+				const rendered = serializeMdxJsxFlow(child, state);
+				unguard(state);
+				return rendered;
+			}
+			return indentBlockLines(serializeBlocks([child], state), childIndent);
+		});
+		state.jsxDepth -= 1;
+		value += `\n${parts.join("\n\n")}\n`;
+	}
+	if (!selfClosing) value += `${currentIndent}</${node.name ?? ""}>`;
+	return value;
+};
 /** Prefix every line of `content`; blank lines take the trimmed prefix. */
 const prefixLines = (content, prefix, blankPrefix) => content.split("\n").map((line) => line === "" ? blankPrefix : `${prefix}${line}`).join("\n");
 /** First line gets `marker`, continuation lines get spaces of its width. */
@@ -381,7 +499,10 @@ const effectiveListMarker = (list, flipped) => {
 };
 const serializeListItem = (item, marker, state, tight) => {
 	guard(state, item);
+	const savedJsxDepth = state.jsxDepth;
+	state.jsxDepth = 0;
 	const inner = serializeBlocks(item.children, state, tight);
+	state.jsxDepth = savedJsxDepth;
 	unguard(state);
 	const content = `${item.checked === void 0 ? "" : item.checked ? "[x] " : "[ ] "}${inner}`;
 	if (content === "") return marker.trimEnd();
@@ -455,7 +576,10 @@ const serializeBlocks = (children, state, tight = false) => {
 				previousListMarker = void 0;
 				break;
 			case "blockquote": {
+				const savedJsxDepth = state.jsxDepth;
+				state.jsxDepth = 0;
 				const inner = serializeBlocks(child.children, state);
+				state.jsxDepth = savedJsxDepth;
 				parts.push(prefixLines(inner, "> ", ">"));
 				previousListMarker = void 0;
 				break;
@@ -485,6 +609,17 @@ const serializeBlocks = (children, state, tight = false) => {
 				previousListMarker = void 0;
 				break;
 			}
+			case "mdxJsxFlowElement":
+				parts.push(serializeMdxJsxFlow(child, state));
+				previousListMarker = void 0;
+				break;
+			case "mdxFlowExpression":
+				parts.push(mdxExpression(child.value));
+				previousListMarker = void 0;
+				break;
+			case "mdxjsEsm":
+				parts.push(child.value);
+				previousListMarker = void 0;
 		}
 		previous = child;
 		nodes.push(child);
@@ -510,7 +645,12 @@ const serializeBlocks = (children, state, tight = false) => {
 * empty for an empty root and ends with exactly one newline otherwise.
 */
 const stringifyTree = (root) => {
-	const body = serializeBlocks(root.children, { depth: 0 });
+	const state = {
+		depth: 0,
+		jsxDepth: 0,
+		mdx: treeContainsMdx(root)
+	};
+	const body = serializeBlocks(root.children, state);
 	return body === "" ? "" : `${body}\n`;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/markdown",
-	"version": "0.6.3",
+	"version": "0.7.0",
 	"private": false,
 	"description": "CommonMark and GFM markdown parse, edit and transform schemas for Effect",
 	"keywords": [
@@ -39,9 +39,9 @@
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"@effected/jsonc": "^0.7.0",
+		"@effected/jsonc": "^0.8.0",
 		"@effected/toml": "^0.5.0",
-		"@effected/yaml": "^0.11.0",
+		"@effected/yaml": "^0.12.0",
 		"effect": "4.0.0-rc.109"
 	},
 	"peerDependenciesMeta": {