github-markdown-adf 0.0.0-semantic-release

package/dist/index.mjs

@@ -0,0 +1,634 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkGfm from "remark-gfm";
+//#region src/md-to-adf/parser.ts
+function parseMarkdown(markdown) {
+	return unified().use(remarkParse).use(remarkGfm).parse(markdown);
+}
+//#endregion
+//#region src/utils/language.ts
+const LANGUAGE_ALIASES = {
+	ts: "typescript",
+	js: "javascript",
+	jsx: "javascript",
+	tsx: "typescript",
+	py: "python",
+	rb: "ruby",
+	sh: "bash",
+	zsh: "bash",
+	shell: "bash",
+	yml: "yaml",
+	md: "markdown",
+	rs: "rust",
+	kt: "kotlin",
+	tf: "hcl",
+	dockerfile: "docker"
+};
+function normalizeLanguage(lang) {
+	if (!lang) return void 0;
+	const lower = lang.toLowerCase().trim();
+	if (!lower) return void 0;
+	return LANGUAGE_ALIASES[lower] ?? lower;
+}
+//#endregion
+//#region src/md-to-adf/transform/marks.ts
+const OPEN_HTML_TAG = /^<(ins|sub|sup)>$/i;
+const CLOSE_HTML_TAG = /^<\/(ins|sub|sup)>$/i;
+function htmlTagToMark(tag) {
+	const t = tag.toLowerCase();
+	if (t === "ins") return { type: "underline" };
+	if (t === "sub") return {
+		type: "subsup",
+		attrs: { type: "sub" }
+	};
+	if (t === "sup") return {
+		type: "subsup",
+		attrs: { type: "sup" }
+	};
+	return null;
+}
+function phrasingToInlineNodes(nodes) {
+	const markStack = [];
+	const result = [];
+	for (const node of nodes) {
+		if (node.type === "html") {
+			const openMatch = OPEN_HTML_TAG.exec(node.value);
+			if (openMatch) {
+				const mark = htmlTagToMark(openMatch[1] ?? "");
+				if (mark) markStack.push(mark);
+				continue;
+			}
+			if (CLOSE_HTML_TAG.exec(node.value)) {
+				markStack.pop();
+				continue;
+			}
+		}
+		result.push(...phrasingToInline(node, markStack.slice()));
+	}
+	return result;
+}
+function phrasingToInline(node, inheritedMarks) {
+	switch (node.type) {
+		case "text":
+			if (!node.value) return [];
+			return [makeText(node.value, inheritedMarks)];
+		case "inlineCode": {
+			const marks = [...inheritedMarks.filter((m) => m.type === "link"), { type: "code" }];
+			return [makeText(node.value, marks)];
+		}
+		case "strong": return node.children.flatMap((c) => phrasingToInline(c, [...inheritedMarks, { type: "strong" }]));
+		case "emphasis": return node.children.flatMap((c) => phrasingToInline(c, [...inheritedMarks, { type: "em" }]));
+		case "delete": return node.children.flatMap((c) => phrasingToInline(c, [...inheritedMarks, { type: "strike" }]));
+		case "link": {
+			const linkMark = {
+				type: "link",
+				attrs: {
+					href: node.url,
+					...node.title ? { title: node.title } : {}
+				}
+			};
+			return node.children.flatMap((c) => phrasingToInline(c, [...inheritedMarks, linkMark]));
+		}
+		case "image": return [{
+			type: "inlineCard",
+			attrs: { url: node.url }
+		}];
+		case "break": return [{ type: "hardBreak" }];
+		case "html": return parseHtmlInline(node.value, inheritedMarks);
+		case "linkReference":
+		case "imageReference": return [];
+		default: return [];
+	}
+}
+function makeText(value, marks) {
+	const node = {
+		type: "text",
+		text: value
+	};
+	if (marks.length > 0) node.marks = marks;
+	return node;
+}
+function parseHtmlInline(html, inheritedMarks) {
+	const stripped = html.replace(/<[^>]+>/g, "");
+	if (stripped) return [makeText(stripped, inheritedMarks)];
+	return [];
+}
+//#endregion
+//#region src/md-to-adf/transform/blocks.ts
+function transformHeading(node) {
+	return {
+		type: "heading",
+		attrs: { level: node.depth },
+		content: phrasingToInlineNodes(node.children)
+	};
+}
+function transformParagraph(node) {
+	return {
+		type: "paragraph",
+		content: phrasingToInlineNodes(node.children)
+	};
+}
+function transformCode(node) {
+	const result = { type: "codeBlock" };
+	const lang = normalizeLanguage(node.lang);
+	if (lang) result.attrs = { language: lang };
+	if (node.value) result.content = [{
+		type: "text",
+		text: node.value
+	}];
+	return result;
+}
+function transformThematicBreak(_node) {
+	return { type: "rule" };
+}
+const ALERT_PATTERN = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*/i;
+const ALERT_TO_PANEL = {
+	NOTE: "note",
+	TIP: "info",
+	IMPORTANT: "warning",
+	WARNING: "warning",
+	CAUTION: "error"
+};
+function transformBlockquote(node, transformChildren) {
+	const firstChild = node.children[0];
+	if (firstChild?.type === "paragraph") {
+		const firstText = firstChild.children[0];
+		if (firstText?.type === "text") {
+			const match = ALERT_PATTERN.exec(firstText.value);
+			if (match) {
+				const panelType = ALERT_TO_PANEL[(match[1] ?? "NOTE").toUpperCase()] ?? "info";
+				const remainingFirstParagraphText = firstText.value.replace(ALERT_PATTERN, "").trim();
+				const remainingChildren = [...firstChild.children.slice(1)];
+				const contentNodes = [];
+				if (remainingFirstParagraphText || remainingChildren.length > 0) {
+					const newParagraph = {
+						type: "paragraph",
+						children: [...remainingFirstParagraphText ? [{
+							type: "text",
+							value: remainingFirstParagraphText
+						}] : [], ...remainingChildren]
+					};
+					if (newParagraph.children.length > 0) contentNodes.push(transformParagraph(newParagraph));
+				}
+				const restChildren = node.children.slice(1);
+				contentNodes.push(...transformChildren(restChildren));
+				if (contentNodes.length === 0) contentNodes.push({
+					type: "paragraph",
+					content: []
+				});
+				return {
+					type: "panel",
+					attrs: { panelType },
+					content: contentNodes
+				};
+			}
+		}
+	}
+	const content = transformChildren(node.children);
+	return {
+		type: "blockquote",
+		content: content.length > 0 ? content : [{
+			type: "paragraph",
+			content: []
+		}]
+	};
+}
+//#endregion
+//#region src/md-to-adf/transform/inlines.ts
+function transformHtmlBlock(node) {
+	const detailsMatch = /<details[^>]*>\s*<summary[^>]*>(.*?)<\/summary>([\s\S]*?)<\/details>/i.exec(node.value);
+	if (detailsMatch) return {
+		type: "paragraph",
+		content: [{
+			type: "text",
+			text: (detailsMatch[1] ?? "").trim()
+		}]
+	};
+	const stripped = node.value.replace(/<[^>]+>/g, "").trim();
+	if (!stripped) return null;
+	return {
+		type: "paragraph",
+		content: [{
+			type: "text",
+			text: stripped
+		}]
+	};
+}
+//#endregion
+//#region src/utils/id.ts
+function generateId() {
+	return crypto.randomUUID();
+}
+//#endregion
+//#region src/md-to-adf/transform/lists.ts
+function transformList(node, transformBlock) {
+	if (node.children.some((item) => item.checked !== null && item.checked !== void 0)) return transformTaskList(node);
+	if (node.ordered) return transformOrderedList(node, transformBlock);
+	return transformBulletList(node, transformBlock);
+}
+function transformBulletList(node, transformBlock) {
+	return {
+		type: "bulletList",
+		content: node.children.map((item) => transformListItem(item, transformBlock))
+	};
+}
+function transformOrderedList(node, transformBlock) {
+	const result = {
+		type: "orderedList",
+		content: node.children.map((item) => transformListItem(item, transformBlock))
+	};
+	if (node.start !== null && node.start !== void 0 && node.start !== 1) result.attrs = { order: node.start };
+	return result;
+}
+function transformListItem(node, transformBlock) {
+	const content = [];
+	for (const child of node.children) if (child.type === "paragraph") content.push({
+		type: "paragraph",
+		content: phrasingToInlineNodes(child.children)
+	});
+	else if (child.type === "list") {
+		const nestedList = transformList(child, transformBlock);
+		if (nestedList.type === "taskList") {
+			const para = {
+				type: "paragraph",
+				content: []
+			};
+			if (content.length === 0) content.push(para);
+		} else {
+			if (content.length === 0) content.push({
+				type: "paragraph",
+				content: []
+			});
+			content.push(nestedList);
+		}
+	} else if (child.type === "code") content.push({
+		type: "codeBlock",
+		content: [{
+			type: "text",
+			text: child.value
+		}],
+		...child.lang ? { attrs: { language: child.lang } } : {}
+	});
+	else {
+		const transformed = transformBlock(child);
+		if (transformed) {
+			if (transformed.type === "paragraph") content.push(transformed);
+		}
+	}
+	if (content.length === 0) content.push({
+		type: "paragraph",
+		content: []
+	});
+	return {
+		type: "listItem",
+		content
+	};
+}
+function transformTaskList(node) {
+	const listId = generateId();
+	const items = node.children.map((listItem) => {
+		const state = listItem.checked === true ? "DONE" : "TODO";
+		const inlineContent = listItem.children.filter((c) => c.type === "paragraph").flatMap((c) => phrasingToInlineNodes(c.children));
+		const taskItem = {
+			type: "taskItem",
+			attrs: {
+				localId: generateId(),
+				state
+			}
+		};
+		if (inlineContent.length > 0) taskItem.content = inlineContent;
+		return taskItem;
+	});
+	return {
+		type: "taskList",
+		attrs: { localId: listId },
+		content: items
+	};
+}
+//#endregion
+//#region src/md-to-adf/transform/tables.ts
+function transformTable(node) {
+	const rows = node.children;
+	if (rows.length === 0) return {
+		type: "table",
+		content: []
+	};
+	const headerRow = rows[0];
+	const bodyRows = rows.slice(1);
+	const adfRows = [];
+	if (headerRow) adfRows.push({
+		type: "tableRow",
+		content: headerRow.children.map((cell) => transformTableHeader(cell))
+	});
+	for (const row of bodyRows) adfRows.push({
+		type: "tableRow",
+		content: row.children.map((cell) => transformTableCell(cell))
+	});
+	return {
+		type: "table",
+		content: adfRows
+	};
+}
+function transformTableHeader(cell) {
+	const inlines = phrasingToInlineNodes(cell.children);
+	return {
+		type: "tableHeader",
+		attrs: {},
+		content: [{
+			type: "paragraph",
+			content: inlines.length > 0 ? inlines : []
+		}]
+	};
+}
+function transformTableCell(cell) {
+	const inlines = phrasingToInlineNodes(cell.children);
+	return {
+		type: "tableCell",
+		attrs: {},
+		content: [{
+			type: "paragraph",
+			content: inlines.length > 0 ? inlines : []
+		}]
+	};
+}
+//#endregion
+//#region src/md-to-adf/transform/index.ts
+function transformRoot(root) {
+	return {
+		version: 1,
+		type: "doc",
+		content: root.children.flatMap((node) => {
+			const result = transformBlock(node);
+			return result ? [result] : [];
+		})
+	};
+}
+function transformBlock(node) {
+	switch (node.type) {
+		case "heading": return transformHeading(node);
+		case "paragraph": return transformParagraph(node);
+		case "code": return transformCode(node);
+		case "thematicBreak": return transformThematicBreak(node);
+		case "blockquote": return transformBlockquote(node, (children) => children.flatMap((c) => {
+			const r = transformBlock(c);
+			return r ? [r] : [];
+		}));
+		case "list": return transformList(node, transformBlock);
+		case "table": return transformTable(node);
+		case "html": return transformHtmlBlock(node);
+		default: return null;
+	}
+}
+//#endregion
+//#region src/utils/sanitize.ts
+function stripNullBytes(text) {
+	return text.replace(/\0/g, "");
+}
+function normalizeNewlines(text) {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function trimTrailingWhitespace(text) {
+	return text.replace(/[^\S\n]+$/gm, "");
+}
+function collapseBlankLines(text) {
+	return text.replace(/\n{3,}/g, "\n\n");
+}
+function sanitizeMarkdown(text) {
+	return collapseBlankLines(trimTrailingWhitespace(normalizeNewlines(stripNullBytes(text))));
+}
+function sanitizeText(text) {
+	return stripNullBytes(normalizeNewlines(text));
+}
+//#endregion
+//#region src/md-to-adf/index.ts
+function mdToAdf(markdown) {
+	return transformRoot(parseMarkdown(sanitizeText(markdown)));
+}
+//#endregion
+//#region src/utils/escape.ts
+const INLINE_ESCAPE = /([\\`*_[\]~|<])/g;
+function escapeMarkdown(text) {
+	let result = text.replace(INLINE_ESCAPE, "\\$1");
+	result = result.replace(/^(#{1,6} )/m, "\\$1");
+	result = result.replace(/^([-+]) /m, "\\$1 ");
+	result = result.replace(/^> /m, "\\> ");
+	result = result.replace(/^(\d+)\./m, "$1\\.");
+	return result;
+}
+//#endregion
+//#region src/adf-to-md/serialize/marks.ts
+function applyMarks(text, marks) {
+	if (!marks || marks.length === 0) return text;
+	let result = text;
+	if (marks.some((m) => m.type === "code")) {
+		const linkMark = marks.find((m) => m.type === "link");
+		result = `\`${result}\``;
+		if (linkMark) result = `[${result}](${linkMark.attrs.href})`;
+		return result;
+	}
+	for (const mark of marks) switch (mark.type) {
+		case "strong":
+			result = `**${result}**`;
+			break;
+		case "em":
+			result = `*${result}*`;
+			break;
+		case "strike":
+			result = `~~${result}~~`;
+			break;
+		case "underline":
+			result = `<ins>${result}</ins>`;
+			break;
+		case "subsup":
+			result = mark.attrs.type === "sub" ? `<sub>${result}</sub>` : `<sup>${result}</sup>`;
+			break;
+		case "link":
+			result = `[${result}](${mark.attrs.href}${mark.attrs.title ? ` "${mark.attrs.title}"` : ""})`;
+			break;
+		case "textColor":
+		case "backgroundColor":
+		case "alignment":
+		case "indentation":
+		case "breakout":
+		case "border":
+		case "annotation":
+		case "dataConsumer":
+		case "fragment": break;
+	}
+	return result;
+}
+//#endregion
+//#region src/adf-to-md/serialize/inlines.ts
+function serializeInlineNodes(nodes) {
+	if (!nodes || nodes.length === 0) return "";
+	return nodes.map(serializeInline).join("");
+}
+function serializeInline(node) {
+	switch (node.type) {
+		case "text": return applyMarks(escapeMarkdown(node.text), node.marks);
+		case "hardBreak": return "\\\n";
+		case "mention": return node.attrs.text ?? `@${node.attrs.id}`;
+		case "emoji": return node.attrs.text ?? `:${node.attrs.shortName}:`;
+		case "date": return node.attrs.timestamp;
+		case "status": return `\`[${node.attrs.text}]\``;
+		case "inlineCard": return node.attrs.url ? `<${node.attrs.url}>` : "";
+		case "mediaInline": return "";
+		default: return "";
+	}
+}
+//#endregion
+//#region src/adf-to-md/serialize/blocks.ts
+function serializeHeading(node) {
+	return `${"#".repeat(node.attrs.level)} ${serializeInlineNodes(node.content)}`;
+}
+function serializeParagraph(node) {
+	return serializeInlineNodes(node.content);
+}
+function serializeCodeBlock(node) {
+	return `\`\`\`${node.attrs?.language ?? ""}\n${node.content?.map((t) => t.text).join("") ?? ""}\n\`\`\``;
+}
+function serializeRule(_node) {
+	return "---";
+}
+function serializeBlockquote(node, serializeBlock) {
+	return node.content.map((child) => serializeBlock(child)).join("\n\n").split("\n").map((line) => `> ${line}`).join("\n");
+}
+//#endregion
+//#region src/adf-to-md/serialize/lists.ts
+function serializeBulletList(node, depth = 0) {
+	return node.content.map((item) => serializeListItem(item, "-", depth)).join("\n");
+}
+function serializeOrderedList(node, depth = 0) {
+	const start = node.attrs?.order ?? 1;
+	return node.content.map((item, i) => serializeListItem(item, `${start + i}.`, depth)).join("\n");
+}
+function serializeTaskList(node, depth = 0) {
+	return node.content.map((item) => {
+		return `${"  ".repeat(depth)}- ${item.attrs.state === "DONE" ? "[x]" : "[ ]"} ${serializeInlineNodes(item.content)}`;
+	}).join("\n");
+}
+function serializeDecisionList(node, depth = 0) {
+	return node.content.map((item) => {
+		return `${"  ".repeat(depth)}- [x] ${serializeInlineNodes(item.content)}`;
+	}).join("\n");
+}
+function serializeListItem(node, bullet, depth) {
+	const indent = "  ".repeat(depth);
+	const parts = [];
+	for (const child of node.content) if (child.type === "paragraph") parts.push(serializeInlineNodes(child.content));
+	else if (child.type === "bulletList") parts.push("\n" + serializeBulletList(child, depth + 1));
+	else if (child.type === "orderedList") parts.push("\n" + serializeOrderedList(child, depth + 1));
+	else if (child.type === "codeBlock") {
+		const lang = child.attrs?.language ?? "";
+		const code = child.content?.map((t) => t.text).join("") ?? "";
+		parts.push(`\n\`\`\`${lang}\n${code}\n\`\`\``);
+	}
+	return `${indent}${bullet} ${parts.join("")}`;
+}
+//#endregion
+//#region src/adf-to-md/serialize/panels.ts
+const PANEL_TO_ALERT = {
+	note: "NOTE",
+	info: "TIP",
+	tip: "TIP",
+	warning: "WARNING",
+	success: "NOTE",
+	error: "CAUTION",
+	custom: "NOTE"
+};
+function serializePanel(node, serializeBlock) {
+	const alertType = PANEL_TO_ALERT[node.attrs.panelType] ?? "NOTE";
+	const contentLines = node.content.map((child) => serializeBlock(child)).join("\n\n");
+	return [`> [!${alertType}]`, ...contentLines.split("\n").map((l) => `> ${l}`)].join("\n");
+}
+function serializeExpand(node, serializeBlock) {
+	return `<details>\n<summary>${node.attrs.title ?? ""}</summary>\n\n${node.content.map((child) => serializeBlock(child)).join("\n\n")}\n</details>`;
+}
+function serializeMediaSingle(node) {
+	const media = node.content[0];
+	if (!media) return "";
+	const alt = media.attrs.alt ?? "image";
+	if (media.attrs.type === "link") {
+		const url = media.attrs.url;
+		if (url) return `![${alt}](${url})`;
+	}
+	return `[media: ${media.attrs.id}]`;
+}
+function serializeBlockCard(node) {
+	const url = node.attrs.url;
+	if (!url) return "";
+	return `[${url}](${url})`;
+}
+function serializeEmbedCard(node) {
+	return `[${node.attrs.url}](${node.attrs.url})`;
+}
+//#endregion
+//#region src/adf-to-md/serialize/tables.ts
+function serializeTable(node) {
+	const rows = node.content;
+	if (rows.length === 0) return "";
+	const firstRow = rows[0];
+	if (!firstRow) return "";
+	const isHeaderRow = firstRow.content.some((c) => c.type === "tableHeader");
+	const serializeCell = (cell) => {
+		const para = cell.content.find((c) => c.type === "paragraph");
+		if (!para) return " ";
+		return serializeInlineNodes(para.content).trim() || " ";
+	};
+	const lines = [];
+	if (isHeaderRow) {
+		const headerCells = firstRow.content.map(serializeCell);
+		lines.push(`| ${headerCells.join(" | ")} |`);
+		lines.push(`| ${headerCells.map(() => "---").join(" | ")} |`);
+		for (const row of rows.slice(1)) {
+			const cells = row.content.map(serializeCell);
+			lines.push(`| ${cells.join(" | ")} |`);
+		}
+	} else {
+		const colCount = firstRow.content.length;
+		const headerPlaceholders = Array(colCount).fill(" ");
+		lines.push(`| ${headerPlaceholders.join(" | ")} |`);
+		lines.push(`| ${headerPlaceholders.map(() => "---").join(" | ")} |`);
+		for (const row of rows) {
+			const cells = row.content.map(serializeCell);
+			lines.push(`| ${cells.join(" | ")} |`);
+		}
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/adf-to-md/serialize/index.ts
+function serializeBlock(node) {
+	switch (node.type) {
+		case "paragraph": return serializeParagraph(node);
+		case "heading": return serializeHeading(node);
+		case "codeBlock": return serializeCodeBlock(node);
+		case "rule": return serializeRule(node);
+		case "blockquote": return serializeBlockquote(node, serializeBlock);
+		case "bulletList": return serializeBulletList(node);
+		case "orderedList": return serializeOrderedList(node);
+		case "taskList": return serializeTaskList(node);
+		case "decisionList": return serializeDecisionList(node);
+		case "table": return serializeTable(node);
+		case "panel": return serializePanel(node, serializeBlock);
+		case "expand": return serializeExpand(node, serializeBlock);
+		case "nestedExpand": return serializeExpand(node, serializeBlock);
+		case "mediaSingle": return serializeMediaSingle(node);
+		case "blockCard": return serializeBlockCard(node);
+		case "embedCard": return serializeEmbedCard(node);
+		case "layoutSection": return serializeLayoutSection(node);
+		default: return "";
+	}
+}
+function serializeLayoutSection(node) {
+	return node.content.map((col) => col.content.map((child) => serializeBlock(child)).join("\n\n")).join("\n\n---\n\n");
+}
+//#endregion
+//#region src/adf-to-md/index.ts
+function adfToMd(adf) {
+	return sanitizeMarkdown(adf.content.map((node) => serializeBlock(node)).filter((p) => p.length > 0).join("\n\n"));
+}
+//#endregion
+export { adfToMd, mdToAdf };
+
+//# sourceMappingURL=index.mjs.map