@antdv-next/x-markdown 0.1.2 → 0.1.3

package/dist/XMarkdown/components/AnimationText.vue_vue_type_script_setup_true_lang.js

@@ -1,6 +1,6 @@
 import { Fragment, computed, createElementBlock, defineComponent, normalizeStyle, openBlock, ref, renderList, toDisplayString, watch } from "vue";
 //#region src/XMarkdown/components/AnimationText.vue?vue&type=script&setup=true&lang.ts
-var AnimationText_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+var AnimationText_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
 	__name: "AnimationText",
 	props: {
 		text: {},

package/dist/XMarkdown/components/DebugPanel.vue_vue_type_script_setup_true_lang.js

@@ -10,7 +10,7 @@ var _hoisted_4 = {
 };
 var _hoisted_5 = ["d"];
 var maxSnapshots = 60;
-var DebugPanel_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+var DebugPanel_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
 	__name: "DebugPanel",
 	props: { className: {} },
 	setup(__props) {

package/dist/XMarkdown/components/TailIndicator.vue_vue_type_script_setup_true_lang.js

@@ -1,7 +1,7 @@
 import { createElementBlock, defineComponent, openBlock, toDisplayString } from "vue";
 //#region src/XMarkdown/components/TailIndicator.vue?vue&type=script&setup=true&lang.ts
 var _hoisted_1 = { class: "xmd-tail" };
-var TailIndicator_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+var TailIndicator_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
 	__name: "TailIndicator",
 	props: { content: { default: "▋" } },
 	setup(__props) {

package/dist/XMarkdown/composables/__tests__/useStreaming.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/XMarkdown/composables/__tests__/useStreaming.test.js

@@ -0,0 +1,118 @@
+import { h as describe, m as it } from "../../../node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/@vitest/runner/chunk-artifact.js";
+import { g as globalExpect } from "../../../node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/chunks/test.CBQUpOM3.js";
+import { useStreaming } from "../useStreaming.js";
+import { effectScope, nextTick, ref } from "vue";
+//#region src/XMarkdown/composables/__tests__/useStreaming.test.ts
+/**
+* Drive `useStreaming` with streaming enabled and return the latest
+* `processedContent` value after Vue flushes.
+*/
+async function stream(chunks, opts = {}) {
+	let result = "";
+	const scope = effectScope();
+	await scope.run(async () => {
+		const content = ref("");
+		const { processedContent } = useStreaming(content, ref({ hasNextChunk: opts.hasNextChunk ?? true }));
+		await nextTick();
+		let acc = "";
+		for (const chunk of chunks) {
+			acc += chunk;
+			content.value = acc;
+			await nextTick();
+		}
+		result = processedContent.value;
+	});
+	scope.stop();
+	return result;
+}
+describe("useStreaming fence correctness", () => {
+	it("streams plain text unchanged", async () => {
+		globalExpect(await stream(["Hello", " world"])).toBe("Hello world");
+	});
+	it("opens a fence on a partial last line immediately", async () => {
+		globalExpect(await stream(["```js\nconst a = 1;\n"])).toBe("```js\nconst a = 1;\n");
+	});
+	it("keeps an unclosed fence open for streaming continuation", async () => {
+		globalExpect(await stream(["```\ncode here"])).toBe("```\ncode here");
+	});
+	it("closes a fence once its line is completed by a newline", async () => {
+		globalExpect(await stream(["```\ncode\n```\nafter"])).toBe("```\ncode\n```\nafter");
+	});
+	it("requires the same fence char to close", async () => {
+		globalExpect(await stream(["~~~\ncode\n```\nstill in fence"])).toBe("~~~\ncode\n```\nstill in fence");
+	});
+	it("requires at least the opening run length to close", async () => {
+		globalExpect(await stream(["````\ncode\n```\nstill in fence"])).toBe("````\ncode\n```\nstill in fence");
+	});
+	it("allows a longer closing fence", async () => {
+		globalExpect(await stream(["```\ncode\n````\nafter"])).toBe("```\ncode\n````\nafter");
+	});
+	it("treats a closing fence with trailing whitespace as valid", async () => {
+		globalExpect(await stream(["```\ncode\n```   \nafter"])).toBe("```\ncode\n```   \nafter");
+	});
+	it("does not treat a closing fence with non-whitespace tail as close", async () => {
+		globalExpect(await stream(["```\ncode\n```js\nstill in fence"])).toBe("```\ncode\n```js\nstill in fence");
+	});
+});
+describe("useStreaming CRLF semantics", () => {
+	it("handles CRLF fence open and close", async () => {
+		globalExpect(await stream(["```\r\ncode\r\n```\r\nafter"])).toBe("```\r\ncode\r\n```\r\nafter");
+	});
+	it("handles a trailing CR", async () => {
+		globalExpect(await stream(["```\r"])).toBe("```\r");
+	});
+});
+describe("useStreaming long single-line content (base64 images)", () => {
+	it("streams a large base64 image without quadratic slowdown", async () => {
+		const full = `Here is an image:\n\n![chart](data:image/png;base64,${"A".repeat(3e5)})\n\nDone.`;
+		const chunkSize = 1e3;
+		let result = "";
+		const scope = effectScope();
+		const start = performance.now();
+		await scope.run(async () => {
+			const content = ref("");
+			const { processedContent } = useStreaming(content, ref({ hasNextChunk: true }));
+			await nextTick();
+			let acc = "";
+			for (let end = chunkSize; end < full.length + chunkSize; end += chunkSize) {
+				acc = full.slice(0, Math.min(end, full.length));
+				content.value = acc;
+				await nextTick();
+			}
+			result = processedContent.value;
+		});
+		const elapsed = performance.now() - start;
+		scope.stop();
+		globalExpect(result).toBe(full);
+		globalExpect(elapsed).toBeLessThan(1e4);
+	}, 12e4);
+	it("keeps fence state correct when a code block follows long content", async () => {
+		const full = `![img](data:image/png;base64,${"B".repeat(2e4)})\n\n\`\`\`js\nconst a = 1;\n`;
+		let result = "";
+		const scope = effectScope();
+		await scope.run(async () => {
+			const content = ref(full.slice(0, 100));
+			const { processedContent } = useStreaming(content, ref({ hasNextChunk: true }));
+			await nextTick();
+			content.value = full;
+			await nextTick();
+			result = processedContent.value;
+		});
+		scope.stop();
+		globalExpect(result).toBe(full);
+	});
+});
+describe("useStreaming non-streaming passthrough", () => {
+	it("returns content verbatim when hasNextChunk is false", async () => {
+		let result = "";
+		const scope = effectScope();
+		await scope.run(async () => {
+			const { processedContent } = useStreaming(ref("```\ncode\n```\ntext"), ref({ hasNextChunk: false }));
+			await nextTick();
+			result = processedContent.value;
+		});
+		scope.stop();
+		globalExpect(result).toBe("```\ncode\n```\ntext");
+	});
+});
+//#endregion

package/dist/XMarkdown/composables/useStreaming.js

@@ -82,11 +82,21 @@ var recognize = (cache, tokenType) => {
 	}
 };
 var recognizeHandlers = Object.values(tokenRecognizerMap).filter((recognizer) => Boolean(recognizer));
+var getInitialFenceState = () => ({
+	inFenced: false,
+	fenceChar: "",
+	fenceLen: 0,
+	lineFenceChar: "",
+	lineFenceLen: 0,
+	lineFenceRunEnded: false,
+	lineTailBlank: true
+});
 var getInitialCache = () => ({
 	pending: "",
 	token: StreamCacheTokenType.Text,
 	processedLength: 0,
-	completeMarkdown: ""
+	completeMarkdown: "",
+	fence: getInitialFenceState()
 });
 var commitCache = (cache) => {
 	if (cache.pending) {
@@ -95,33 +105,42 @@ var commitCache = (cache) => {
 	}
 	cache.token = StreamCacheTokenType.Text;
 };
-var isInCodeBlock = (text, isFinalChunk = false) => {
-	const lines = text.split("\n");
-	let inFenced = false;
-	let fenceChar = "";
-	let fenceLen = 0;
-	for (let i = 0; i < lines.length; i++) {
-		const rawLine = lines[i];
-		const match = (rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine).match(/^(`{3,}|~{3,})(.*)$/);
-		if (!match) continue;
-		const fence = match[1];
-		const after = match[2];
-		const char = fence[0];
-		const len = fence.length;
-		if (!inFenced) {
-			inFenced = true;
-			fenceChar = char;
-			fenceLen = len;
-			continue;
-		}
-		if (char === fenceChar && len >= fenceLen && /^\s*$/.test(after) && (isFinalChunk || i < lines.length - 1)) {
-			inFenced = false;
-			fenceChar = "";
-			fenceLen = 0;
+/**
+* Incremental fenced-code-block state over the processed text, updated in O(1)
+* per character. Recomputing over the full accumulated text on every character
+* is O(N²) and freezes the page on long single-line content such as base64
+* image data URIs.
+*/
+var feedFenceState = (fence, char) => {
+	if (char === "\n") {
+		if (fence.lineFenceLen >= 3) {
+			if (!fence.inFenced) {
+				fence.inFenced = true;
+				fence.fenceChar = fence.lineFenceChar;
+				fence.fenceLen = fence.lineFenceLen;
+			} else if (fence.lineFenceChar === fence.fenceChar && fence.lineFenceLen >= fence.fenceLen && fence.lineTailBlank) {
+				fence.inFenced = false;
+				fence.fenceChar = "";
+				fence.fenceLen = 0;
+			}
 		}
+		fence.lineFenceChar = "";
+		fence.lineFenceLen = 0;
+		fence.lineFenceRunEnded = false;
+		fence.lineTailBlank = true;
+		return;
+	}
+	if (!fence.lineFenceRunEnded) if (fence.lineFenceLen === 0 && (char === "`" || char === "~")) {
+		fence.lineFenceChar = char;
+		fence.lineFenceLen = 1;
+	} else if (fence.lineFenceLen > 0 && char === fence.lineFenceChar) fence.lineFenceLen += 1;
+	else {
+		fence.lineFenceRunEnded = true;
+		fence.lineTailBlank = fence.lineTailBlank && /\s/.test(char);
 	}
-	return inFenced;
+	else fence.lineTailBlank = fence.lineTailBlank && /\s/.test(char);
 };
+var isInCodeBlock = (fence) => fence.inFenced || fence.lineFenceLen >= 3;
 var sanitizeForURIComponent = (input) => {
 	let result = "";
 	for (let i = 0; i < input.length; i++) {
@@ -173,7 +192,8 @@ function useStreaming(content, streaming, components) {
 		cache.processedLength += chunk.length;
 		for (const char of chunk) {
 			cache.pending += char;
-			if (isInCodeBlock(cache.completeMarkdown + cache.pending)) {
+			feedFenceState(cache.fence, char);
+			if (isInCodeBlock(cache.fence)) {
 				commitCache(cache);
 				continue;
 			}
@@ -200,7 +220,8 @@ function useStreaming(content, streaming, components) {
 				pending: "",
 				token: StreamCacheTokenType.Text,
 				processedLength: newContent.length,
-				completeMarkdown: newContent
+				completeMarkdown: newContent,
+				fence: getInitialFenceState()
 			};
 			return;
 		}

package/dist/XMarkdown/core/VueRenderer.js

@@ -71,7 +71,7 @@ var VueRenderer = class {
 		return h(Fragment, nodes);
 	}
 	sanitize(html) {
-		const allowedTags = [...new Set([
+		const allowedTags = [.../* @__PURE__ */ new Set([
 			...Object.keys(this.options.components),
 			"p",
 			"br",

package/dist/XMarkdown/core/detectUnclosedComponentTags.js

@@ -1,7 +1,7 @@
 //#region src/XMarkdown/core/detectUnclosedComponentTags.ts
 var WHITESPACE_REGEX = /\s/;
 var TAG_NAME_CHAR_REGEX = /[a-zA-Z0-9-]/;
-var VOID_ELEMENTS = new Set([
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
 	"area",
 	"base",
 	"br",

package/dist/XMarkdown/index.vue_vue_type_script_setup_true_lang.js

@@ -6,7 +6,7 @@ import { VueRenderer } from "./core/VueRenderer.js";
 import { useTail } from "./composables/useTail.js";
 import { computed, createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, h, normalizeClass, normalizeStyle, openBlock, ref, shallowRef, unref, watch } from "vue";
 //#region src/XMarkdown/index.vue?vue&type=script&setup=true&lang.ts
-var index_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
 	__name: "index",
 	props: {
 		content: { default: "" },

package/dist/XMarkdown/interface.d.ts

@@ -10,11 +10,24 @@ export declare enum StreamCacheTokenType {
     Table = "table",
     InlineCode = "inline-code"
 }
+export interface FenceState {
+    /** Inside an open fence, considering completed lines only */
+    inFenced: boolean;
+    fenceChar: string;
+    fenceLen: number;
+    /** Leading `` ` ``/`~` run of the current (possibly incomplete) line */
+    lineFenceChar: string;
+    lineFenceLen: number;
+    lineFenceRunEnded: boolean;
+    /** Whether every char after the leading run is whitespace (closing fences allow only whitespace) */
+    lineTailBlank: boolean;
+}
 export interface StreamCache {
     pending: string;
     token: StreamCacheTokenType;
     processedLength: number;
     completeMarkdown: string;
+    fence: FenceState;
 }
 export interface StreamingOption {
     hasNextChunk: boolean;