@opentui/core 0.1.30 → 0.1.32

package/parser.worker.js

@@ -144,6 +144,7 @@ class ParserWorker {
   initializePromise;
   performance;
   dataPath;
+  tsDataPath;
   initialized = false;
   constructor() {
     this.performance = {
@@ -153,11 +154,11 @@ class ParserWorker {
       queryTimes: []
     };
   }
-  async fetchHighlightQueries(sources, filetype) {
-    if (!this.dataPath) {
+  async fetchQueries(sources, filetype) {
+    if (!this.tsDataPath) {
       return "";
     }
-    return DownloadUtils.fetchHighlightQueries(sources, this.dataPath, filetype);
+    return DownloadUtils.fetchHighlightQueries(sources, this.tsDataPath, filetype);
   }
   async initialize({ dataPath }) {
     if (this.initializePromise) {
@@ -165,10 +166,11 @@ class ParserWorker {
     }
     this.initializePromise = new Promise(async (resolve, reject) => {
       this.dataPath = dataPath;
+      this.tsDataPath = path2.join(dataPath, "tree-sitter");
       try {
-        await mkdir2(path2.join(dataPath, "languages"), { recursive: true });
-        await mkdir2(path2.join(dataPath, "queries"), { recursive: true });
-        let { default: treeWasm } = await import("web-tree-sitter/web-tree-sitter.wasm", {
+        await mkdir2(path2.join(this.tsDataPath, "languages"), { recursive: true });
+        await mkdir2(path2.join(this.tsDataPath, "queries"), { recursive: true });
+        let { default: treeWasm } = await import("web-tree-sitter/tree-sitter.wasm", {
           with: { type: "wasm" }
         });
         if (/\$bunfs/.test(treeWasm)) {
@@ -192,25 +194,33 @@ class ParserWorker {
   }
   async createQueries(filetypeParser, language) {
     try {
-      const highlightQueryContent = await this.fetchHighlightQueries(filetypeParser.queries.highlights, filetypeParser.filetype);
+      const highlightQueryContent = await this.fetchQueries(filetypeParser.queries.highlights, filetypeParser.filetype);
       if (!highlightQueryContent) {
         console.error("Failed to fetch highlight queries for:", filetypeParser.filetype);
         return;
       }
-      const query = new Query(language, highlightQueryContent);
-      return {
-        highlights: query
+      const highlightsQuery = new Query(language, highlightQueryContent);
+      const result = {
+        highlights: highlightsQuery
       };
+      if (filetypeParser.queries.injections && filetypeParser.queries.injections.length > 0) {
+        const injectionQueryContent = await this.fetchQueries(filetypeParser.queries.injections, filetypeParser.filetype);
+        if (injectionQueryContent) {
+          result.injections = new Query(language, injectionQueryContent);
+        }
+      }
+      return result;
     } catch (error) {
+      console.error("Error creating queries for", filetypeParser.filetype, filetypeParser.queries);
       console.error(error);
       return;
     }
   }
   async loadLanguage(languageSource) {
-    if (!this.initialized || !this.dataPath) {
+    if (!this.initialized || !this.tsDataPath) {
       return;
     }
-    const result = await DownloadUtils.downloadOrLoad(languageSource, this.dataPath, "languages", ".wasm", false);
+    const result = await DownloadUtils.downloadOrLoad(languageSource, this.tsDataPath, "languages", ".wasm", false);
     if (result.error) {
       console.error(`Error loading language ${languageSource}:`, result.error);
       return;
@@ -297,7 +307,8 @@ class ParserWorker {
     parser.setLanguage(filetypeParser.language);
     const reusableState = {
       parser,
-      filetypeParser
+      filetypeParser,
+      queries: filetypeParser.queries
     };
     return reusableState;
   }
@@ -326,7 +337,14 @@ class ParserWorker {
       });
       return;
     }
-    const parserState = { parser, tree, queries: filetypeParser.queries };
+    const parserState = {
+      parser,
+      tree,
+      queries: filetypeParser.queries,
+      filetype,
+      content,
+      injectionMapping: filetypeParser.injectionMapping
+    };
     this.bufferParsers.set(bufferId, parserState);
     self.postMessage({
       type: "PARSER_INIT_RESPONSE",
@@ -334,7 +352,7 @@ class ParserWorker {
       messageId,
       hasParser: true
     });
-    const highlights = this.initialQuery(parserState);
+    const highlights = await this.initialQuery(parserState);
     self.postMessage({
       type: "HIGHLIGHT_RESPONSE",
       bufferId,
@@ -342,10 +360,111 @@ class ParserWorker {
       ...highlights
     });
   }
-  initialQuery(parserState) {
+  async initialQuery(parserState) {
     const query = parserState.queries.highlights;
     const matches = query.captures(parserState.tree.rootNode);
-    return this.getHighlights(parserState, matches);
+    let injectionRanges = new Map;
+    if (parserState.queries.injections) {
+      const injectionResult = await this.processInjections(parserState);
+      matches.push(...injectionResult.captures);
+      injectionRanges = injectionResult.injectionRanges;
+    }
+    return this.getHighlights(parserState, matches, injectionRanges);
+  }
+  getNodeText(node, content) {
+    return content.substring(node.startIndex, node.endIndex);
+  }
+  async processInjections(parserState) {
+    const injectionMatches = [];
+    const injectionRanges = new Map;
+    if (!parserState.queries.injections) {
+      return { captures: injectionMatches, injectionRanges };
+    }
+    const content = parserState.content;
+    const injectionCaptures = parserState.queries.injections.captures(parserState.tree.rootNode);
+    const languageGroups = new Map;
+    const injectionMapping = parserState.injectionMapping;
+    for (const capture of injectionCaptures) {
+      const captureName = capture.name;
+      if (captureName === "injection.content" || captureName.includes("injection")) {
+        const nodeType = capture.node.type;
+        let targetLanguage;
+        if (injectionMapping?.nodeTypes && injectionMapping.nodeTypes[nodeType]) {
+          targetLanguage = injectionMapping.nodeTypes[nodeType];
+        } else if (nodeType === "code_fence_content") {
+          const parent = capture.node.parent;
+          if (parent) {
+            const infoString = parent.children.find((child) => child.type === "info_string");
+            if (infoString) {
+              const languageNode = infoString.children.find((child) => child.type === "language");
+              if (languageNode) {
+                const languageName = this.getNodeText(languageNode, content);
+                if (injectionMapping?.infoStringMap && injectionMapping.infoStringMap[languageName]) {
+                  targetLanguage = injectionMapping.infoStringMap[languageName];
+                } else {
+                  targetLanguage = languageName;
+                }
+              }
+            }
+          }
+        }
+        if (targetLanguage) {
+          if (!languageGroups.has(targetLanguage)) {
+            languageGroups.set(targetLanguage, []);
+          }
+          languageGroups.get(targetLanguage).push({ node: capture.node, name: capture.name });
+        }
+      }
+    }
+    for (const [language, captures] of languageGroups.entries()) {
+      const injectedParser = await this.getReusableParser(language);
+      if (!injectedParser) {
+        console.warn(`No parser found for injection language: ${language}`);
+        continue;
+      }
+      if (!injectionRanges.has(language)) {
+        injectionRanges.set(language, []);
+      }
+      const parser = injectedParser.parser;
+      for (const { node: injectionNode } of captures) {
+        try {
+          injectionRanges.get(language).push({
+            start: injectionNode.startIndex,
+            end: injectionNode.endIndex
+          });
+          const injectionContent = this.getNodeText(injectionNode, content);
+          const tree = parser.parse(injectionContent);
+          if (tree) {
+            const matches = injectedParser.queries.highlights.captures(tree.rootNode);
+            for (const match of matches) {
+              const offsetCapture = {
+                name: match.name,
+                patternIndex: match.patternIndex,
+                _injectedQuery: injectedParser.queries.highlights,
+                node: {
+                  ...match.node,
+                  startPosition: {
+                    row: match.node.startPosition.row + injectionNode.startPosition.row,
+                    column: match.node.startPosition.row === 0 ? match.node.startPosition.column + injectionNode.startPosition.column : match.node.startPosition.column
+                  },
+                  endPosition: {
+                    row: match.node.endPosition.row + injectionNode.startPosition.row,
+                    column: match.node.endPosition.row === 0 ? match.node.endPosition.column + injectionNode.startPosition.column : match.node.endPosition.column
+                  },
+                  startIndex: match.node.startIndex + injectionNode.startIndex,
+                  endIndex: match.node.endIndex + injectionNode.startIndex
+                }
+              };
+              injectionMatches.push(offsetCapture);
+            }
+            tree.delete();
+          }
+        } catch (error) {
+          console.error(`Error processing injection for language ${language}:`, error);
+        }
+      }
+    }
+    return { captures: injectionMatches, injectionRanges };
   }
   editToRange(edit) {
     return {
@@ -366,6 +485,7 @@ class ParserWorker {
     if (!parserState) {
       return { warning: "No parser state found for buffer" };
     }
+    parserState.content = content;
     for (const edit of edits) {
       parserState.tree.edit(edit);
     }
@@ -413,6 +533,12 @@ class ParserWorker {
       const nodeCaptures = parserState.queries.highlights.captures(node);
       matches.push(...nodeCaptures);
     }
+    let injectionRanges = new Map;
+    if (parserState.queries.injections) {
+      const injectionResult = await this.processInjections(parserState);
+      matches.push(...injectionResult.captures);
+      injectionRanges = injectionResult.injectionRanges;
+    }
     const endQuery = performance.now();
     const queryTime = endQuery - startQuery;
     this.performance.queryTimes.push(queryTime);
@@ -420,12 +546,12 @@ class ParserWorker {
       this.performance.queryTimes.shift();
     }
     this.performance.averageQueryTime = this.performance.queryTimes.reduce((acc, time) => acc + time, 0) / this.performance.queryTimes.length;
-    return this.getHighlights(parserState, matches);
+    return this.getHighlights(parserState, matches, injectionRanges);
   }
   nodeContainsRange(node, range) {
     return node.startPosition.row <= range.startPosition.row && node.endPosition.row >= range.endPosition.row && (node.startPosition.row < range.startPosition.row || node.startPosition.column <= range.startPosition.column) && (node.endPosition.row > range.endPosition.row || node.endPosition.column >= range.endPosition.column);
   }
-  getHighlights(parserState, matches) {
+  getHighlights(parserState, matches, injectionRanges) {
     const lineHighlights = new Map;
     const droppedHighlights = new Map;
     for (const match of matches) {
@@ -467,12 +593,54 @@ class ParserWorker {
       }))
     };
   }
-  getSimpleHighlights(matches) {
+  getSimpleHighlights(matches, injectionRanges) {
     const highlights = [];
+    const flatInjectionRanges = [];
+    for (const [lang, ranges] of injectionRanges.entries()) {
+      for (const range of ranges) {
+        flatInjectionRanges.push({ ...range, lang });
+      }
+    }
     for (const match of matches) {
       const node = match.node;
-      highlights.push([node.startIndex, node.endIndex, match.name]);
+      let isInjection = false;
+      let injectionLang;
+      let containsInjection = false;
+      for (const injRange of flatInjectionRanges) {
+        if (node.startIndex >= injRange.start && node.endIndex <= injRange.end) {
+          isInjection = true;
+          injectionLang = injRange.lang;
+          break;
+        } else if (node.startIndex <= injRange.start && node.endIndex >= injRange.end) {
+          containsInjection = true;
+          break;
+        }
+      }
+      const matchQuery = match._injectedQuery;
+      const patternProperties = matchQuery?.setProperties?.[match.patternIndex];
+      const concealValue = patternProperties?.conceal ?? match.setProperties?.conceal;
+      const concealLines = patternProperties?.conceal_lines ?? match.setProperties?.conceal_lines;
+      const meta = {};
+      if (isInjection && injectionLang) {
+        meta.isInjection = true;
+        meta.injectionLang = injectionLang;
+      }
+      if (containsInjection) {
+        meta.containsInjection = true;
+      }
+      if (concealValue !== undefined) {
+        meta.conceal = concealValue;
+      }
+      if (concealLines !== undefined) {
+        meta.concealLines = concealLines;
+      }
+      if (Object.keys(meta).length > 0) {
+        highlights.push([node.startIndex, node.endIndex, match.name, meta]);
+      } else {
+        highlights.push([node.startIndex, node.endIndex, match.name]);
+      }
     }
+    highlights.sort((a, b) => a[0] - b[0]);
     return highlights;
   }
   async handleResetBuffer(bufferId, version, content) {
@@ -480,13 +648,20 @@ class ParserWorker {
     if (!parserState) {
       return { warning: "No parser state found for buffer" };
     }
+    parserState.content = content;
     const newTree = parserState.parser.parse(content);
     if (!newTree) {
       return { error: "Failed to parse buffer during reset" };
     }
     parserState.tree = newTree;
     const matches = parserState.queries.highlights.captures(parserState.tree.rootNode);
-    return this.getHighlights(parserState, matches);
+    let injectionRanges = new Map;
+    if (parserState.queries.injections) {
+      const injectionResult = await this.processInjections(parserState);
+      matches.push(...injectionResult.captures);
+      injectionRanges = injectionResult.injectionRanges;
+    }
+    return this.getHighlights(parserState, matches, injectionRanges);
   }
   disposeBuffer(bufferId) {
     const parserState = this.bufferParsers.get(bufferId);
@@ -508,7 +683,9 @@ class ParserWorker {
       });
       return;
     }
-    const tree = reusableState.parser.parse(content);
+    const parseContent = filetype === "markdown" && content.endsWith("```") ? content + `
+` : content;
+    const tree = reusableState.parser.parse(parseContent);
     if (!tree) {
       self.postMessage({
         type: "ONESHOT_HIGHLIGHT_RESPONSE",
@@ -520,7 +697,21 @@ class ParserWorker {
     }
     try {
       const matches = reusableState.filetypeParser.queries.highlights.captures(tree.rootNode);
-      const highlights = this.getSimpleHighlights(matches);
+      let injectionRanges = new Map;
+      if (reusableState.filetypeParser.queries.injections) {
+        const parserState = {
+          parser: reusableState.parser,
+          tree,
+          queries: reusableState.filetypeParser.queries,
+          filetype,
+          content,
+          injectionMapping: reusableState.filetypeParser.injectionMapping
+        };
+        const injectionResult = await this.processInjections(parserState);
+        matches.push(...injectionResult.captures);
+        injectionRanges = injectionResult.injectionRanges;
+      }
+      const highlights = this.getSimpleHighlights(matches, injectionRanges);
       self.postMessage({
         type: "ONESHOT_HIGHLIGHT_RESPONSE",
         messageId,
@@ -533,13 +724,32 @@ class ParserWorker {
   }
   async updateDataPath(dataPath) {
     this.dataPath = dataPath;
+    this.tsDataPath = path2.join(dataPath, "tree-sitter");
     try {
-      await mkdir2(path2.join(dataPath, "languages"), { recursive: true });
-      await mkdir2(path2.join(dataPath, "queries"), { recursive: true });
+      await mkdir2(path2.join(this.tsDataPath, "languages"), { recursive: true });
+      await mkdir2(path2.join(this.tsDataPath, "queries"), { recursive: true });
     } catch (error) {
       throw new Error(`Failed to update data path: ${error}`);
     }
   }
+  async clearCache() {
+    if (!this.dataPath || !this.tsDataPath) {
+      throw new Error("No data path configured");
+    }
+    const { rm } = await import("fs/promises");
+    try {
+      const treeSitterPath = path2.join(this.dataPath, "tree-sitter");
+      await rm(treeSitterPath, { recursive: true, force: true });
+      await mkdir2(path2.join(treeSitterPath, "languages"), { recursive: true });
+      await mkdir2(path2.join(treeSitterPath, "queries"), { recursive: true });
+      this.filetypeParsers.clear();
+      this.filetypeParserPromises.clear();
+      this.reusableParsers.clear();
+      this.reusableParserPromises.clear();
+    } catch (error) {
+      throw new Error(`Failed to clear cache: ${error}`);
+    }
+  }
 }
 if (!isMainThread) {
   let logMessage = function(type, ...args) {
@@ -552,6 +762,7 @@ if (!isMainThread) {
   const worker = new ParserWorker;
   console.log = (...args) => logMessage("log", ...args);
   console.error = (...args) => logMessage("error", ...args);
+  console.warn = (...args) => logMessage("warn", ...args);
   self.onmessage = async (e) => {
     const { type, bufferId, version, content, filetype, edits, filetypeParser, messageId, dataPath } = e.data;
     try {
@@ -619,6 +830,18 @@ if (!isMainThread) {
             });
           }
           break;
+        case "CLEAR_CACHE":
+          try {
+            await worker.clearCache();
+            self.postMessage({ type: "CLEAR_CACHE_RESPONSE", messageId });
+          } catch (error) {
+            self.postMessage({
+              type: "CLEAR_CACHE_RESPONSE",
+              messageId,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+          break;
         default:
           self.postMessage({
             type: "ERROR",
@@ -636,5 +859,5 @@ if (!isMainThread) {
   };
 }
 
-//# debugId=E28996FCD9507DC064756E2164756E21
+//# debugId=E1AC39235C034C8264756E2164756E21
 //# sourceMappingURL=parser.worker.js.map