react-native-nitro-markdown 0.7.1 → 0.8.0

package/src/use-markdown-stream.ts

@@ -21,13 +21,9 @@ export function useMarkdownSession(initialText?: string) {
     const session = sessionRef.current!;
     return () => {
       try {
-        session.clear();
+        session.dispose();
       } finally {
-        try {
-          session.dispose();
-        } finally {
-          sessionRef.current = null;
-        }
+        sessionRef.current = null;
       }
     };
   }, []);

package/src/utils/code-highlight.ts

@@ -182,7 +182,7 @@ export function defaultHighlighter(
   const lines = code.split("\n");
   const result: HighlightedToken[] = [];
   for (let i = 0; i < lines.length; i++) {
-    result.push(...tokenizeLine(lines[i], language));
+    result.push(...tokenizeLine(lines[i] ?? "", language));
     if (i < lines.length - 1) {
       result.push({ text: "\n", type: "default" });
     }

package/src/utils/incremental-ast.ts

@@ -24,7 +24,7 @@ const isInsideFencedCodeBlock = (text: string): boolean => {
     const fenceMatch = line.match(FENCE_LINE_PATTERN);
     if (!fenceMatch) continue;
 
-    const marker = fenceMatch[1];
+    const marker = fenceMatch[1] ?? "";
     const markerChar = marker[0] as "`" | "~";
     const markerLength = marker.length;
 
@@ -94,7 +94,11 @@ const findTrailingLeafPath = (
   }
 
   const lastIndex = children.length - 1;
-  return findTrailingLeafPath(children[lastIndex], [...path, lastIndex]);
+  const lastChild = children[lastIndex];
+  if (lastChild === undefined) {
+    return path;
+  }
+  return findTrailingLeafPath(lastChild, [...path, lastIndex]);
 };
 
 const getNodeAtPath = (
@@ -126,11 +130,14 @@ const appendPlainTextToAst = (
   const delta = appendedChunk.length;
   const update = (node: MarkdownNode, depth: number): MarkdownNode => {
     if (depth === path.length) {
-      return {
+      const updatedNode: MarkdownNode = {
         ...node,
         content: (node.content ?? "") + appendedChunk,
-        end: typeof node.end === "number" ? node.end + delta : node.end,
       };
+      if (typeof node.end === "number") {
+        updatedNode.end = node.end + delta;
+      }
+      return updatedNode;
     }
 
     const childIndex = path[depth];
@@ -138,11 +145,16 @@ const appendPlainTextToAst = (
       index === childIndex ? update(child, depth + 1) : child,
     );
 
-    return {
+    const updatedNode: MarkdownNode = {
       ...node,
-      end: typeof node.end === "number" ? node.end + delta : node.end,
-      children,
     };
+    if (typeof node.end === "number") {
+      updatedNode.end = node.end + delta;
+    }
+    if (children) {
+      updatedNode.children = children;
+    }
+    return updatedNode;
   };
 
   return update(ast, 0);
@@ -152,6 +164,87 @@ const endsAtBlockBoundary = (text: string): boolean => {
   return text.endsWith("\n") || text.endsWith("\r");
 };
 
+const nodesHaveMatchingMetadata = (
+  previousNode: MarkdownNode,
+  nextNode: MarkdownNode,
+): boolean => {
+  return (
+    previousNode.type === nextNode.type &&
+    previousNode.content === nextNode.content &&
+    previousNode.level === nextNode.level &&
+    previousNode.href === nextNode.href &&
+    previousNode.title === nextNode.title &&
+    previousNode.alt === nextNode.alt &&
+    previousNode.language === nextNode.language &&
+    previousNode.ordered === nextNode.ordered &&
+    previousNode.start === nextNode.start &&
+    previousNode.checked === nextNode.checked &&
+    previousNode.isHeader === nextNode.isHeader &&
+    previousNode.align === nextNode.align &&
+    previousNode.beg === nextNode.beg &&
+    previousNode.end === nextNode.end
+  );
+};
+
+export const reuseStableAstNodes = (
+  previousNode: MarkdownNode,
+  nextNode: MarkdownNode,
+): MarkdownNode => {
+  if (previousNode.type !== nextNode.type) {
+    return nextNode;
+  }
+
+  const hasMatchingMetadata = nodesHaveMatchingMetadata(previousNode, nextNode);
+  const previousChildren = previousNode.children;
+  const nextChildren = nextNode.children;
+
+  if (!previousChildren || !nextChildren) {
+    return hasMatchingMetadata && previousChildren === nextChildren
+      ? previousNode
+      : nextNode;
+  }
+
+  if (previousChildren.length !== nextChildren.length) {
+    return {
+      ...nextNode,
+      children: nextChildren.map((nextChild, index) => {
+        const previousChild = previousChildren[index];
+        return previousChild
+          ? reuseStableAstNodes(previousChild, nextChild)
+          : nextChild;
+      }),
+    };
+  }
+
+  let hasChildChange = false;
+  const children = nextChildren.map((nextChild, index) => {
+    const previousChild = previousChildren[index];
+    const child =
+      previousChild === undefined
+        ? nextChild
+        : reuseStableAstNodes(previousChild, nextChild);
+    hasChildChange ||= child !== previousChild;
+    return child;
+  });
+
+  if (hasMatchingMetadata && !hasChildChange) {
+    return previousNode;
+  }
+
+  return {
+    ...nextNode,
+    children,
+  };
+};
+
+const parseAstWithStableNodes = (
+  previousAst: MarkdownNode,
+  text: string,
+  options?: ParserOptions,
+): MarkdownNode => {
+  return reuseStableAstNodes(previousAst, parseAst(text, options));
+};
+
 export type IncrementalAstInput = {
   allowIncremental?: boolean;
   nextText: string;
@@ -168,7 +261,7 @@ export const getNextStreamAst = ({
   previousText,
 }: IncrementalAstInput): MarkdownNode => {
   if (!allowIncremental || !nextText.startsWith(previousText)) {
-    return parseAst(nextText, options);
+    return parseAstWithStableNodes(previousAst, nextText, options);
   }
 
   const appendedChunk = nextText.slice(previousText.length);
@@ -194,7 +287,7 @@ export const getNextStreamAst = ({
 
   if (!PLAIN_TEXT_APPEND_PATTERN.test(appendedChunk)) {
     if (endsAtBlockBoundary(previousText)) {
-      return parseAst(nextText, options);
+      return parseAstWithStableNodes(previousAst, nextText, options);
     }
 
     const textAppendedAst = appendPlainTextToAst(
@@ -208,12 +301,12 @@ export const getNextStreamAst = ({
   }
 
   if (insideFencedCodeBlock) {
-    return parseAst(nextText, options);
+    return parseAstWithStableNodes(previousAst, nextText, options);
   }
 
   // Correctness-first fallback: full reparse for all non-trivial appends.
   // Incremental append is only used for plain text chunks at the true trailing leaf.
-  return parseAst(nextText, options);
+  return parseAstWithStableNodes(previousAst, nextText, options);
 };
 
 export const parseMarkdownAst = (

package/src/utils/link-security.ts

@@ -26,14 +26,14 @@ const parseAbsoluteHref = (
   const protocolMatch = href.match(/^([a-z][a-z0-9+.-]*):/i);
   if (!protocolMatch) return null;
 
-  const protocol = normalizeProtocol(protocolMatch[1]);
+  const protocol = normalizeProtocol(protocolMatch[1] ?? "");
   const rest = href.slice(protocolMatch[0].length);
   const authorityMatch = rest.match(/^\/\/([^/?#]*)/);
   const rawHost = authorityMatch?.[1] ?? "";
-  const hostname = rawHost
+  const hostname = (rawHost
     .replace(/^[^@]*@/, "")
     .replace(/^\[|\]$/g, "")
-    .split(":")[0]
+    .split(":")[0] ?? "")
     .toLowerCase();
 
   return { protocol, hostname };

package/src/utils/stream-timeline.ts

@@ -19,15 +19,17 @@ export const createTimestampTimeline = (
     .map(Number)
     .filter((index) => Number.isFinite(index))
     .sort((a, b) => a - b)
-    .map((index) => ({
-      index,
-      time: timestamps[index],
-    }))
+    .flatMap((index) => {
+      const time = timestamps[index];
+      return time === undefined ? [] : [{ index, time }];
+    })
     .filter((entry) => Number.isFinite(entry.time));
 
   let monotonic = true;
   for (let i = 1; i < entries.length; i += 1) {
-    if (entries[i].time < entries[i - 1].time) {
+    const current = entries[i];
+    const previous = entries[i - 1];
+    if (current && previous && current.time < previous.time) {
       monotonic = false;
       break;
     }
@@ -59,7 +61,8 @@ export const resolveHighlightPosition = (
 
   while (left <= right) {
     const mid = (left + right) >> 1;
-    if (entries[mid].time <= currentTimeMs) {
+    const entry = entries[mid];
+    if (entry !== undefined && entry.time <= currentTimeMs) {
       resolvedIndex = mid;
       left = mid + 1;
     } else {
@@ -68,5 +71,5 @@ export const resolveHighlightPosition = (
   }
 
   if (resolvedIndex === -1) return 0;
-  return entries[resolvedIndex].index + 1;
+  return (entries[resolvedIndex]?.index ?? 0) + 1;
 };