@incremark/core 0.0.5 → 0.1.1

package/dist/index.js

@@ -5,8 +5,21 @@ import { gfm } from 'micromark-extension-gfm';
 // src/parser/IncremarkParser.ts
 
 // src/detector/index.ts
+var RE_FENCE_START = /^(\s*)((`{3,})|(~{3,}))/;
+var RE_EMPTY_LINE = /^\s*$/;
+var RE_HEADING = /^#{1,6}\s/;
+var RE_THEMATIC_BREAK = /^(\*{3,}|-{3,}|_{3,})\s*$/;
+var RE_UNORDERED_LIST = /^(\s*)([-*+])\s/;
+var RE_ORDERED_LIST = /^(\s*)(\d{1,9})[.)]\s/;
+var RE_BLOCKQUOTE = /^\s{0,3}>/;
+var RE_HTML_BLOCK_1 = /^\s{0,3}<(script|pre|style|textarea|!--|!DOCTYPE|\?|!\[CDATA\[)/i;
+var RE_HTML_BLOCK_2 = /^\s{0,3}<\/?[a-zA-Z][a-zA-Z0-9-]*(\s|>|$)/;
+var RE_TABLE_DELIMITER = /^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?$/;
+var RE_ESCAPE_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+var fenceEndPatternCache = /* @__PURE__ */ new Map();
+var containerPatternCache = /* @__PURE__ */ new Map();
 function detectFenceStart(line) {
-  const match = line.match(/^(\s*)((`{3,})|(~{3,}))/);
+  const match = line.match(RE_FENCE_START);
   if (match) {
     const fence = match[2];
     const char = fence[0];
@@ -18,45 +31,55 @@ function detectFenceEnd(line, context) {
   if (!context.inFencedCode || !context.fenceChar || !context.fenceLength) {
     return false;
   }
-  const pattern = new RegExp(`^\\s{0,3}${context.fenceChar}{${context.fenceLength},}\\s*$`);
+  const cacheKey = `${context.fenceChar}-${context.fenceLength}`;
+  let pattern = fenceEndPatternCache.get(cacheKey);
+  if (!pattern) {
+    pattern = new RegExp(`^\\s{0,3}${context.fenceChar}{${context.fenceLength},}\\s*$`);
+    fenceEndPatternCache.set(cacheKey, pattern);
+  }
   return pattern.test(line);
 }
 function isEmptyLine(line) {
-  return /^\s*$/.test(line);
+  return RE_EMPTY_LINE.test(line);
 }
 function isHeading(line) {
-  return /^#{1,6}\s/.test(line);
+  return RE_HEADING.test(line);
 }
 function isThematicBreak(line) {
-  return /^(\*{3,}|-{3,}|_{3,})\s*$/.test(line.trim());
+  return RE_THEMATIC_BREAK.test(line.trim());
 }
 function isListItemStart(line) {
-  const unordered = line.match(/^(\s*)([-*+])\s/);
+  const unordered = line.match(RE_UNORDERED_LIST);
   if (unordered) {
     return { ordered: false, indent: unordered[1].length };
   }
-  const ordered = line.match(/^(\s*)(\d{1,9})[.)]\s/);
+  const ordered = line.match(RE_ORDERED_LIST);
   if (ordered) {
     return { ordered: true, indent: ordered[1].length };
   }
   return null;
 }
 function isBlockquoteStart(line) {
-  return /^\s{0,3}>/.test(line);
+  return RE_BLOCKQUOTE.test(line);
 }
 function isHtmlBlock(line) {
-  return /^\s{0,3}<(script|pre|style|textarea|!--|!DOCTYPE|\?|!\[CDATA\[)/i.test(line) || /^\s{0,3}<\/?[a-zA-Z][a-zA-Z0-9-]*(\s|>|$)/.test(line);
+  return RE_HTML_BLOCK_1.test(line) || RE_HTML_BLOCK_2.test(line);
 }
 function isTableDelimiter(line) {
-  return /^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?$/.test(line.trim());
+  return RE_TABLE_DELIMITER.test(line.trim());
 }
 function detectContainer(line, config) {
   const marker = config?.marker || ":";
   const minLength = config?.minMarkerLength || 3;
-  const escapedMarker = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(
-    `^(\\s*)(${escapedMarker}{${minLength},})(?:\\s+(\\w[\\w-]*))?(?:\\s+(.*))?\\s*$`
-  );
+  const cacheKey = `${marker}-${minLength}`;
+  let pattern = containerPatternCache.get(cacheKey);
+  if (!pattern) {
+    const escapedMarker = marker.replace(RE_ESCAPE_SPECIAL, "\\$&");
+    pattern = new RegExp(
+      `^(\\s*)(${escapedMarker}{${minLength},})(?:\\s+(\\w[\\w-]*))?(?:\\s+(.*))?\\s*$`
+    );
+    containerPatternCache.set(cacheKey, pattern);
+  }
   const match = line.match(pattern);
   if (!match) {
     return null;
@@ -168,7 +191,7 @@ var IncremarkParser = class {
   context;
   options;
   /** 缓存的容器配置，避免重复计算 */
-  cachedContainerConfig = null;
+  containerConfig;
   /** 上次 append 返回的 pending blocks，用于 getAst 复用 */
   lastPendingBlocks = [];
   constructor(options = {}) {
@@ -177,7 +200,7 @@ var IncremarkParser = class {
       ...options
     };
     this.context = createInitialContext();
-    this.cachedContainerConfig = this.computeContainerConfig();
+    this.containerConfig = this.computeContainerConfig();
   }
   generateBlockId() {
     return `block-${++this.blockIdCounter}`;
@@ -187,9 +210,6 @@ var IncremarkParser = class {
     if (!containers) return void 0;
     return containers === true ? {} : containers;
   }
-  getContainerConfig() {
-    return this.cachedContainerConfig ?? void 0;
-  }
   parse(text) {
     const extensions = [];
     const mdastExtensions = [];
@@ -244,13 +264,12 @@ var IncremarkParser = class {
     let stableLine = -1;
     let stableContext = this.context;
     let tempContext = { ...this.context };
-    const containerConfig = this.getContainerConfig();
     for (let i = this.pendingStartLine; i < this.lines.length; i++) {
       const line = this.lines[i];
       const wasInFencedCode = tempContext.inFencedCode;
       const wasInContainer = tempContext.inContainer;
       const wasContainerDepth = tempContext.containerDepth;
-      tempContext = updateContext(line, tempContext, containerConfig);
+      tempContext = updateContext(line, tempContext, this.containerConfig);
       if (wasInFencedCode && !tempContext.inFencedCode) {
         if (i < this.lines.length - 1) {
           stableLine = i;
@@ -271,7 +290,7 @@ var IncremarkParser = class {
       if (tempContext.inContainer) {
         continue;
       }
-      const stablePoint = this.checkStability(i, containerConfig);
+      const stablePoint = this.checkStability(i);
       if (stablePoint >= 0) {
         stableLine = stablePoint;
         stableContext = { ...tempContext };
@@ -279,7 +298,7 @@ var IncremarkParser = class {
     }
     return { line: stableLine, contextAtLine: stableContext };
   }
-  checkStability(lineIndex, containerConfig) {
+  checkStability(lineIndex) {
     if (lineIndex === 0) {
       return -1;
     }
@@ -304,10 +323,10 @@ var IncremarkParser = class {
       if (isListItemStart(line) && !isListItemStart(prevLine)) {
         return lineIndex - 1;
       }
-      if (containerConfig !== void 0) {
-        const container = detectContainer(line, containerConfig);
+      if (this.containerConfig !== void 0) {
+        const container = detectContainer(line, this.containerConfig);
         if (container && !container.isEnd) {
-          const prevContainer = detectContainer(prevLine, containerConfig);
+          const prevContainer = detectContainer(prevLine, this.containerConfig);
           if (!prevContainer || prevContainer.isEnd) {
             return lineIndex - 1;
           }
@@ -522,40 +541,105 @@ function joinLines(lines, start, end) {
 
 // src/transformer/utils.ts
 function countChars(node) {
-  let count = 0;
-  function traverse(n) {
-    if (n.value && typeof n.value === "string") {
-      count += n.value.length;
-      return;
-    }
-    if (n.children && Array.isArray(n.children)) {
-      for (const child of n.children) {
-        traverse(child);
-      }
+  return countCharsInNode(node);
+}
+function countCharsInNode(n) {
+  if (n.value && typeof n.value === "string") {
+    return n.value.length;
+  }
+  if (n.children && Array.isArray(n.children)) {
+    let count = 0;
+    for (const child of n.children) {
+      count += countCharsInNode(child);
     }
+    return count;
   }
-  traverse(node);
-  return count;
+  return 1;
 }
-function sliceAst(node, maxChars) {
+function sliceAst(node, maxChars, accumulatedChunks, skipChars = 0) {
   if (maxChars <= 0) return null;
-  let remaining = maxChars;
+  if (skipChars >= maxChars) return null;
+  let remaining = maxChars - skipChars;
+  let charIndex = 0;
+  const chunkRanges = [];
+  if (accumulatedChunks && accumulatedChunks.chunks.length > 0) {
+    let chunkStart = accumulatedChunks.stableChars;
+    for (const chunk of accumulatedChunks.chunks) {
+      chunkRanges.push({
+        start: chunkStart,
+        end: chunkStart + chunk.text.length,
+        chunk
+      });
+      chunkStart += chunk.text.length;
+    }
+  }
   function process(n) {
     if (remaining <= 0) return null;
     if (n.value && typeof n.value === "string") {
-      const take = Math.min(n.value.length, remaining);
+      const nodeStart = charIndex;
+      const nodeEnd = charIndex + n.value.length;
+      if (nodeEnd <= skipChars) {
+        charIndex = nodeEnd;
+        return null;
+      }
+      const skipInNode = Math.max(0, skipChars - nodeStart);
+      const take = Math.min(n.value.length - skipInNode, remaining);
       remaining -= take;
       if (take === 0) return null;
-      return { ...n, value: n.value.slice(0, take) };
+      const slicedValue = n.value.slice(skipInNode, skipInNode + take);
+      charIndex = nodeEnd;
+      const result = {
+        ...n,
+        value: slicedValue
+      };
+      if (chunkRanges.length > 0 && accumulatedChunks) {
+        const nodeChunks = [];
+        let firstChunkLocalStart = take;
+        for (const range of chunkRanges) {
+          const overlapStart = Math.max(range.start, nodeStart + skipInNode);
+          const overlapEnd = Math.min(range.end, nodeStart + skipInNode + take);
+          if (overlapStart < overlapEnd) {
+            const localStart = overlapStart - (nodeStart + skipInNode);
+            const localEnd = overlapEnd - (nodeStart + skipInNode);
+            const chunkText = slicedValue.slice(localStart, localEnd);
+            if (chunkText.length > 0) {
+              if (nodeChunks.length === 0) {
+                firstChunkLocalStart = localStart;
+              }
+              nodeChunks.push({
+                text: chunkText,
+                createdAt: range.chunk.createdAt
+              });
+            }
+          }
+        }
+        if (nodeChunks.length > 0) {
+          result.stableLength = firstChunkLocalStart;
+          result.chunks = nodeChunks;
+        }
+      }
+      return result;
     }
     if (n.children && Array.isArray(n.children)) {
       const newChildren = [];
+      let childCharIndex = charIndex;
       for (const child of n.children) {
         if (remaining <= 0) break;
+        const childChars = countCharsInNode(child);
+        const childStart = childCharIndex;
+        const childEnd = childCharIndex + childChars;
+        if (childEnd <= skipChars) {
+          childCharIndex = childEnd;
+          continue;
+        }
+        const savedCharIndex = charIndex;
+        charIndex = childStart;
         const processed = process(child);
+        charIndex = savedCharIndex;
         if (processed) {
           newChildren.push(processed);
         }
+        childCharIndex = childEnd;
       }
       if (newChildren.length === 0) {
         return null;
@@ -563,12 +647,84 @@ function sliceAst(node, maxChars) {
       return { ...n, children: newChildren };
     }
     remaining -= 1;
+    charIndex += 1;
     return { ...n };
   }
   return process(node);
 }
+function appendToAst(baseNode, sourceNode, startChars, endChars, accumulatedChunks) {
+  if (endChars <= startChars) {
+    return baseNode;
+  }
+  const newPart = sliceAst(sourceNode, endChars, accumulatedChunks, startChars);
+  if (!newPart) {
+    return baseNode;
+  }
+  return mergeAstNodes(baseNode, newPart);
+}
+function mergeAstNodes(baseNode, newPart) {
+  if (baseNode.type !== newPart.type) {
+    return baseNode;
+  }
+  const base = baseNode;
+  const part = newPart;
+  if (base.value && typeof base.value === "string" && part.value && typeof part.value === "string") {
+    const baseChunks = base.chunks || [];
+    const partChunks = part.chunks || [];
+    const mergedChunks = [...baseChunks, ...partChunks];
+    const mergedValue = base.value + part.value;
+    const baseStableLength = base.stableLength ?? 0;
+    const result = {
+      ...base,
+      value: mergedValue,
+      stableLength: mergedChunks.length > 0 ? baseStableLength : void 0,
+      chunks: mergedChunks.length > 0 ? mergedChunks : void 0
+    };
+    return result;
+  }
+  if (base.children && Array.isArray(base.children) && part.children && Array.isArray(part.children)) {
+    if (base.children.length > 0 && part.children.length > 0) {
+      const lastBaseChild = base.children[base.children.length - 1];
+      const firstPartChild = part.children[0];
+      if (lastBaseChild.type === firstPartChild.type) {
+        const merged = mergeAstNodes(lastBaseChild, firstPartChild);
+        return {
+          ...base,
+          children: [
+            ...base.children.slice(0, -1),
+            merged,
+            ...part.children.slice(1)
+          ]
+        };
+      }
+    }
+    return {
+      ...base,
+      children: [...base.children, ...part.children]
+    };
+  }
+  return baseNode;
+}
 function cloneNode(node) {
-  return JSON.parse(JSON.stringify(node));
+  if (typeof structuredClone === "function") {
+    return structuredClone(node);
+  }
+  return deepClone(node);
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  const cloned = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
 }
 
 // src/transformer/BlockTransformer.ts
@@ -579,7 +735,16 @@ var BlockTransformer = class {
   lastTickTime = 0;
   isRunning = false;
   isPaused = false;
+  chunks = [];
+  // 累积的 chunks（用于 fade-in 动画）
   visibilityHandler = null;
+  // ============ 性能优化：缓存机制 ============
+  /** 缓存的已截断 displayNode（稳定的部分，避免重复遍历） */
+  cachedDisplayNode = null;
+  /** 缓存的字符数（避免重复计算） */
+  cachedTotalChars = null;
+  /** 当前缓存的进度（对应 cachedDisplayNode） */
+  cachedProgress = 0;
   constructor(options = {}) {
     this.options = {
       charsPerTick: options.charsPerTick ?? 1,
@@ -614,10 +779,15 @@ var BlockTransformer = class {
     if (this.state.currentBlock) {
       const updated = blocks.find((b) => b.id === this.state.currentBlock.id);
       if (updated && updated.node !== this.state.currentBlock.node) {
+        this.clearCache();
+        const oldTotal = this.cachedTotalChars ?? this.countChars(this.state.currentBlock.node);
+        const newTotal = this.countChars(updated.node);
+        if (newTotal < oldTotal || newTotal < this.state.currentProgress) {
+          this.state.currentProgress = Math.min(this.state.currentProgress, newTotal);
+        }
         this.state.currentBlock = updated;
         if (!this.rafId && !this.isPaused) {
-          const total = this.countChars(updated.node);
-          if (this.state.currentProgress < total) {
+          if (this.state.currentProgress < newTotal) {
             this.startIfNeeded();
           }
         }
@@ -629,10 +799,11 @@ var BlockTransformer = class {
    */
   update(block) {
     if (this.state.currentBlock?.id === block.id) {
-      const oldTotal = this.countChars(this.state.currentBlock.node);
+      const oldTotal = this.cachedTotalChars ?? this.countChars(this.state.currentBlock.node);
       const newTotal = this.countChars(block.node);
       this.state.currentBlock = block;
       if (newTotal > oldTotal && !this.rafId && !this.isPaused && this.state.currentProgress >= oldTotal) {
+        this.clearCache();
         this.startIfNeeded();
       }
     }
@@ -653,6 +824,8 @@ var BlockTransformer = class {
       currentProgress: 0,
       pendingBlocks: []
     };
+    this.chunks = [];
+    this.clearCache();
     this.emit();
   }
   /**
@@ -666,6 +839,8 @@ var BlockTransformer = class {
       currentProgress: 0,
       pendingBlocks: []
     };
+    this.chunks = [];
+    this.clearCache();
     this.emit();
   }
   /**
@@ -686,6 +861,7 @@ var BlockTransformer = class {
   }
   /**
    * 获取用于渲染的 display blocks
+   * 优化：使用缓存的 displayNode，避免重复遍历已稳定的节点
    */
   getDisplayBlocks() {
     const result = [];
@@ -698,11 +874,13 @@ var BlockTransformer = class {
       });
     }
     if (this.state.currentBlock) {
-      const total = this.countChars(this.state.currentBlock.node);
-      const displayNode = this.sliceNode(this.state.currentBlock.node, this.state.currentProgress);
+      const total = this.getTotalChars();
+      if (this.state.currentProgress !== this.cachedProgress || !this.cachedDisplayNode) {
+        this.updateCachedDisplayNode();
+      }
       result.push({
         ...this.state.currentBlock,
-        displayNode: displayNode || { type: "paragraph", children: [] },
+        displayNode: this.cachedDisplayNode || { type: "paragraph", children: [] },
         progress: total > 0 ? this.state.currentProgress / total : 1,
         isDisplayComplete: false
       });
@@ -802,6 +980,7 @@ var BlockTransformer = class {
     if (!this.state.currentBlock && this.state.pendingBlocks.length > 0) {
       this.state.currentBlock = this.state.pendingBlocks.shift();
       this.state.currentProgress = 0;
+      this.clearCache();
     }
     if (this.state.currentBlock) {
       this.isRunning = true;
@@ -832,18 +1011,59 @@ var BlockTransformer = class {
       this.processNext();
       return;
     }
-    const total = this.countChars(block.node);
+    const total = this.getTotalChars();
     const step = this.getStep();
-    this.state.currentProgress = Math.min(this.state.currentProgress + step, total);
+    const prevProgress = this.state.currentProgress;
+    this.state.currentProgress = Math.min(prevProgress + step, total);
+    if (this.options.effect === "fade-in" && this.state.currentProgress > prevProgress) {
+      const newText = this.extractText(block.node, prevProgress, this.state.currentProgress);
+      if (newText.length > 0) {
+        this.chunks.push({
+          text: newText,
+          createdAt: Date.now()
+        });
+      }
+    }
     this.emit();
     if (this.state.currentProgress >= total) {
       this.notifyComplete(block.node);
       this.state.completedBlocks.push(block);
       this.state.currentBlock = null;
       this.state.currentProgress = 0;
+      this.chunks = [];
+      this.clearCache();
       this.processNext();
     }
   }
+  /**
+   * 从 AST 节点中提取指定范围的文本
+   */
+  extractText(node, start, end) {
+    let result = "";
+    let charIndex = 0;
+    function traverse(n) {
+      if (charIndex >= end) return false;
+      if (n.value && typeof n.value === "string") {
+        const nodeStart = charIndex;
+        const nodeEnd = charIndex + n.value.length;
+        charIndex = nodeEnd;
+        const overlapStart = Math.max(start, nodeStart);
+        const overlapEnd = Math.min(end, nodeEnd);
+        if (overlapStart < overlapEnd) {
+          result += n.value.slice(overlapStart - nodeStart, overlapEnd - nodeStart);
+        }
+        return charIndex < end;
+      }
+      if (n.children && Array.isArray(n.children)) {
+        for (const child of n.children) {
+          if (!traverse(child)) return false;
+        }
+      }
+      return true;
+    }
+    traverse(node);
+    return result;
+  }
   getStep() {
     const { charsPerTick } = this.options;
     if (typeof charsPerTick === "number") {
@@ -856,6 +1076,8 @@ var BlockTransformer = class {
     if (this.state.pendingBlocks.length > 0) {
       this.state.currentBlock = this.state.pendingBlocks.shift();
       this.state.currentProgress = 0;
+      this.chunks = [];
+      this.clearCache();
       this.emit();
     } else {
       this.isRunning = false;
@@ -887,7 +1109,7 @@ var BlockTransformer = class {
     }
     return countChars(node);
   }
-  sliceNode(node, chars) {
+  sliceNode(node, chars, accumulatedChunks) {
     for (const plugin of this.options.plugins) {
       if (plugin.match?.(node) && plugin.sliceNode) {
         const total = this.countChars(node);
@@ -895,7 +1117,7 @@ var BlockTransformer = class {
         if (result !== null) return result;
       }
     }
-    return sliceAst(node, chars);
+    return sliceAst(node, chars, accumulatedChunks);
   }
   notifyComplete(node) {
     for (const plugin of this.options.plugins) {
@@ -904,6 +1126,72 @@ var BlockTransformer = class {
       }
     }
   }
+  // ============ 缓存管理方法 ============
+  /**
+   * 更新缓存的 displayNode
+   * 使用真正的增量追加模式：只处理新增部分，不重复遍历已稳定的节点
+   */
+  updateCachedDisplayNode() {
+    const block = this.state.currentBlock;
+    if (!block) {
+      this.cachedDisplayNode = null;
+      this.cachedProgress = 0;
+      return;
+    }
+    const currentProgress = this.state.currentProgress;
+    if (currentProgress < this.cachedProgress) {
+      this.cachedDisplayNode = this.sliceNode(
+        block.node,
+        currentProgress,
+        this.getAccumulatedChunks()
+      );
+      this.cachedProgress = currentProgress;
+      return;
+    }
+    if (currentProgress > this.cachedProgress && this.cachedDisplayNode) {
+      this.cachedDisplayNode = appendToAst(
+        this.cachedDisplayNode,
+        block.node,
+        this.cachedProgress,
+        currentProgress,
+        this.getAccumulatedChunks()
+      );
+      this.cachedProgress = currentProgress;
+    } else if (!this.cachedDisplayNode) {
+      this.cachedDisplayNode = this.sliceNode(
+        block.node,
+        currentProgress,
+        this.getAccumulatedChunks()
+      );
+      this.cachedProgress = currentProgress;
+    }
+  }
+  /**
+   * 获取总字符数（带缓存）
+   */
+  getTotalChars() {
+    if (this.cachedTotalChars === null && this.state.currentBlock) {
+      this.cachedTotalChars = this.countChars(this.state.currentBlock.node);
+    }
+    return this.cachedTotalChars ?? 0;
+  }
+  /**
+   * 清除缓存（当 block 切换或内容更新时）
+   */
+  clearCache() {
+    this.cachedDisplayNode = null;
+    this.cachedTotalChars = null;
+    this.cachedProgress = 0;
+  }
+  /**
+   * 获取累积的 chunks（用于 fade-in 效果）
+   */
+  getAccumulatedChunks() {
+    if (this.options.effect === "fade-in" && this.chunks.length > 0) {
+      return { stableChars: 0, chunks: this.chunks };
+    }
+    return void 0;
+  }
 };
 function createBlockTransformer(options) {
   return new BlockTransformer(options);