@fairyhunter13/opentui-core 0.1.114 → 0.1.115

package/src/lib/tree-sitter/client.ts

@@ -1,607 +0,0 @@
-import { EventEmitter } from "events"
-import { createDebounce, clearDebounceScope, DebounceController } from "../debounce.js"
-import { ProcessQueue } from "../queue.js"
-import type {
-  TreeSitterClientOptions,
-  TreeSitterClientEvents,
-  BufferState,
-  ParsedBuffer,
-  FiletypeParserOptions,
-  Edit,
-  PerformanceStats,
-  SimpleHighlight,
-} from "./types.js"
-import { getParsers } from "./default-parsers.js"
-import { resolve, isAbsolute, parse } from "path"
-import { existsSync } from "fs"
-import { registerEnvVar, env } from "../env.js"
-import { isBunfsPath, normalizeBunfsPath } from "../bunfs.js"
-
-registerEnvVar({
-  name: "OTUI_TREE_SITTER_WORKER_PATH",
-  description: "Path to the TreeSitter worker",
-  type: "string",
-  default: "",
-})
-
-declare global {
-  const OTUI_TREE_SITTER_WORKER_PATH: string
-}
-
-interface EditQueueItem {
-  edits: Edit[]
-  newContent: string
-  version: number
-  isReset?: boolean
-}
-
-let DEFAULT_PARSERS: FiletypeParserOptions[] = getParsers()
-
-export function addDefaultParsers(parsers: FiletypeParserOptions[]): void {
-  for (const parser of parsers) {
-    DEFAULT_PARSERS = [
-      ...DEFAULT_PARSERS.filter((existingParser) => existingParser.filetype !== parser.filetype),
-      parser,
-    ]
-  }
-}
-
-const isUrl = (path: string) => path.startsWith("http://") || path.startsWith("https://")
-
-// Parser options now support both URLs and local file paths
-// TODO: TreeSitterClient should have a setOptions method, passing it on to the worker etc.
-export class TreeSitterClient extends EventEmitter<TreeSitterClientEvents> {
-  private initialized = false
-  private worker: Worker | undefined
-  private buffers: Map<number, BufferState> = new Map()
-  private initializePromise: Promise<void> | undefined
-  private initializeResolvers:
-    | { resolve: () => void; reject: (error: Error) => void; timeoutId: ReturnType<typeof setTimeout> }
-    | undefined
-  private messageCallbacks: Map<string, (response: any) => void> = new Map()
-  private messageIdCounter: number = 0
-  private editQueues: Map<number, ProcessQueue<EditQueueItem>> = new Map()
-  private debouncer: DebounceController
-  private options: TreeSitterClientOptions
-
-  constructor(options: TreeSitterClientOptions) {
-    super()
-    this.options = options
-    this.debouncer = createDebounce("tree-sitter-client")
-    this.startWorker()
-  }
-
-  private emitError(error: string, bufferId?: number): void {
-    if (this.listenerCount("error") > 0) {
-      this.emit("error", error, bufferId)
-    }
-  }
-
-  private emitWarning(warning: string, bufferId?: number): void {
-    if (this.listenerCount("warning") > 0) {
-      this.emit("warning", warning, bufferId)
-    }
-  }
-
-  private startWorker() {
-    if (this.worker) {
-      return
-    }
-
-    let worker_path: string | URL
-
-    if (env.OTUI_TREE_SITTER_WORKER_PATH) {
-      worker_path = env.OTUI_TREE_SITTER_WORKER_PATH
-    } else if (typeof OTUI_TREE_SITTER_WORKER_PATH !== "undefined") {
-      worker_path = OTUI_TREE_SITTER_WORKER_PATH
-    } else if (this.options.workerPath) {
-      worker_path = this.options.workerPath
-    } else {
-      worker_path = new URL("./parser.worker.js", import.meta.url).href
-      if (!existsSync(resolve(import.meta.dirname, "parser.worker.js"))) {
-        worker_path = new URL("./parser.worker.ts", import.meta.url).href
-      }
-    }
-
-    this.worker = new Worker(worker_path)
-
-    // @ts-ignore - onmessage exists
-    this.worker.onmessage = this.handleWorkerMessage.bind(this)
-
-    // @ts-ignore - onerror exists
-    this.worker.onerror = (error: ErrorEvent) => {
-      console.error("TreeSitter worker error:", error.message)
-
-      // If we're still initializing, reject the init promise
-      if (this.initializeResolvers) {
-        clearTimeout(this.initializeResolvers.timeoutId)
-        this.initializeResolvers.reject(new Error(`Worker error: ${error.message}`))
-        this.initializeResolvers = undefined
-      }
-
-      this.emitError(`Worker error: ${error.message}`)
-    }
-  }
-
-  private stopWorker() {
-    if (!this.worker) {
-      return
-    }
-
-    this.worker.terminate()
-    this.worker = undefined
-  }
-
-  // NOTE: Unused, but useful for debugging and testing
-  private handleReset() {
-    this.buffers.clear()
-    this.stopWorker()
-    this.startWorker()
-    this.initializePromise = undefined
-    this.initializeResolvers = undefined
-    return this.initialize()
-  }
-
-  async initialize(): Promise<void> {
-    if (this.initializePromise) {
-      return this.initializePromise
-    }
-
-    this.initializePromise = new Promise((resolve, reject) => {
-      const timeoutMs = this.options.initTimeout ?? 10000 // Default to 10 seconds
-      const timeoutId = setTimeout(() => {
-        const error = new Error("Worker initialization timed out")
-        console.error("TreeSitter client:", error.message)
-        this.initializeResolvers = undefined
-        reject(error)
-      }, timeoutMs)
-
-      this.initializeResolvers = { resolve, reject, timeoutId }
-      this.worker?.postMessage({
-        type: "INIT",
-        dataPath: this.options.dataPath,
-      })
-    })
-
-    await this.initializePromise
-    await this.registerDefaultParsers()
-
-    return this.initializePromise
-  }
-
-  private async registerDefaultParsers(): Promise<void> {
-    for (const parser of DEFAULT_PARSERS) {
-      this.addFiletypeParser(parser)
-    }
-  }
-
-  private resolvePath(path: string): string {
-    if (isUrl(path)) {
-      return path
-    }
-    if (isBunfsPath(path)) {
-      return normalizeBunfsPath(parse(path).base)
-    }
-    if (!isAbsolute(path)) {
-      return resolve(path)
-    }
-    return path
-  }
-
-  public addFiletypeParser(filetypeParser: FiletypeParserOptions): void {
-    const resolvedParser: FiletypeParserOptions = {
-      ...filetypeParser,
-      aliases: filetypeParser.aliases
-        ? [...new Set(filetypeParser.aliases.filter((alias) => alias !== filetypeParser.filetype))]
-        : undefined,
-      wasm: this.resolvePath(filetypeParser.wasm),
-      queries: {
-        highlights: filetypeParser.queries.highlights.map((path) => this.resolvePath(path)),
-        injections: filetypeParser.queries.injections?.map((path) => this.resolvePath(path)),
-      },
-    }
-    this.worker?.postMessage({ type: "ADD_FILETYPE_PARSER", filetypeParser: resolvedParser })
-  }
-
-  public async getPerformance(): Promise<PerformanceStats> {
-    const messageId = `performance_${this.messageIdCounter++}`
-    return new Promise<PerformanceStats>((resolve) => {
-      this.messageCallbacks.set(messageId, resolve)
-      this.worker?.postMessage({ type: "GET_PERFORMANCE", messageId })
-    })
-  }
-
-  public async highlightOnce(
-    content: string,
-    filetype: string,
-  ): Promise<{ highlights?: SimpleHighlight[]; warning?: string; error?: string }> {
-    if (!this.initialized) {
-      try {
-        await this.initialize()
-      } catch (error) {
-        return { error: "Could not highlight because of initialization error" }
-      }
-    }
-
-    const messageId = `oneshot_${this.messageIdCounter++}`
-    return new Promise((resolve) => {
-      this.messageCallbacks.set(messageId, resolve)
-      this.worker?.postMessage({
-        type: "ONESHOT_HIGHLIGHT",
-        content,
-        filetype,
-        messageId,
-      })
-    })
-  }
-
-  private handleWorkerMessage(event: MessageEvent) {
-    const { type, bufferId, error, highlights, warning, messageId, hasParser, performance, version } = event.data
-
-    if (type === "HIGHLIGHT_RESPONSE") {
-      const buffer = this.buffers.get(bufferId)
-      if (!buffer || !buffer.hasParser) return
-      if (buffer.version !== version) {
-        this.resetBuffer(bufferId, buffer.version, buffer.content)
-        return
-      }
-      this.emit("highlights:response", bufferId, version, highlights)
-    }
-
-    if (type === "INIT_RESPONSE") {
-      if (this.initializeResolvers) {
-        clearTimeout(this.initializeResolvers.timeoutId)
-        if (error) {
-          console.error("TreeSitter client initialization failed:", error)
-          this.initializeResolvers.reject(new Error(error))
-        } else {
-          this.initialized = true
-          this.initializeResolvers.resolve()
-        }
-        this.initializeResolvers = undefined
-        return
-      }
-    }
-
-    if (type === "PARSER_INIT_RESPONSE") {
-      const callback = this.messageCallbacks.get(messageId)
-      if (callback) {
-        this.messageCallbacks.delete(messageId)
-        callback({ hasParser, warning, error })
-      }
-      return
-    }
-
-    if (type === "PRELOAD_PARSER_RESPONSE") {
-      const callback = this.messageCallbacks.get(messageId)
-      if (callback) {
-        this.messageCallbacks.delete(messageId)
-        callback({ hasParser })
-      }
-      return
-    }
-
-    if (type === "BUFFER_DISPOSED") {
-      const callback = this.messageCallbacks.get(`dispose_${bufferId}`)
-      if (callback) {
-        this.messageCallbacks.delete(`dispose_${bufferId}`)
-        callback(true)
-      }
-      this.emit("buffer:disposed", bufferId)
-      return
-    }
-
-    if (type === "PERFORMANCE_RESPONSE") {
-      const callback = this.messageCallbacks.get(messageId)
-      if (callback) {
-        this.messageCallbacks.delete(messageId)
-        callback(performance)
-      }
-      return
-    }
-
-    if (type === "ONESHOT_HIGHLIGHT_RESPONSE") {
-      const callback = this.messageCallbacks.get(messageId)
-      if (callback) {
-        this.messageCallbacks.delete(messageId)
-        callback({ highlights, warning, error })
-      }
-      return
-    }
-
-    if (type === "UPDATE_DATA_PATH_RESPONSE") {
-      const callback = this.messageCallbacks.get(messageId)
-      if (callback) {
-        this.messageCallbacks.delete(messageId)
-        callback({ error })
-      }
-      return
-    }
-
-    if (type === "CLEAR_CACHE_RESPONSE") {
-      const callback = this.messageCallbacks.get(messageId)
-      if (callback) {
-        this.messageCallbacks.delete(messageId)
-        callback({ error })
-      }
-      return
-    }
-
-    if (warning) {
-      this.emitWarning(warning, bufferId)
-      return
-    }
-
-    if (error) {
-      this.emitError(error, bufferId)
-      return
-    }
-
-    if (type === "WORKER_LOG") {
-      const { logType, data } = event.data
-      const message = data.join(" ")
-
-      this.emit("worker:log", logType, message)
-      return
-    }
-  }
-
-  public async preloadParser(filetype: string): Promise<boolean> {
-    const messageId = `has_parser_${this.messageIdCounter++}`
-    const response = await new Promise<{ hasParser: boolean; warning?: string; error?: string }>((resolve) => {
-      this.messageCallbacks.set(messageId, resolve)
-      this.worker?.postMessage({
-        type: "PRELOAD_PARSER",
-        filetype,
-        messageId,
-      })
-    })
-    return response.hasParser
-  }
-
-  public async createBuffer(
-    id: number,
-    content: string,
-    filetype: string,
-    version: number = 1,
-    autoInitialize: boolean = true,
-  ): Promise<boolean> {
-    if (!this.initialized) {
-      if (!autoInitialize) {
-        this.emitError("Could not create buffer because client is not initialized")
-        return false
-      }
-      try {
-        await this.initialize()
-      } catch (error) {
-        this.emitError("Could not create buffer because of initialization error")
-        return false
-      }
-    }
-
-    if (this.buffers.has(id)) {
-      throw new Error(`Buffer with id ${id} already exists`)
-    }
-
-    // Set buffer state immediately to avoid race conditions
-    this.buffers.set(id, { id, content, filetype, version, hasParser: false })
-
-    const messageId = `init_${this.messageIdCounter++}`
-    const response = await new Promise<{ hasParser: boolean; warning?: string; error?: string }>((resolve) => {
-      this.messageCallbacks.set(messageId, resolve)
-      this.worker?.postMessage({
-        type: "INITIALIZE_PARSER",
-        bufferId: id,
-        version,
-        content,
-        filetype,
-        messageId,
-      })
-    })
-
-    if (!response.hasParser) {
-      this.emit("buffer:initialized", id, false)
-      if (filetype !== "plaintext") {
-        this.emitWarning(response.warning || response.error || "Buffer has no parser", id)
-      }
-      return false
-    }
-
-    // Update buffer state to indicate it has a parser
-    const bufferState: ParsedBuffer = { id, content, filetype, version, hasParser: true }
-    this.buffers.set(id, bufferState)
-
-    this.emit("buffer:initialized", id, true)
-    return true
-  }
-
-  public async updateBuffer(id: number, edits: Edit[], newContent: string, version: number): Promise<void> {
-    if (!this.initialized) {
-      return
-    }
-
-    const buffer = this.buffers.get(id)
-    if (!buffer || !buffer.hasParser) {
-      return
-    }
-
-    // Update buffer state
-    this.buffers.set(id, { ...buffer, content: newContent, version })
-
-    if (!this.editQueues.has(id)) {
-      this.editQueues.set(
-        id,
-        new ProcessQueue<EditQueueItem>((item) =>
-          this.processEdit(id, item.edits, item.newContent, item.version, item.isReset),
-        ),
-      )
-    }
-
-    const bufferQueue = this.editQueues.get(id)!
-    bufferQueue.enqueue({ edits, newContent, version })
-  }
-
-  private async processEdit(
-    bufferId: number,
-    edits: Edit[],
-    newContent: string,
-    version: number,
-    isReset = false,
-  ): Promise<void> {
-    this.worker?.postMessage({
-      type: isReset ? "RESET_BUFFER" : "HANDLE_EDITS",
-      bufferId,
-      version,
-      content: newContent,
-      edits,
-    })
-  }
-
-  public async removeBuffer(bufferId: number): Promise<void> {
-    if (!this.initialized) {
-      return
-    }
-
-    this.buffers.delete(bufferId)
-
-    if (this.editQueues.has(bufferId)) {
-      this.editQueues.get(bufferId)?.clear()
-      this.editQueues.delete(bufferId)
-    }
-
-    if (this.worker) {
-      await new Promise<boolean>((resolve) => {
-        const messageId = `dispose_${bufferId}`
-        this.messageCallbacks.set(messageId, resolve)
-        try {
-          this.worker!.postMessage({
-            type: "DISPOSE_BUFFER",
-            bufferId,
-          })
-        } catch (error) {
-          console.error("Error disposing buffer", error)
-          resolve(false)
-        }
-
-        // Add a timeout in case the worker doesn't respond
-        setTimeout(() => {
-          if (this.messageCallbacks.has(messageId)) {
-            this.messageCallbacks.delete(messageId)
-            console.warn({ bufferId }, "Timed out waiting for buffer to be disposed")
-            resolve(false)
-          }
-        }, 3000)
-      })
-    }
-
-    this.debouncer.clearDebounce(`reset-${bufferId}`)
-  }
-
-  public async destroy(): Promise<void> {
-    if (this.initializeResolvers) {
-      clearTimeout(this.initializeResolvers.timeoutId)
-      // Reject pending initialization promise to prevent hanging awaits
-      this.initializeResolvers.reject(new Error("Client destroyed during initialization"))
-      this.initializeResolvers = undefined
-    }
-
-    for (const [messageId, callback] of this.messageCallbacks.entries()) {
-      if (typeof callback === "function") {
-        try {
-          callback({ error: "Client destroyed" })
-        } catch (e) {
-          // Ignore errors during cleanup
-        }
-      }
-    }
-    this.messageCallbacks.clear()
-
-    clearDebounceScope("tree-sitter-client")
-    this.debouncer.clear()
-
-    this.editQueues.clear()
-    this.buffers.clear()
-
-    this.stopWorker()
-
-    this.initialized = false
-    this.initializePromise = undefined
-  }
-
-  public async resetBuffer(bufferId: number, version: number, content: string): Promise<void> {
-    if (!this.initialized) {
-      return
-    }
-
-    const buffer = this.buffers.get(bufferId)
-    if (!buffer || !buffer.hasParser) {
-      this.emitError("Cannot reset buffer with no parser", bufferId)
-      return
-    }
-
-    // Update buffer state
-    this.buffers.set(bufferId, { ...buffer, content, version })
-
-    // Use debouncer to avoid excessive resets
-    this.debouncer.debounce(`reset-${bufferId}`, 10, () => this.processEdit(bufferId, [], content, version, true))
-  }
-
-  public getBuffer(bufferId: number): BufferState | undefined {
-    return this.buffers.get(bufferId)
-  }
-
-  public getAllBuffers(): BufferState[] {
-    return Array.from(this.buffers.values())
-  }
-
-  public isInitialized(): boolean {
-    return this.initialized
-  }
-
-  public async setDataPath(dataPath: string): Promise<void> {
-    if (this.options.dataPath === dataPath) {
-      return
-    }
-
-    this.options.dataPath = dataPath
-
-    if (this.initialized && this.worker) {
-      const messageId = `update_datapath_${this.messageIdCounter++}`
-      return new Promise<void>((resolve, reject) => {
-        this.messageCallbacks.set(messageId, (response: any) => {
-          if (response.error) {
-            reject(new Error(response.error))
-          } else {
-            resolve()
-          }
-        })
-        this.worker!.postMessage({
-          type: "UPDATE_DATA_PATH",
-          dataPath,
-          messageId,
-        })
-      })
-    }
-  }
-
-  public async clearCache(): Promise<void> {
-    if (!this.initialized || !this.worker) {
-      throw new Error("Cannot clear cache: client is not initialized")
-    }
-
-    const messageId = `clear_cache_${this.messageIdCounter++}`
-    return new Promise<void>((resolve, reject) => {
-      this.messageCallbacks.set(messageId, (response: any) => {
-        if (response.error) {
-          reject(new Error(response.error))
-        } else {
-          resolve()
-        }
-      })
-      this.worker!.postMessage({
-        type: "CLEAR_CACHE",
-        messageId,
-      })
-    })
-  }
-}

package/src/lib/tree-sitter/default-parsers.ts

@@ -1,86 +0,0 @@
-// This file is generated by assets/update.ts - DO NOT EDIT MANUALLY
-// Run 'bun assets/update.ts' to regenerate this file
-// Last generated: 2026-03-20T21:07:24.696Z
-
-import type { FiletypeParserOptions } from "./types.js"
-import { resolve, dirname } from "path"
-import { fileURLToPath } from "url"
-
-import javascript_highlights from "./assets/javascript/highlights.scm" with { type: "file" }
-import javascript_language from "./assets/javascript/tree-sitter-javascript.wasm" with { type: "file" }
-import typescript_highlights from "./assets/typescript/highlights.scm" with { type: "file" }
-import typescript_language from "./assets/typescript/tree-sitter-typescript.wasm" with { type: "file" }
-import markdown_highlights from "./assets/markdown/highlights.scm" with { type: "file" }
-import markdown_language from "./assets/markdown/tree-sitter-markdown.wasm" with { type: "file" }
-import markdown_injections from "./assets/markdown/injections.scm" with { type: "file" }
-import markdown_inline_highlights from "./assets/markdown_inline/highlights.scm" with { type: "file" }
-import markdown_inline_language from "./assets/markdown_inline/tree-sitter-markdown_inline.wasm" with { type: "file" }
-import zig_highlights from "./assets/zig/highlights.scm" with { type: "file" }
-import zig_language from "./assets/zig/tree-sitter-zig.wasm" with { type: "file" }
-
-// Cached parsers to avoid re-resolving paths on every call
-let _cachedParsers: FiletypeParserOptions[] | undefined
-
-export function getParsers(): FiletypeParserOptions[] {
-  if (!_cachedParsers) {
-    _cachedParsers = [
-      {
-        filetype: "javascript",
-        aliases: ["javascriptreact"],
-        queries: {
-          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), javascript_highlights)],
-        },
-        wasm: resolve(dirname(fileURLToPath(import.meta.url)), javascript_language),
-      },
-      {
-        filetype: "typescript",
-        aliases: ["typescriptreact"],
-        queries: {
-          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), typescript_highlights)],
-        },
-        wasm: resolve(dirname(fileURLToPath(import.meta.url)), typescript_language),
-      },
-      {
-        filetype: "markdown",
-        queries: {
-          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_highlights)],
-          injections: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_injections)],
-        },
-        wasm: resolve(dirname(fileURLToPath(import.meta.url)), markdown_language),
-        injectionMapping: {
-          "nodeTypes": {
-                    "inline": "markdown_inline",
-                    "pipe_table_cell": "markdown_inline"
-          },
-          "infoStringMap": {
-                    "javascript": "javascript",
-                    "js": "javascript",
-                    "jsx": "javascriptreact",
-                    "javascriptreact": "javascriptreact",
-                    "typescript": "typescript",
-                    "ts": "typescript",
-                    "tsx": "typescriptreact",
-                    "typescriptreact": "typescriptreact",
-                    "markdown": "markdown",
-                    "md": "markdown"
-          }
-},
-      },
-      {
-        filetype: "markdown_inline",
-        queries: {
-          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_inline_highlights)],
-        },
-        wasm: resolve(dirname(fileURLToPath(import.meta.url)), markdown_inline_language),
-      },
-      {
-        filetype: "zig",
-        queries: {
-          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), zig_highlights)],
-        },
-        wasm: resolve(dirname(fileURLToPath(import.meta.url)), zig_language),
-      },
-    ]
-  }
-  return _cachedParsers
-}