@opentui/core 0.1.84 → 0.1.85

package/index.js

@@ -78,6 +78,7 @@ import {
   cyan,
   defaultKeyAliases,
   delegate,
+  detectLinks,
   dim,
   env,
   envRegistry,
@@ -153,7 +154,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-qr7b6cvh.js";
+} from "./index-2yz42vd4.js";
 // src/text-buffer-view.ts
 class TextBufferView {
   lib;
@@ -3115,6 +3116,7 @@ class CodeRenderable extends TextBufferRenderable {
   _hadInitialContent = false;
   _lastHighlights = [];
   _onHighlight;
+  _onChunks;
   _contentDefaultOptions = {
     content: "",
     conceal: true,
@@ -3131,6 +3133,7 @@ class CodeRenderable extends TextBufferRenderable {
     this._drawUnstyledText = options.drawUnstyledText ?? this._contentDefaultOptions.drawUnstyledText;
     this._streaming = options.streaming ?? this._contentDefaultOptions.streaming;
     this._onHighlight = options.onHighlight;
+    this._onChunks = options.onChunks;
     if (this._content.length > 0) {
       this.textBuffer.setText(this._content);
       this.updateTextInfo();
@@ -3218,9 +3221,24 @@ class CodeRenderable extends TextBufferRenderable {
       this._highlightsDirty = true;
     }
   }
+  get onChunks() {
+    return this._onChunks;
+  }
+  set onChunks(value) {
+    if (this._onChunks !== value) {
+      this._onChunks = value;
+      this._highlightsDirty = true;
+    }
+  }
   get isHighlighting() {
     return this._isHighlighting;
   }
+  async transformChunks(chunks, context) {
+    if (!this._onChunks)
+      return chunks;
+    const modified = await this._onChunks(chunks, context);
+    return modified ?? chunks;
+  }
   ensureVisibleTextBeforeHighlight() {
     if (this.isDestroyed)
       return;
@@ -3279,9 +3297,23 @@ class CodeRenderable extends TextBufferRenderable {
         if (this._streaming) {
           this._lastHighlights = highlights;
         }
-        const chunks = treeSitterToTextChunks(content, highlights, this._syntaxStyle, {
+      }
+      if (highlights.length > 0 || this._onChunks) {
+        const context = {
+          content,
+          filetype,
+          syntaxStyle: this._syntaxStyle,
+          highlights
+        };
+        let chunks = treeSitterToTextChunks(content, highlights, this._syntaxStyle, {
           enabled: this._conceal
         });
+        chunks = await this.transformChunks(chunks, context);
+        if (snapshotId !== this._highlightSnapshotId) {
+          return;
+        }
+        if (this.isDestroyed)
+          return;
         const styledText = new StyledText(chunks);
         this.textBuffer.setStyledText(styledText);
       } else {
@@ -8852,15 +8884,23 @@ function parseMarkdownIncremental(newContent, prevState, trailingUnstable = 2) {
     const newTokens = x.lex(remainingContent, { gfm: true });
     return { content: newContent, tokens: [...stableTokens, ...newTokens] };
   } catch {
-    return { content: newContent, tokens: stableTokens };
+    try {
+      const fullTokens = x.lex(newContent, { gfm: true });
+      return { content: newContent, tokens: fullTokens };
+    } catch {
+      return { content: newContent, tokens: [] };
+    }
   }
 }
 
 // src/renderables/Markdown.ts
+var TRAILING_MARKDOWN_BLOCK_BREAKS_RE = /(?:\r?\n){2,}$/;
+
 class MarkdownRenderable extends Renderable {
   _content = "";
   _syntaxStyle;
   _conceal;
+  _concealCode;
   _treeSitterClient;
   _tableOptions;
   _renderNode;
@@ -8868,9 +8908,14 @@ class MarkdownRenderable extends Renderable {
   _streaming = false;
   _blockStates = [];
   _styleDirty = false;
+  _linkifyMarkdownChunks = (chunks, context) => detectLinks(chunks, {
+    content: context.content,
+    highlights: context.highlights
+  });
   _contentDefaultOptions = {
     content: "",
     conceal: true,
+    concealCode: false,
     streaming: false
   };
   constructor(ctx, options) {
@@ -8881,6 +8926,7 @@ class MarkdownRenderable extends Renderable {
     });
     this._syntaxStyle = options.syntaxStyle;
     this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
+    this._concealCode = options.concealCode ?? this._contentDefaultOptions.concealCode;
     this._content = options.content ?? this._contentDefaultOptions.content;
     this._treeSitterClient = options.treeSitterClient;
     this._tableOptions = options.tableOptions;
@@ -8892,6 +8938,8 @@ class MarkdownRenderable extends Renderable {
     return this._content;
   }
   set content(value) {
+    if (this.isDestroyed)
+      return;
     if (this._content !== value) {
       this._content = value;
       this.updateBlocks();
@@ -8916,13 +8964,24 @@ class MarkdownRenderable extends Renderable {
       this._styleDirty = true;
     }
   }
+  get concealCode() {
+    return this._concealCode;
+  }
+  set concealCode(value) {
+    if (this._concealCode !== value) {
+      this._concealCode = value;
+      this._styleDirty = true;
+    }
+  }
   get streaming() {
     return this._streaming;
   }
   set streaming(value) {
+    if (this.isDestroyed)
+      return;
     if (this._streaming !== value) {
       this._streaming = value;
-      this.clearCache();
+      this.updateBlocks(true);
     }
   }
   get tableOptions() {
@@ -9084,92 +9143,17 @@ class MarkdownRenderable extends Renderable {
         break;
     }
   }
-  renderHeadingChunks(token) {
-    const chunks = [];
-    const group = `markup.heading.${token.depth}`;
-    const marker = "#".repeat(token.depth) + " ";
-    if (!this._conceal) {
-      chunks.push(this.createChunk(marker, group));
-    }
-    for (const child of token.tokens) {
-      this.renderInlineTokenWithStyle(child, chunks, group);
-    }
-    return chunks;
-  }
-  renderParagraphChunks(token) {
-    const chunks = [];
-    this.renderInlineContent(token.tokens, chunks);
-    return chunks;
-  }
-  renderBlockquoteChunks(token) {
-    const chunks = [];
-    for (const child of token.tokens) {
-      chunks.push(this.createChunk("> ", "punctuation.special"));
-      const childChunks = this.renderTokenToChunks(child);
-      chunks.push(...childChunks);
-      chunks.push(this.createDefaultChunk(`
-`));
-    }
-    return chunks;
-  }
-  renderListChunks(token) {
-    const chunks = [];
-    let index = typeof token.start === "number" ? token.start : 1;
-    for (const item of token.items) {
-      if (token.ordered) {
-        chunks.push(this.createChunk(`${index}. `, "markup.list"));
-        index++;
-      } else {
-        chunks.push(this.createChunk("- ", "markup.list"));
-      }
-      for (let i = 0;i < item.tokens.length; i++) {
-        const child = item.tokens[i];
-        if (child.type === "text" && i === 0 && "tokens" in child && child.tokens) {
-          this.renderInlineContent(child.tokens, chunks);
-          chunks.push(this.createDefaultChunk(`
-`));
-        } else if (child.type === "paragraph" && i === 0) {
-          this.renderInlineContent(child.tokens, chunks);
-          chunks.push(this.createDefaultChunk(`
-`));
-        } else {
-          const childChunks = this.renderTokenToChunks(child);
-          chunks.push(...childChunks);
-          chunks.push(this.createDefaultChunk(`
-`));
-        }
-      }
-    }
-    return chunks;
-  }
-  renderThematicBreakChunks() {
-    return [this.createChunk("---", "punctuation.special")];
-  }
-  renderTokenToChunks(token) {
-    switch (token.type) {
-      case "heading":
-        return this.renderHeadingChunks(token);
-      case "paragraph":
-        return this.renderParagraphChunks(token);
-      case "blockquote":
-        return this.renderBlockquoteChunks(token);
-      case "list":
-        return this.renderListChunks(token);
-      case "hr":
-        return this.renderThematicBreakChunks();
-      case "space":
-        return [];
-      default:
-        if ("raw" in token && token.raw) {
-          return [this.createDefaultChunk(token.raw)];
-        }
-        return [];
-    }
-  }
-  createTextRenderable(chunks, id, marginBottom = 0) {
-    return new TextRenderable(this.ctx, {
+  createMarkdownCodeRenderable(content, id, marginBottom = 0) {
+    return new CodeRenderable(this.ctx, {
       id,
-      content: new StyledText(chunks),
+      content,
+      filetype: "markdown",
+      syntaxStyle: this._syntaxStyle,
+      conceal: this._conceal,
+      drawUnstyledText: false,
+      streaming: true,
+      onChunks: this._linkifyMarkdownChunks,
+      treeSitterClient: this._treeSitterClient,
       width: "100%",
       marginBottom
     });
@@ -9180,14 +9164,95 @@ class MarkdownRenderable extends Renderable {
       content: token.text,
       filetype: token.lang || undefined,
       syntaxStyle: this._syntaxStyle,
-      conceal: this._conceal,
+      conceal: this._concealCode,
+      drawUnstyledText: !(this._streaming && this._concealCode),
+      streaming: this._streaming,
       treeSitterClient: this._treeSitterClient,
       width: "100%",
       marginBottom
     });
   }
+  applyMarkdownCodeRenderable(renderable, content, marginBottom) {
+    renderable.content = content;
+    renderable.filetype = "markdown";
+    renderable.syntaxStyle = this._syntaxStyle;
+    renderable.conceal = this._conceal;
+    renderable.drawUnstyledText = false;
+    renderable.streaming = true;
+    renderable.marginBottom = marginBottom;
+  }
+  applyCodeBlockRenderable(renderable, token, marginBottom) {
+    renderable.content = token.text;
+    renderable.filetype = token.lang || undefined;
+    renderable.syntaxStyle = this._syntaxStyle;
+    renderable.conceal = this._concealCode;
+    renderable.drawUnstyledText = !(this._streaming && this._concealCode);
+    renderable.streaming = this._streaming;
+    renderable.marginBottom = marginBottom;
+  }
+  shouldRenderSeparately(token) {
+    return token.type === "code" || token.type === "table" || token.type === "blockquote";
+  }
+  getInterBlockMargin(token, hasNextToken) {
+    if (!hasNextToken)
+      return 0;
+    return this.shouldRenderSeparately(token) ? 1 : 0;
+  }
+  createMarkdownBlockToken(raw) {
+    return {
+      type: "paragraph",
+      raw,
+      text: raw,
+      tokens: []
+    };
+  }
+  normalizeMarkdownBlockRaw(raw) {
+    return raw.replace(TRAILING_MARKDOWN_BLOCK_BREAKS_RE, `
+`);
+  }
+  buildRenderableTokens(tokens) {
+    if (this._renderNode) {
+      return tokens.filter((token) => token.type !== "space");
+    }
+    const renderTokens = [];
+    let markdownRaw = "";
+    const flushMarkdownRaw = () => {
+      if (markdownRaw.length === 0)
+        return;
+      const normalizedRaw = this.normalizeMarkdownBlockRaw(markdownRaw);
+      if (normalizedRaw.length > 0) {
+        renderTokens.push(this.createMarkdownBlockToken(normalizedRaw));
+      }
+      markdownRaw = "";
+    };
+    for (let i = 0;i < tokens.length; i += 1) {
+      const token = tokens[i];
+      if (token.type === "space") {
+        if (markdownRaw.length === 0) {
+          continue;
+        }
+        let nextIndex = i + 1;
+        while (nextIndex < tokens.length && tokens[nextIndex].type === "space") {
+          nextIndex += 1;
+        }
+        const nextToken = tokens[nextIndex];
+        if (nextToken && !this.shouldRenderSeparately(nextToken)) {
+          markdownRaw += token.raw;
+        }
+        continue;
+      }
+      if (this.shouldRenderSeparately(token)) {
+        flushMarkdownRaw();
+        renderTokens.push(token);
+        continue;
+      }
+      markdownRaw += token.raw;
+    }
+    flushMarkdownRaw();
+    return renderTokens;
+  }
   getTableRowsToRender(table) {
-    return this._streaming && table.rows.length > 0 ? table.rows.slice(0, -1) : table.rows;
+    return table.rows;
   }
   hashString(value, seed) {
     let hash = seed >>> 0;
@@ -9370,7 +9435,7 @@ class MarkdownRenderable extends Renderable {
     const { cache } = this.buildTableContentCache(table, previousCache, forceRegenerate);
     if (!cache) {
       return {
-        renderable: this.createTextRenderable([this.createDefaultChunk(table.raw)], id, marginBottom)
+        renderable: this.createMarkdownCodeRenderable(table.raw, id, marginBottom)
       };
     }
     return {
@@ -9380,7 +9445,7 @@ class MarkdownRenderable extends Renderable {
   }
   createDefaultRenderable(token, index, hasNextToken = false) {
     const id = `${this.id}-block-${index}`;
-    const marginBottom = hasNextToken ? 1 : 0;
+    const marginBottom = this.getInterBlockMargin(token, hasNextToken);
     if (token.type === "code") {
       return this.createCodeRenderable(token, id, marginBottom);
     }
@@ -9390,39 +9455,28 @@ class MarkdownRenderable extends Renderable {
     if (token.type === "space") {
       return null;
     }
-    const chunks = this.renderTokenToChunks(token);
-    if (chunks.length === 0) {
+    if (!token.raw) {
       return null;
     }
-    return this.createTextRenderable(chunks, id, marginBottom);
+    return this.createMarkdownCodeRenderable(token.raw, id, marginBottom);
   }
   updateBlockRenderable(state, token, index, hasNextToken) {
-    const marginBottom = hasNextToken ? 1 : 0;
+    const marginBottom = this.getInterBlockMargin(token, hasNextToken);
     if (token.type === "code") {
-      const codeRenderable = state.renderable;
-      const codeToken = token;
-      codeRenderable.content = codeToken.text;
-      if (codeToken.lang) {
-        codeRenderable.filetype = codeToken.lang;
-      }
-      codeRenderable.marginBottom = marginBottom;
+      this.applyCodeBlockRenderable(state.renderable, token, marginBottom);
       return;
     }
     if (token.type === "table") {
       const tableToken = token;
       const { cache, changed } = this.buildTableContentCache(tableToken, state.tableContentCache);
       if (!cache) {
-        const fallbackChunks = [this.createDefaultChunk(tableToken.raw)];
-        if (state.renderable instanceof TextRenderable) {
-          if (state.tokenRaw !== tableToken.raw) {
-            state.renderable.content = new StyledText(fallbackChunks);
-          }
-          state.renderable.marginBottom = marginBottom;
+        if (state.renderable instanceof CodeRenderable) {
+          this.applyMarkdownCodeRenderable(state.renderable, tableToken.raw, marginBottom);
           state.tableContentCache = undefined;
           return;
         }
         state.renderable.destroyRecursively();
-        const fallbackRenderable = this.createTextRenderable(fallbackChunks, `${this.id}-block-${index}`, marginBottom);
+        const fallbackRenderable = this.createMarkdownCodeRenderable(tableToken.raw, `${this.id}-block-${index}`, marginBottom);
         this.add(fallbackRenderable);
         state.renderable = fallbackRenderable;
         state.tableContentCache = undefined;
@@ -9444,12 +9498,18 @@ class MarkdownRenderable extends Renderable {
       state.tableContentCache = cache;
       return;
     }
-    const textRenderable = state.renderable;
-    const chunks = this.renderTokenToChunks(token);
-    textRenderable.content = new StyledText(chunks);
-    textRenderable.marginBottom = marginBottom;
+    if (state.renderable instanceof CodeRenderable) {
+      this.applyMarkdownCodeRenderable(state.renderable, token.raw, marginBottom);
+      return;
+    }
+    state.renderable.destroyRecursively();
+    const markdownRenderable = this.createMarkdownCodeRenderable(token.raw, `${this.id}-block-${index}`, marginBottom);
+    this.add(markdownRenderable);
+    state.renderable = markdownRenderable;
   }
-  updateBlocks() {
+  updateBlocks(forceTableRefresh = false) {
+    if (this.isDestroyed)
+      return;
     if (!this._content) {
       this.clearBlockStates();
       this._parseState = null;
@@ -9460,35 +9520,39 @@ class MarkdownRenderable extends Renderable {
     const tokens = this._parseState.tokens;
     if (tokens.length === 0 && this._content.length > 0) {
       this.clearBlockStates();
-      const text = this.createTextRenderable([this.createDefaultChunk(this._content)], `${this.id}-fallback`);
-      this.add(text);
+      const fallback = this.createMarkdownCodeRenderable(this._content, `${this.id}-fallback`);
+      this.add(fallback);
       this._blockStates = [
         {
           token: { type: "text", raw: this._content, text: this._content },
           tokenRaw: this._content,
-          renderable: text
+          renderable: fallback
         }
       ];
       return;
     }
-    const blockTokens = [];
-    for (let i = 0;i < tokens.length; i++) {
-      if (tokens[i].type !== "space") {
-        blockTokens.push({ token: tokens[i], originalIndex: i });
-      }
-    }
+    const blockTokens = this.buildRenderableTokens(tokens);
     const lastBlockIndex = blockTokens.length - 1;
     let blockIndex = 0;
     for (let i = 0;i < blockTokens.length; i++) {
-      const { token } = blockTokens[i];
+      const token = blockTokens[i];
       const hasNextToken = i < lastBlockIndex;
       const existing = this._blockStates[blockIndex];
+      const shouldForceRefresh = forceTableRefresh;
       if (existing && existing.token === token) {
+        if (shouldForceRefresh) {
+          this.updateBlockRenderable(existing, token, blockIndex, hasNextToken);
+          existing.tokenRaw = token.raw;
+        }
         blockIndex++;
         continue;
       }
       if (existing && existing.tokenRaw === token.raw && existing.token.type === token.type) {
         existing.token = token;
+        if (shouldForceRefresh) {
+          this.updateBlockRenderable(existing, token, blockIndex, hasNextToken);
+          existing.tokenRaw = token.raw;
+        }
         blockIndex++;
         continue;
       }
@@ -9508,6 +9572,7 @@ class MarkdownRenderable extends Renderable {
         const context = {
           syntaxStyle: this._syntaxStyle,
           conceal: this._conceal,
+          concealCode: this._concealCode,
           treeSitterClient: this._treeSitterClient,
           defaultRender: () => this.createDefaultRenderable(token, blockIndex, hasNextToken)
         };
@@ -9518,7 +9583,7 @@ class MarkdownRenderable extends Renderable {
       }
       if (!renderable) {
         if (token.type === "table") {
-          const tableBlock = this.createTableBlock(token, `${this.id}-block-${blockIndex}`, hasNextToken ? 1 : 0);
+          const tableBlock = this.createTableBlock(token, `${this.id}-block-${blockIndex}`, this.getInterBlockMargin(token, hasNextToken));
           renderable = tableBlock.renderable;
           tableContentCache = tableBlock.tableContentCache;
         } else {
@@ -9555,44 +9620,48 @@ class MarkdownRenderable extends Renderable {
     for (let i = 0;i < this._blockStates.length; i++) {
       const state = this._blockStates[i];
       const hasNextToken = i < this._blockStates.length - 1;
+      const marginBottom = this.getInterBlockMargin(state.token, hasNextToken);
       if (state.token.type === "code") {
-        const codeRenderable = state.renderable;
-        codeRenderable.syntaxStyle = this._syntaxStyle;
-        codeRenderable.conceal = this._conceal;
-      } else if (state.token.type === "table") {
+        this.applyCodeBlockRenderable(state.renderable, state.token, marginBottom);
+        continue;
+      }
+      if (state.token.type === "table") {
         const tableToken = state.token;
-        const marginBottom = hasNextToken ? 1 : 0;
         const { cache } = this.buildTableContentCache(tableToken, state.tableContentCache, true);
         if (!cache) {
-          if (state.renderable instanceof TextRenderable) {
-            state.renderable.content = new StyledText([this.createDefaultChunk(tableToken.raw)]);
-            state.renderable.marginBottom = marginBottom;
+          if (state.renderable instanceof CodeRenderable) {
+            this.applyMarkdownCodeRenderable(state.renderable, tableToken.raw, marginBottom);
           } else {
             state.renderable.destroyRecursively();
-            const fallbackRenderable = this.createTextRenderable([this.createDefaultChunk(tableToken.raw)], `${this.id}-block-${i}`, marginBottom);
+            const fallbackRenderable = this.createMarkdownCodeRenderable(tableToken.raw, `${this.id}-block-${i}`, marginBottom);
             this.add(fallbackRenderable);
             state.renderable = fallbackRenderable;
           }
           state.tableContentCache = undefined;
-        } else if (state.renderable instanceof TextTableRenderable) {
+          continue;
+        }
+        if (state.renderable instanceof TextTableRenderable) {
           state.renderable.content = cache.content;
           this.applyTableRenderableOptions(state.renderable, this.resolveTableRenderableOptions());
           state.renderable.marginBottom = marginBottom;
           state.tableContentCache = cache;
-        } else {
-          state.renderable.destroyRecursively();
-          const tableRenderable = this.createTextTableRenderable(cache.content, `${this.id}-block-${i}`, marginBottom);
-          this.add(tableRenderable);
-          state.renderable = tableRenderable;
-          state.tableContentCache = cache;
-        }
-      } else {
-        const textRenderable = state.renderable;
-        const chunks = this.renderTokenToChunks(state.token);
-        if (chunks.length > 0) {
-          textRenderable.content = new StyledText(chunks);
+          continue;
         }
+        state.renderable.destroyRecursively();
+        const tableRenderable = this.createTextTableRenderable(cache.content, `${this.id}-block-${i}`, marginBottom);
+        this.add(tableRenderable);
+        state.renderable = tableRenderable;
+        state.tableContentCache = cache;
+        continue;
       }
+      if (state.renderable instanceof CodeRenderable) {
+        this.applyMarkdownCodeRenderable(state.renderable, state.token.raw, marginBottom);
+        continue;
+      }
+      state.renderable.destroyRecursively();
+      const markdownRenderable = this.createMarkdownCodeRenderable(state.token.raw, `${this.id}-block-${i}`, marginBottom);
+      this.add(markdownRenderable);
+      state.renderable = markdownRenderable;
     }
   }
   clearCache() {
@@ -11634,6 +11703,7 @@ export {
   env,
   engine,
   dim,
+  detectLinks,
   delegate,
   cyan,
   createTimeline,
@@ -11763,5 +11833,5 @@ export {
   ASCIIFont
 };
 
-//# debugId=3C6B494E292F6AEE64756E2164756E21
+//# debugId=D4980C658617B6F964756E2164756E21
 //# sourceMappingURL=index.js.map