@antdv-next/x-markdown 0.2.0 → 0.3.0

package/dist/XMarkdown/components/AnimationText.vue.d.ts

@@ -2,10 +2,16 @@ interface Props {
     text: string;
     fadeDuration?: number;
     easing?: string;
+    splitBy?: "chunk" | "sentence";
+    delimiters?: string[];
+    maxSentenceChars?: number;
 }
 declare const __VLS_export: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
     fadeDuration: number;
     easing: string;
+    splitBy: "chunk" | "sentence";
+    delimiters: string[];
+    maxSentenceChars: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -5,10 +5,66 @@ var AnimationText_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ de
 	props: {
 		text: {},
 		fadeDuration: { default: 200 },
-		easing: { default: "ease-in-out" }
+		easing: { default: "ease-in-out" },
+		splitBy: { default: "chunk" },
+		delimiters: { default: () => [
+			"。",
+			"！",
+			"？",
+			".",
+			"!",
+			"?",
+			"\n"
+		] },
+		maxSentenceChars: { default: 120 }
 	},
 	setup(__props) {
 		const props = __props;
+		const endsWithDelimiter = (chunk, delimiters) => chunk.length > 0 && delimiters.includes(chunk[chunk.length - 1]);
+		/**
+		* Append `newText` sentence-wise: text that continues the current (unfinished)
+		* sentence is merged into its chunk so it does not fade in separately, and a
+		* new chunk starts only after a delimiter. Text that is already on screen is
+		* never moved to another chunk, so nothing that has faded in fades in again.
+		*/
+		/** Push `text` as units of at most `maxChars`, so a long delimiter-less run
+		* still fades in piece by piece. */
+		const pushCapped = (chunks, text, maxChars) => {
+			for (let start = 0; start < text.length; start += maxChars) chunks.push(text.slice(start, start + maxChars));
+		};
+		const appendBySentence = (chunks, newText, delimiters, maxChars) => {
+			const cap = Math.max(1, maxChars);
+			const next = chunks.slice();
+			let rest = newText;
+			const last = next[next.length - 1];
+			if (next.length > 0 && !endsWithDelimiter(last, delimiters) && last.length < cap) {
+				let cut = -1;
+				for (let i = 0; i < rest.length; i++) if (delimiters.includes(rest[i])) {
+					cut = i + 1;
+					break;
+				}
+				if (cut === -1) {
+					const room = cap - last.length;
+					if (rest.length <= room) {
+						next[next.length - 1] += rest;
+						return next;
+					}
+					next[next.length - 1] += rest.slice(0, room);
+					rest = rest.slice(room);
+					pushCapped(next, rest, cap);
+					return next;
+				}
+				next[next.length - 1] += rest.slice(0, cut);
+				rest = rest.slice(cut);
+			}
+			let start = 0;
+			for (let i = 0; i < rest.length; i++) if (delimiters.includes(rest[i])) {
+				next.push(rest.slice(start, i + 1));
+				start = i + 1;
+			}
+			if (start < rest.length) pushCapped(next, rest.slice(start), cap);
+			return next;
+		};
 		const chunks = ref([]);
 		const previousText = ref("");
 		function updateChunks(nextText) {
@@ -20,7 +76,7 @@ var AnimationText_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ de
 			}
 			const delta = nextText.slice(previousText.value.length);
 			if (!delta) return;
-			chunks.value = [...chunks.value, delta];
+			chunks.value = props.splitBy === "sentence" ? appendBySentence(chunks.value, delta, props.delimiters, props.maxSentenceChars) : [...chunks.value, delta];
 			previousText.value = nextText;
 		}
 		watch(() => props.text, updateChunks, { immediate: true });

package/dist/XMarkdown/components/Section.js

@@ -0,0 +1,5 @@
+import Section_vue_vue_type_script_lang_default from "./Section.vue_vue_type_script_lang.js";
+//#region src/XMarkdown/components/Section.vue
+var Section_default = Section_vue_vue_type_script_lang_default;
+//#endregion
+export { Section_default as default };

package/dist/XMarkdown/components/Section.vue.d.ts

@@ -0,0 +1,76 @@
+import { Parser } from '../core/Parser';
+import { VueRenderer } from '../core/VueRenderer';
+/**
+ * One section of an incrementally rendered document. Vue skips re-rendering
+ * this component while its props are unchanged: while streaming, every
+ * section but the last keeps the same source string from chunk to chunk, so
+ * marked, DOMPurify, the HTML→vnode conversion and patching run only for the
+ * section that is still growing.
+ *
+ * Renders the parsed vnode directly so the DOM is exactly what rendering the
+ * whole document at once would produce.
+ */
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** Markdown source of this section */
+    content: {
+        type: StringConstructor;
+        required: true;
+    };
+    parser: {
+        type: () => Parser;
+        required: true;
+    };
+    renderer: {
+        type: () => VueRenderer;
+        required: true;
+    };
+    /** Whether the streaming tail is appended to this section (only the last one) */
+    injectTail: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Bumped when parser/renderer options change in place (the parent keeps
+     * both identities stable), so an options change still re-renders every
+     * section even though `content` is unchanged.
+     */
+    optionsVersion: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** Markdown source of this section */
+    content: {
+        type: StringConstructor;
+        required: true;
+    };
+    parser: {
+        type: () => Parser;
+        required: true;
+    };
+    renderer: {
+        type: () => VueRenderer;
+        required: true;
+    };
+    /** Whether the streaming tail is appended to this section (only the last one) */
+    injectTail: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Bumped when parser/renderer options change in place (the parent keeps
+     * both identities stable), so an options change still re-renders every
+     * section even though `content` is unchanged.
+     */
+    optionsVersion: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    injectTail: boolean;
+    optionsVersion: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/XMarkdown/components/Section.vue_vue_type_script_lang.js

@@ -0,0 +1,54 @@
+import { computed, defineComponent } from "vue";
+//#region src/XMarkdown/components/Section.vue?vue&type=script&lang.ts
+/**
+* One section of an incrementally rendered document. Vue skips re-rendering
+* this component while its props are unchanged: while streaming, every
+* section but the last keeps the same source string from chunk to chunk, so
+* marked, DOMPurify, the HTML→vnode conversion and patching run only for the
+* section that is still growing.
+*
+* Renders the parsed vnode directly so the DOM is exactly what rendering the
+* whole document at once would produce.
+*/
+var Section_vue_vue_type_script_lang_default = defineComponent({
+	name: "XMarkdownSection",
+	props: {
+		/** Markdown source of this section */
+		content: {
+			type: String,
+			required: true
+		},
+		parser: {
+			type: Object,
+			required: true
+		},
+		renderer: {
+			type: Object,
+			required: true
+		},
+		/** Whether the streaming tail is appended to this section (only the last one) */
+		injectTail: {
+			type: Boolean,
+			default: false
+		},
+		/**
+		* Bumped when parser/renderer options change in place (the parent keeps
+		* both identities stable), so an options change still re-renders every
+		* section even though `content` is unchanged.
+		*/
+		optionsVersion: {
+			type: Number,
+			default: 0
+		}
+	},
+	setup(props) {
+		const node = computed(() => {
+			props.optionsVersion;
+			const html = props.parser.parse(props.content, { injectTail: props.injectTail });
+			return props.renderer.render(html);
+		});
+		return () => node.value;
+	}
+});
+//#endregion
+export { Section_vue_vue_type_script_lang_default as default };

package/dist/XMarkdown/composables/index.d.ts

@@ -1,4 +1,5 @@
-export { useStreaming } from './useStreaming';
+export { useStreaming, useStreamingCore } from './useStreaming';
+export { useTypewriter } from './useTypewriter';
 export { useParser } from './useParser';
 export { useRenderer } from './useRenderer';
 export { useTail } from './useTail';

package/dist/XMarkdown/composables/index.js

@@ -1,5 +1,6 @@
-import { useStreaming } from "./useStreaming.js";
+import { useStreaming, useStreamingCore } from "./useStreaming.js";
+import useTypewriter from "./useTypewriter.js";
 import { useParser } from "./useParser.js";
 import { useRenderer } from "./useRenderer.js";
 import { useTail } from "./useTail.js";
-export { useParser, useRenderer, useStreaming, useTail };
+export { useParser, useRenderer, useStreaming, useStreamingCore, useTail, useTypewriter };

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

@@ -1,6 +1,42 @@
+import { Token } from 'marked';
 import { Component, Ref } from 'vue';
 import { StreamingOption } from '../interface';
-export declare function useStreaming(content: Ref<string>, streaming: Ref<StreamingOption | undefined>, components?: Ref<Record<string, Component> | undefined>): {
+/** Sections shorter than this are merged into the next one. */
+export declare const DEFAULT_MIN_SECTION_CHARS = 200;
+/**
+ * The splitter's oracle: a block-level lex of the *preprocessed* source by the
+ * renderer's own marked. Callers hand over `Parser.lex`.
+ */
+type SectionLexer = (markdown: string) => readonly Token[];
+export interface StreamingResult {
+    /** The markdown to parse: committed text plus the placeholder for the pending token */
+    output: Ref<string>;
+    /**
+     * `output` split at section boundaries when `streaming.incremental` is on
+     * and at least one boundary exists; `null` means render `output` as a whole.
+     * Joining the sections always gives back `output`.
+     */
+    sections: Ref<string[] | null>;
+    reset: () => void;
+}
+/**
+ * Streaming state machine plus, when `streaming.incremental` is on, the
+ * section boundaries the renderer can memoise on. `useStreaming` is the
+ * backwards-compatible view of this composable.
+ */
+export declare function useStreamingCore(content: Ref<string>, streaming: Ref<boolean | StreamingOption | undefined>, components: Ref<Record<string, Component> | undefined> | undefined, 
+/**
+ * Lexer used to decide section boundaries. Must be the renderer's own marked
+ * (`Parser.lex`), so `config.extensions` and the parser's preprocessing
+ * (`protectCustomTags`, `escapeRawHtml`) are honoured — a different grammar
+ * answers about a different document and yields wrong boundaries. Required
+ * rather than defaulted: a silent GFM fallback here would be wrong by
+ * construction for any configured renderer. The sections-blind
+ * `useStreaming` wrapper passes the fallback explicitly.
+ */
+lex: SectionLexer): StreamingResult;
+export declare function useStreaming(content: Ref<string>, streaming: Ref<boolean | StreamingOption | undefined>, components?: Ref<Record<string, Component> | undefined>): {
     processedContent: Ref<string, string>;
     reset: () => void;
 };
+export {};