@tldiagram/core-ui 1.87.0

package/src/utils/treesitter.ts

@@ -0,0 +1,147 @@
+import Parser from 'web-tree-sitter'
+
+let parserInitialized = false
+
+export async function initTreeSitter() {
+  if (parserInitialized) return
+  const VERSION = '0.21.0'
+  await Parser.init({
+    locateFile(scriptName: string) {
+      // In newer versions, the WASM file is named tree-sitter.wasm, but some loaders might still ask for web-tree-sitter.wasm
+      const name = scriptName === 'web-tree-sitter.wasm' ? 'tree-sitter.wasm' : scriptName
+      return `https://unpkg.com/web-tree-sitter@${VERSION}/${name}`
+    }
+  })
+  parserInitialized = true
+}
+
+export type SupportedLanguage = 'javascript' | 'typescript' | 'python' | 'java' | 'cpp' | 'go' | 'rust'
+
+const EXT_TO_LANGUAGE: Record<string, SupportedLanguage> = {
+  '.js': 'javascript', '.jsx': 'javascript',
+  '.ts': 'typescript', '.tsx': 'typescript',
+  '.py': 'python', '.go': 'go', '.rs': 'rust',
+  '.java': 'java', '.cpp': 'cpp', '.cc': 'cpp', '.cxx': 'cpp', '.c': 'cpp', '.h': 'cpp',
+}
+
+export function detectLanguage(path: string): SupportedLanguage | null {
+  const parts = path.split('.')
+  if (parts.length < 2) return null
+  const ext = '.' + parts.pop()!.toLowerCase()
+  return EXT_TO_LANGUAGE[ext] ?? null
+}
+
+const languageWasms: Record<SupportedLanguage, string> = {
+  javascript: 'https://unpkg.com/tree-sitter-wasms@0.1.13/out/tree-sitter-javascript.wasm',
+  typescript: 'https://unpkg.com/tree-sitter-wasms@0.1.13/out/tree-sitter-typescript.wasm',
+  python: 'https://unpkg.com/tree-sitter-wasms@0.1.13/out/tree-sitter-python.wasm',
+  java: 'https://unpkg.com/tree-sitter-wasms@0.1.13/out/tree-sitter-java.wasm',
+  cpp: 'https://unpkg.com/tree-sitter-wasms@0.1.13/out/tree-sitter-cpp.wasm',
+  go: 'https://unpkg.com/tree-sitter-wasms@0.1.13/out/tree-sitter-go.wasm',
+  rust: 'https://unpkg.com/tree-sitter-wasms@0.1.13/out/tree-sitter-rust.wasm',
+}
+
+const parsers: Partial<Record<SupportedLanguage, Parser>> = {}
+
+export async function getParser(language: SupportedLanguage): Promise<Parser> {
+  await initTreeSitter()
+
+  if (parsers[language]) {
+    return parsers[language]!
+  }
+
+  const parser = new Parser()
+  const langWasmPath = languageWasms[language]
+  const Lang = await Parser.Language.load(langWasmPath)
+  parser.setLanguage(Lang)
+  parsers[language] = parser
+  return parser
+}
+
+export interface ParsedSymbol {
+  name: string
+  type: string
+  startLine: number
+  endLine: number
+}
+
+// Extract main symbols using tree-sitter cursor to avoid complex queries across languages.
+export function extractSymbols(tree: Parser.Tree, language: SupportedLanguage): ParsedSymbol[] {
+  const symbols: ParsedSymbol[] = []
+
+  const isTargetNode = (nodeType: string) => {
+    switch (language) {
+      case 'javascript':
+      case 'typescript':
+        return ['class_declaration', 'function_declaration', 'method_definition', 'interface_declaration', 'type_alias_declaration'].includes(nodeType)
+      case 'python':
+        return ['class_definition', 'function_definition'].includes(nodeType)
+      case 'java':
+        return ['class_declaration', 'method_declaration', 'interface_declaration'].includes(nodeType)
+      case 'cpp':
+        return ['class_specifier', 'function_definition', 'struct_specifier'].includes(nodeType)
+      case 'go':
+        return ['function_declaration', 'method_declaration', 'type_declaration'].includes(nodeType)
+      case 'rust':
+        return ['function_item', 'struct_item', 'impl_item', 'trait_item'].includes(nodeType)
+      default:
+        return false
+    }
+  }
+
+  const getNameField = (node: Parser.SyntaxNode): string => {
+    // Attempt to find an identifier child
+    if (node.type === 'method_definition') {
+      const nameNode = node.childForFieldName('name')
+      if (nameNode) return nameNode.text
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i)
+      if (child && ['identifier', 'type_identifier', 'name'].includes(child.type)) {
+        return child.text
+      }
+    }
+    return node.child(1)?.text || 'unknown'
+  }
+
+  const traverse = (node: Parser.SyntaxNode) => {
+    if (isTargetNode(node.type)) {
+      symbols.push({
+        name: getNameField(node),
+        type: node.type,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1
+      })
+    }
+
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i)
+      if (child) traverse(child)
+    }
+  }
+
+  traverse(tree.rootNode)
+
+  return symbols
+}
+
+export function findSymbolByName(
+  tree: Parser.Tree,
+  language: SupportedLanguage,
+  name: string,
+  type: string
+): ParsedSymbol | null {
+  const all = extractSymbols(tree, language)
+  // Exact match
+  let found = all.find(s => s.name === name && s.type === type)
+  if (found) return found
+
+  // Partial type match (e.g., 'function_item' contains 'function')
+  if (type) {
+    found = all.find(s => s.name === name && (s.type.includes(type) || type.includes(s.type)))
+    if (found) return found
+  }
+
+  // Fallback to just name match
+  return all.find(s => s.name === name) ?? null
+}

package/src/utils/url.ts

@@ -0,0 +1,72 @@
+import { isNativeApp } from '../config/runtime'
+
+/**
+ * Resolves a static asset path (like a logo or icon) taking into account
+ * the environment (dev vs production, web vs native Capacitor).
+ */
+export function resolveIconPath(path: string | null | undefined): string {
+  if (!path) return ''
+
+  // Absolute URLs and data URIs are returned as-is
+  if (path.startsWith('http://') || path.startsWith('https://') || path.startsWith('data:')) return path
+
+  // If running inside the native mobile app (Capacitor) OR inside an embedded
+  // webview that serves content from localhost (e.g. Capacitor production webview),
+  // static assets are typically available at the web root. However we must NOT treat
+  // the local dev server (like http://localhost:5173) as a native/webview environment.
+  // Use a conservative detection: file:// is always native; localhost/127.0.0.1 is
+  // treated as native only when served over HTTPS (Capacitor uses https://localhost)
+  // or when there is no non-default dev port present.
+  const runningOnLocalhost = typeof window !== 'undefined' && (() => {
+    // file: is unequivocally a native / packaged environment (Capacitor)
+    if (window.location.protocol === 'file:') return true
+
+    // Only consider plain localhost/127.0.0.1 further
+    const hostIsLocal = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1'
+    if (!hostIsLocal) return false
+
+    // If served over HTTPS on localhost (Capacitor uses https://localhost) assume native/webview.
+    if (window.location.protocol === 'https:') return true
+
+    // If there's no explicit port (or it's the default HTTPS port), treat as native/webview.
+    // Dev servers usually expose a non-default port (like 5173) - those should NOT be treated as native.
+    const port = (window.location.port || '').trim()
+    if (!port || port === '443') return true
+
+    return false
+  })()
+
+  if (isNativeApp || runningOnLocalhost) {
+    // Strip the web app base prefix (/app/) if present - logo_url values saved from
+    // the web interface may have this prefix baked in, but on native assets live at root.
+    const stripped = path.startsWith('/app/') ? path.slice('/app'.length) : path
+    return stripped.startsWith('/') ? stripped : `/${stripped}`
+  }
+
+  // Use Vite's BASE_URL (import.meta.env.BASE_URL)
+  const base = import.meta.env.BASE_URL || '/'
+  const normalizedBase = base.endsWith('/') ? base : `${base}/`
+
+  // If the path already starts with the base, return it
+  if (path.startsWith(normalizedBase) || path === normalizedBase.slice(0, -1)) return path
+
+  const normalizedPath = path.startsWith('/') ? path.slice(1) : path
+  return `${normalizedBase}${normalizedPath}`
+}
+
+  /**
+   * Normalizes any git repository reference to an "owner/repo" slug:
+   *   - SSH:   git@github.com:owner/repo.git  → owner/repo
+   *   - HTTPS: https://github.com/owner/repo.git → owner/repo
+   *   - Plain: owner/repo                     → owner/repo
+   */
+  export function parseRepoSlug(repo: string): string {
+    // SSH format: git@host:owner/repo(.git)
+    const sshMatch = repo.match(/^git@[^:]+:(.+?)(?:\.git)?$/)
+    if (sshMatch) return sshMatch[1]
+    // HTTPS format: https://host/owner/repo(.git)
+    const httpsMatch = repo.match(/^https?:\/\/[^/]+\/(.+?)(?:\.git)?$/)
+    if (httpsMatch) return httpsMatch[1]
+    // Already owner/repo, strip optional .git suffix
+    return repo.replace(/\.git$/, '')
+  }

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />