@byteatatime/mdstream 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byteatatime/mdstream",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "module": "src/index.ts",
   "types": "src/index.ts",
   "type": "module",

package/src/index.ts

@@ -3,6 +3,28 @@ import remarkParse from "remark-parse";
 import type { Node, Root } from "mdast";
 import type { PluggableList } from "unified";
 
+/**
+ * A function that fixes up incomplete markdown syntax so it renders correctly.
+ * Applied only to the pending (active) block — finalized blocks are never mended.
+ *
+ * The `remend` package is the recommended choice:
+ *
+ * @example
+ * ```ts
+ * import remend from "remend";
+ * const parser = createStreamingParser({ mend: remend });
+ * ```
+ *
+ * @example With options:
+ * ```ts
+ * import remend from "remend";
+ * const parser = createStreamingParser({
+ *   mend: (source) => remend(source, { links: false }),
+ * });
+ * ```
+ */
+type MendFunction = (source: string) => string;
+
 type Block = {
   readonly ast: Node;
   readonly start: number;
@@ -18,10 +40,21 @@ type ParserState = {
 
 type ParserOptions = {
   plugins?: PluggableList;
+  /**
+   * A mending function that fixes incomplete markdown syntax in the active block.
+   * Only applied to the pending block — finalized blocks are never touched.
+   *
+   * The `remend` package is the recommended mending function:
+   * ```ts
+   * import remend from "remend";
+   * const parser = createStreamingParser({ mend: remend });
+   * ```
+   */
+  mend?: MendFunction;
 };
 
 const createStreamingParser = (options: ParserOptions = {}) => {
-  const { plugins = [] } = options;
+  const { plugins = [], mend } = options;
   const state: ParserState = {
     buffer: "",
     finalizedBlocks: [],
@@ -60,10 +93,12 @@ const createStreamingParser = (options: ParserOptions = {}) => {
       const secondToLastPosition = secondToLastNode?.position;
       const lastPosition = lastNode?.position;
 
-      if (secondToLastNode?.type === "paragraph" && 
-          secondToLastPosition && 
-          lastPosition &&
-          secondToLastPosition.end.offset === lastPosition.start.offset) {
+      if (
+        secondToLastNode?.type === "paragraph" &&
+        secondToLastPosition &&
+        lastPosition &&
+        secondToLastPosition.end.offset === lastPosition.start.offset
+      ) {
         finalizableNodes = finalizableNodes.slice(0, -1);
       }
     }
@@ -101,7 +136,9 @@ const createStreamingParser = (options: ParserOptions = {}) => {
   const getPendingBlock = (): Block | undefined => {
     if (!state.buffer) return undefined;
 
-    const ast = processor.parse(state.buffer) as Root;
+    const mendedBuffer = mend ? mend(state.buffer) : state.buffer;
+
+    const ast = processor.parse(mendedBuffer) as Root;
     const tree = processor.runSync(ast) as Root;
     const children = tree.children;
 
@@ -113,13 +150,14 @@ const createStreamingParser = (options: ParserOptions = {}) => {
     if (!firstNode || !position) return undefined;
 
     const start = state.totalOffset + position.start.offset!;
-    const end = state.totalOffset + position.end.offset!;
+    // end offset is relative to the original (unmended) buffer length
+    const end = state.totalOffset + state.buffer.length;
 
     return {
       ast: firstNode,
       start,
       end,
-      source: state.buffer.slice(position.start.offset!, position.end.offset!),
+      source: mendedBuffer.slice(position.start.offset!, position.end.offset!),
     };
   };
 
@@ -135,4 +173,4 @@ const createStreamingParser = (options: ParserOptions = {}) => {
 };
 
 export { createStreamingParser };
-export type { Block, ParserOptions };
+export type { Block, ParserOptions, MendFunction };