@renxqoo/renx-code-win32-x64 0.0.71 → 0.0.72

package/bin/otui-worker-bundle/parser.worker.js

@@ -3235,7 +3235,7 @@ var Parser = class {
   }
 };
 
-// ../../node_modules/.bun/@opentui+core@0.1.87+a7e4efcb39f2fc50/node_modules/@opentui/core/parser.worker.js
+// ../../node_modules/.bun/@opentui+core@0.1.91+a7e4efcb39f2fc50/node_modules/@opentui/core/parser.worker.js
 import { mkdir as mkdir2 } from "fs/promises";
 import * as path2 from "path";
 import { mkdir, readFile, writeFile } from "fs/promises";
@@ -3359,6 +3359,7 @@ var self2 = globalThis;
 class ParserWorker {
   bufferParsers = new Map;
   filetypeParserOptions = new Map;
+  filetypeAliases = new Map;
   filetypeParsers = new Map;
   filetypeParserPromises = new Map;
   reusableParsers = new Map;
@@ -3386,31 +3387,57 @@ class ParserWorker {
     if (this.initializePromise) {
       return this.initializePromise;
     }
-    this.initializePromise = new Promise(async (resolve, reject) => {
+    this.initializePromise = (async () => {
       this.dataPath = dataPath;
       this.tsDataPath = path2.join(dataPath, "tree-sitter");
-      try {
-        await mkdir2(path2.join(this.tsDataPath, "languages"), { recursive: true });
-        await mkdir2(path2.join(this.tsDataPath, "queries"), { recursive: true });
-        let { default: treeWasm } = await Promise.resolve().then(() => __toESM(require_tree_sitter(), 1));
-        if (isBunfsPath(treeWasm)) {
-          treeWasm = normalizeBunfsPath(path2.parse(treeWasm).base);
-        }
-        await Parser.init({
-          locateFile() {
-            return treeWasm;
-          }
-        });
-        this.initialized = true;
-        resolve();
-      } catch (error) {
-        reject(error);
+      await mkdir2(path2.join(this.tsDataPath, "languages"), { recursive: true });
+      await mkdir2(path2.join(this.tsDataPath, "queries"), { recursive: true });
+      let { default: treeWasm } = await Promise.resolve().then(() => __toESM(require_tree_sitter(), 1));
+      if (isBunfsPath(treeWasm)) {
+        treeWasm = normalizeBunfsPath(path2.parse(treeWasm).base);
       }
-    });
+      await Parser.init({
+        locateFile() {
+          return treeWasm;
+        }
+      });
+      this.initialized = true;
+    })();
     return this.initializePromise;
   }
   addFiletypeParser(filetypeParser) {
-    this.filetypeParserOptions.set(filetypeParser.filetype, filetypeParser);
+    const previousAliases = this.filetypeParserOptions.get(filetypeParser.filetype)?.aliases ?? [];
+    for (const alias of previousAliases) {
+      if (this.filetypeAliases.get(alias) === filetypeParser.filetype) {
+        this.filetypeAliases.delete(alias);
+      }
+    }
+    const aliases = [...new Set((filetypeParser.aliases ?? []).filter((alias) => alias !== filetypeParser.filetype))];
+    this.filetypeAliases.delete(filetypeParser.filetype);
+    this.filetypeParserOptions.set(filetypeParser.filetype, {
+      ...filetypeParser,
+      aliases
+    });
+    for (const alias of aliases) {
+      this.filetypeAliases.set(alias, filetypeParser.filetype);
+    }
+    this.invalidateParserCaches(filetypeParser.filetype);
+  }
+  resolveCanonicalFiletype(filetype) {
+    if (this.filetypeParserOptions.has(filetype)) {
+      return filetype;
+    }
+    return this.filetypeAliases.get(filetype) ?? filetype;
+  }
+  invalidateParserCaches(filetype) {
+    this.filetypeParsers.delete(filetype);
+    this.filetypeParserPromises.delete(filetype);
+    const reusableParser = this.reusableParsers.get(filetype);
+    if (reusableParser) {
+      reusableParser.parser.delete();
+      this.reusableParsers.delete(filetype);
+    }
+    this.reusableParserPromises.delete(filetype);
   }
   async createQueries(filetypeParser, language) {
     try {
@@ -3458,22 +3485,23 @@ class ParserWorker {
     }
   }
   async resolveFiletypeParser(filetype) {
-    if (this.filetypeParsers.has(filetype)) {
-      return this.filetypeParsers.get(filetype);
+    const canonicalFiletype = this.resolveCanonicalFiletype(filetype);
+    if (this.filetypeParsers.has(canonicalFiletype)) {
+      return this.filetypeParsers.get(canonicalFiletype);
     }
-    if (this.filetypeParserPromises.has(filetype)) {
-      return this.filetypeParserPromises.get(filetype);
+    if (this.filetypeParserPromises.has(canonicalFiletype)) {
+      return this.filetypeParserPromises.get(canonicalFiletype);
     }
-    const loadingPromise = this.loadFiletypeParser(filetype);
-    this.filetypeParserPromises.set(filetype, loadingPromise);
+    const loadingPromise = this.loadFiletypeParser(canonicalFiletype);
+    this.filetypeParserPromises.set(canonicalFiletype, loadingPromise);
     try {
       const result = await loadingPromise;
       if (result) {
-        this.filetypeParsers.set(filetype, result);
+        this.filetypeParsers.set(canonicalFiletype, result);
       }
       return result;
     } finally {
-      this.filetypeParserPromises.delete(filetype);
+      this.filetypeParserPromises.delete(canonicalFiletype);
     }
   }
   async loadFiletypeParser(filetype) {
@@ -3501,22 +3529,23 @@ class ParserWorker {
     return this.resolveFiletypeParser(filetype);
   }
   async getReusableParser(filetype) {
-    if (this.reusableParsers.has(filetype)) {
-      return this.reusableParsers.get(filetype);
+    const canonicalFiletype = this.resolveCanonicalFiletype(filetype);
+    if (this.reusableParsers.has(canonicalFiletype)) {
+      return this.reusableParsers.get(canonicalFiletype);
     }
-    if (this.reusableParserPromises.has(filetype)) {
-      return this.reusableParserPromises.get(filetype);
+    if (this.reusableParserPromises.has(canonicalFiletype)) {
+      return this.reusableParserPromises.get(canonicalFiletype);
     }
-    const creationPromise = this.createReusableParser(filetype);
-    this.reusableParserPromises.set(filetype, creationPromise);
+    const creationPromise = this.createReusableParser(canonicalFiletype);
+    this.reusableParserPromises.set(canonicalFiletype, creationPromise);
     try {
       const result = await creationPromise;
       if (result) {
-        this.reusableParsers.set(filetype, result);
+        this.reusableParsers.set(canonicalFiletype, result);
       }
       return result;
     } finally {
-      this.reusableParserPromises.delete(filetype);
+      this.reusableParserPromises.delete(canonicalFiletype);
     }
   }
   async createReusableParser(filetype) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renxqoo/renx-code-win32-x64",
-  "version": "0.0.71",
+  "version": "0.0.72",
   "description": "Renx Code terminal AI coding assistant (win32-x64)",
   "type": "commonjs",
   "private": false,