@fairyhunter13/opentui-core 0.1.114 → 0.1.116

package/src/lib/detect-links.test.ts

@@ -1,98 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { detectLinks } from "./detect-links.js"
-import type { TextChunk } from "../text-buffer.js"
-import type { SimpleHighlight } from "./tree-sitter/types.js"
-import { RGBA } from "./RGBA.js"
-
-function chunk(text: string): TextChunk {
-  return { __isChunk: true, text, fg: RGBA.fromInts(255, 255, 255, 255), attributes: 0 }
-}
-
-describe("detectLinks", () => {
-  test("should set link on markup.link.url chunks", () => {
-    const content = "[Click here](https://example.com)"
-    const highlights: SimpleHighlight[] = [
-      [0, 1, "markup.link"],
-      [1, 11, "markup.link.label"],
-      [11, 13, "markup.link"],
-      [13, 32, "markup.link.url"],
-      [32, 33, "markup.link"],
-    ]
-    const chunks = [chunk("["), chunk("Click here"), chunk("]("), chunk("https://example.com"), chunk(")")]
-
-    const result = detectLinks(chunks, { content, highlights })
-
-    expect(result.find((c) => c.text === "https://example.com")!.link).toEqual({ url: "https://example.com" })
-    expect(result.find((c) => c.text === "Click here")!.link).toEqual({ url: "https://example.com" })
-  })
-
-  test("should set link on string.special.url chunks", () => {
-    const content = "// see https://example.com for details"
-    const highlights: SimpleHighlight[] = [
-      [0, 38, "comment"],
-      [7, 26, "string.special.url"],
-    ]
-    const chunks = [chunk("// see "), chunk("https://example.com"), chunk(" for details")]
-
-    const result = detectLinks(chunks, { content, highlights })
-
-    expect(result.find((c) => c.text === "https://example.com")!.link).toEqual({ url: "https://example.com" })
-  })
-
-  test("should not set link on non-URL chunks", () => {
-    const content = "const x = 42"
-    const highlights: SimpleHighlight[] = [
-      [0, 5, "keyword"],
-      [6, 7, "variable"],
-      [10, 12, "number"],
-    ]
-    const chunks = [chunk("const"), chunk(" "), chunk("x"), chunk(" = "), chunk("42")]
-
-    const result = detectLinks(chunks, { content, highlights })
-
-    for (const c of result) {
-      expect(c.link).toBeUndefined()
-    }
-  })
-
-  test("should return chunks unchanged when no URL scopes exist", () => {
-    const content = "hello world"
-    const highlights: SimpleHighlight[] = [[0, 5, "keyword"]]
-    const chunks = [chunk("hello"), chunk(" world")]
-
-    const result = detectLinks(chunks, { content, highlights })
-
-    expect(result).toBe(chunks)
-  })
-
-  test("should detect links when chunks have concealed text", () => {
-    // Original content: [Click here](https://example.com)
-    // With concealment, `[` and `]` are concealed to empty strings,
-    // and `(` and `)` are concealed to empty strings.
-    // This means chunk text lengths don't match original byte offsets.
-    const content = "[Click here](https://example.com)"
-    const highlights: SimpleHighlight[] = [
-      [0, 1, "markup.link"], // [
-      [1, 11, "markup.link.label"], // Click here
-      [11, 13, "markup.link"], // ](
-      [13, 32, "markup.link.url"], // https://example.com
-      [32, 33, "markup.link"], // )
-    ]
-    // Simulate concealed chunks: `[` -> "", `](` -> " ", `)` -> ""
-    // The URL and label chunks remain unchanged.
-    const chunks = [
-      chunk(""), // concealed `[`
-      chunk("Click here"), // label, unchanged
-      chunk(" "), // concealed `](`
-      chunk("https://example.com"), // URL, unchanged
-      chunk(""), // concealed `)`
-    ]
-
-    const result = detectLinks(chunks, { content, highlights })
-
-    // The URL chunk should still get its link despite concealed offsets
-    expect(result.find((c) => c.text === "https://example.com")!.link).toEqual({ url: "https://example.com" })
-    // The label chunk should also get the link
-    expect(result.find((c) => c.text === "Click here")!.link).toEqual({ url: "https://example.com" })
-  })
-})

package/src/lib/detect-links.ts

@@ -1,56 +0,0 @@
-import type { TextChunk } from "../text-buffer.js"
-import type { SimpleHighlight } from "./tree-sitter/types.js"
-
-const URL_SCOPES = ["markup.link.url", "string.special.url"]
-
-export function detectLinks(
-  chunks: TextChunk[],
-  context: { content: string; highlights: SimpleHighlight[] },
-): TextChunk[] {
-  const content = context.content
-  const highlights = context.highlights
-
-  const ranges: Array<{ start: number; end: number; url: string }> = []
-
-  for (let i = 0; i < highlights.length; i++) {
-    const [start, end, group] = highlights[i]
-    if (!URL_SCOPES.includes(group)) continue
-
-    const url = content.slice(start, end)
-    ranges.push({ start, end, url })
-
-    for (let j = i - 1; j >= 0; j--) {
-      const [labelStart, labelEnd, prev] = highlights[j]
-      if (prev === "markup.link.label") {
-        ranges.push({ start: labelStart, end: labelEnd, url })
-        break
-      }
-      if (!prev.startsWith("markup.link")) break
-    }
-  }
-
-  if (ranges.length === 0) return chunks
-
-  // Use content.indexOf to find each chunk's position in the original content.
-  // This handles concealed text correctly because concealed chunks are either
-  // empty (length 0, skipped) or single-char replacements (length 1, skipped).
-  // Non-concealed chunks with length > 1 are exact substrings of content in order.
-  let contentPos = 0
-  for (const chunk of chunks) {
-    if (chunk.text.length <= 1) continue
-
-    const idx = content.indexOf(chunk.text, contentPos)
-    if (idx < 0) continue
-
-    for (const range of ranges) {
-      if (idx < range.end && idx + chunk.text.length > range.start) {
-        chunk.link = { url: range.url }
-        break
-      }
-    }
-
-    contentPos = idx + chunk.text.length
-  }
-
-  return chunks
-}

package/src/lib/env.test.ts

@@ -1,228 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test"
-import { envRegistry, registerEnvVar, env, clearEnvCache } from "./env.ts"
-
-// Backup and restore registry to avoid interfering with module-level registrations
-let registryBackup: Record<string, any> = {}
-
-beforeEach(() => {
-  registryBackup = { ...envRegistry }
-
-  clearEnvCache()
-
-  Object.keys(process.env).forEach((key) => {
-    if (key.startsWith("TEST_")) {
-      delete process.env[key]
-    }
-  })
-})
-
-afterEach(() => {
-  Object.keys(envRegistry).forEach((key) => {
-    if (key.startsWith("TEST_") && !(key in registryBackup)) {
-      delete envRegistry[key]
-    }
-  })
-
-  Object.keys(process.env).forEach((key) => {
-    if (key.startsWith("TEST_")) {
-      delete process.env[key]
-    }
-  })
-})
-
-describe("env registry", () => {
-  test("should register and access string env vars", () => {
-    registerEnvVar({
-      name: "TEST_STRING",
-      description: "A test string variable",
-      type: "string",
-      default: "default_value",
-    })
-
-    // Set env var
-    process.env.TEST_STRING = "test_value"
-
-    expect(env.TEST_STRING).toBe("test_value")
-  })
-
-  test("should handle boolean env vars with various true values", () => {
-    registerEnvVar({
-      name: "TEST_BOOL_TRUE",
-      description: "A test boolean variable",
-      type: "boolean",
-    })
-
-    // Test various true values
-    process.env.TEST_BOOL_TRUE = "true"
-    expect(env.TEST_BOOL_TRUE).toBe(true)
-
-    process.env.TEST_BOOL_TRUE = "1"
-    expect(env.TEST_BOOL_TRUE).toBe(true)
-
-    process.env.TEST_BOOL_TRUE = "on"
-    expect(env.TEST_BOOL_TRUE).toBe(true)
-
-    process.env.TEST_BOOL_TRUE = "yes"
-    expect(env.TEST_BOOL_TRUE).toBe(true)
-  })
-
-  test("should handle boolean env vars with various false values", () => {
-    registerEnvVar({
-      name: "TEST_BOOL_FALSE",
-      description: "A test boolean variable",
-      type: "boolean",
-    })
-
-    // Test various false values
-    process.env.TEST_BOOL_FALSE = "false"
-    expect(env.TEST_BOOL_FALSE).toBe(false)
-
-    process.env.TEST_BOOL_FALSE = "0"
-    expect(env.TEST_BOOL_FALSE).toBe(false)
-
-    process.env.TEST_BOOL_FALSE = "off"
-    expect(env.TEST_BOOL_FALSE).toBe(false)
-  })
-
-  test("should handle number env vars", () => {
-    registerEnvVar({
-      name: "TEST_NUMBER",
-      description: "A test number variable",
-      type: "number",
-    })
-
-    process.env.TEST_NUMBER = "42"
-    expect(env.TEST_NUMBER).toBe(42)
-  })
-
-  test("should throw error for invalid number", () => {
-    registerEnvVar({
-      name: "TEST_INVALID_NUMBER",
-      description: "A test number variable",
-      type: "number",
-    })
-
-    process.env.TEST_INVALID_NUMBER = "not_a_number"
-
-    expect(() => env.TEST_INVALID_NUMBER).toThrow("must be a valid number")
-  })
-
-  test("should use default values when env var not set", () => {
-    registerEnvVar({
-      name: "TEST_DEFAULT",
-      description: "A test variable with default",
-      type: "string",
-      default: "default_value",
-    })
-
-    // Don't set the env var
-    expect(env.TEST_DEFAULT).toBe("default_value")
-  })
-
-  test("should throw error for required env var not set", () => {
-    registerEnvVar({
-      name: "TEST_REQUIRED",
-      description: "A required test variable",
-    })
-
-    expect(() => env.TEST_REQUIRED).toThrow("Required environment variable TEST_REQUIRED is not set")
-  })
-
-  test("should throw error for unregistered env var", () => {
-    expect(() => env.UNREGISTERED_VAR).toThrow("Environment variable UNREGISTERED_VAR is not registered")
-  })
-
-  test("should support proxy enumeration", () => {
-    registerEnvVar({
-      name: "TEST_ENUM_1",
-      description: "First test var",
-      default: "value1",
-    })
-
-    registerEnvVar({
-      name: "TEST_ENUM_2",
-      description: "Second test var",
-      default: "value2",
-    })
-
-    const keys = Object.keys(env)
-    expect(keys).toContain("TEST_ENUM_1")
-    expect(keys).toContain("TEST_ENUM_2")
-  })
-
-  test("should support 'in' operator", () => {
-    registerEnvVar({
-      name: "TEST_IN_OPERATOR",
-      description: "Test for 'in' operator",
-      default: "test",
-    })
-
-    expect("TEST_IN_OPERATOR" in env).toBe(true)
-    expect("NON_EXISTENT" in env).toBe(false)
-  })
-
-  test("should allow re-registering identical configuration", () => {
-    const config = {
-      name: "TEST_IDENTICAL",
-      description: "Test for identical re-registration",
-      type: "boolean" as const,
-      default: false,
-    }
-
-    registerEnvVar(config)
-    // Should not throw
-    registerEnvVar(config)
-
-    expect("TEST_IDENTICAL" in env).toBe(true)
-  })
-
-  test("should throw when re-registering with different type", () => {
-    registerEnvVar({
-      name: "TEST_DIFFERENT_TYPE",
-      description: "Test for different type",
-      type: "string",
-    })
-
-    expect(() => {
-      registerEnvVar({
-        name: "TEST_DIFFERENT_TYPE",
-        description: "Test for different type",
-        type: "boolean",
-      })
-    }).toThrow("already registered with different configuration")
-  })
-
-  test("should throw when re-registering with different default", () => {
-    registerEnvVar({
-      name: "TEST_DIFFERENT_DEFAULT",
-      description: "Test for different default",
-      type: "string",
-      default: "first",
-    })
-
-    expect(() => {
-      registerEnvVar({
-        name: "TEST_DIFFERENT_DEFAULT",
-        description: "Test for different default",
-        type: "string",
-        default: "second",
-      })
-    }).toThrow("already registered with different configuration")
-  })
-
-  test("should throw when re-registering with different description", () => {
-    registerEnvVar({
-      name: "TEST_DIFFERENT_DESC",
-      description: "First description",
-      type: "string",
-    })
-
-    expect(() => {
-      registerEnvVar({
-        name: "TEST_DIFFERENT_DESC",
-        description: "Second description",
-        type: "string",
-      })
-    }).toThrow("already registered with different configuration")
-  })
-})

package/src/lib/env.ts

@@ -1,209 +0,0 @@
-import { singleton } from "./singleton.js"
-
-/**
- * Environment variable registry
- *
- * Usage:
- * ```ts
- * import { registerEnvVar, env } from "./lib/env.ts";
- *
- * // Register environment variables
- * registerEnvVar({
- *   name: "DEBUG",
- *   description: "Enable debug logging",
- *   type: "boolean",
- *   default: false
- * });
- *
- * registerEnvVar({
- *   name: "PORT",
- *   description: "Server port number",
- *   type: "number",
- *   default: 3000
- * });
- *
- * // Access environment variables
- * if (env.DEBUG) {
- *   console.log("Debug mode enabled");
- * }
- *
- * const port = env.PORT; // number
- * ```
- */
-
-export interface EnvVarConfig {
-  name: string
-  description: string
-  default?: string | boolean | number
-  type?: "string" | "boolean" | "number"
-}
-
-export const envRegistry: Record<string, EnvVarConfig> = singleton("env-registry", () => ({}))
-
-export function registerEnvVar(config: EnvVarConfig): void {
-  const existing = envRegistry[config.name]
-  if (existing) {
-    if (
-      existing.description !== config.description ||
-      existing.type !== config.type ||
-      existing.default !== config.default
-    ) {
-      throw new Error(
-        `Environment variable "${config.name}" is already registered with different configuration. ` +
-          `Existing: ${JSON.stringify(existing)}, New: ${JSON.stringify(config)}`,
-      )
-    }
-    return
-  }
-  envRegistry[config.name] = config
-}
-
-function normalizeBoolean(value: string): boolean {
-  const lowerValue = value.toLowerCase()
-  return ["true", "1", "on", "yes"].includes(lowerValue)
-}
-
-function parseEnvValue(config: EnvVarConfig): string | boolean | number {
-  const envValue = process.env[config.name]
-
-  if (envValue === undefined && config.default !== undefined) {
-    return config.default
-  }
-
-  if (envValue === undefined) {
-    throw new Error(`Required environment variable ${config.name} is not set. ${config.description}`)
-  }
-
-  switch (config.type) {
-    case "boolean":
-      return typeof envValue === "boolean" ? envValue : normalizeBoolean(envValue)
-    case "number":
-      const numValue = Number(envValue)
-      if (isNaN(numValue)) {
-        throw new Error(`Environment variable ${config.name} must be a valid number, got: ${envValue}`)
-      }
-      return numValue
-    case "string":
-    default:
-      return envValue
-  }
-}
-
-class EnvStore {
-  private parsedValues: Map<string, string | boolean | number> = new Map()
-
-  get(key: string): any {
-    if (this.parsedValues.has(key)) {
-      return this.parsedValues.get(key)!
-    }
-
-    if (!(key in envRegistry)) {
-      throw new Error(`Environment variable ${key} is not registered.`)
-    }
-
-    try {
-      const value = parseEnvValue(envRegistry[key])
-      this.parsedValues.set(key, value)
-      return value
-    } catch (error) {
-      throw new Error(`Failed to parse env var ${key}: ${error instanceof Error ? error.message : String(error)}`)
-    }
-  }
-
-  has(key: string): boolean {
-    return key in envRegistry
-  }
-
-  clearCache(): void {
-    this.parsedValues.clear()
-  }
-}
-
-const envStore = singleton("env-store", () => new EnvStore())
-
-export function clearEnvCache(): void {
-  envStore.clearCache()
-}
-
-export function generateEnvMarkdown(): string {
-  const configs = Object.values(envRegistry)
-
-  if (configs.length === 0) {
-    return "# Environment Variables\n\nNo environment variables registered.\n"
-  }
-
-  let markdown = "# Environment Variables\n\n"
-
-  for (const config of configs) {
-    markdown += `## ${config.name}\n\n`
-    markdown += `${config.description}\n\n`
-
-    markdown += `**Type:** \`${config.type || "string"}\`  \n`
-
-    if (config.default !== undefined) {
-      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default)
-      markdown += `**Default:** \`${defaultValue}\`\n`
-    } else {
-      markdown += "**Default:** *Required*\n"
-    }
-
-    markdown += "\n"
-  }
-
-  return markdown
-}
-
-export function generateEnvColored(): string {
-  const configs = Object.values(envRegistry)
-
-  if (configs.length === 0) {
-    return "\x1b[1;36mEnvironment Variables\x1b[0m\n\nNo environment variables registered.\n"
-  }
-
-  let output = "\x1b[1;36mEnvironment Variables\x1b[0m\n\n"
-
-  for (const config of configs) {
-    output += `\x1b[1;33m${config.name}\x1b[0m\n`
-    output += `${config.description}\n`
-    output += `\x1b[32mType:\x1b[0m \x1b[36m${config.type || "string"}\x1b[0m\n`
-
-    if (config.default !== undefined) {
-      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default)
-      output += `\x1b[32mDefault:\x1b[0m \x1b[35m${defaultValue}\x1b[0m\n`
-    } else {
-      output += `\x1b[32mDefault:\x1b[0m \x1b[31mRequired\x1b[0m\n`
-    }
-
-    output += "\n"
-  }
-
-  return output
-}
-
-export const env = new Proxy({} as Record<string, any>, {
-  get(target, prop: string) {
-    if (typeof prop !== "string") {
-      return undefined
-    }
-    return envStore.get(prop)
-  },
-
-  has(target, prop: string) {
-    return envStore.has(prop)
-  },
-
-  ownKeys() {
-    return Object.keys(envRegistry)
-  },
-
-  getOwnPropertyDescriptor(target, prop: string) {
-    if (envStore.has(prop)) {
-      return {
-        enumerable: true,
-        configurable: true,
-        get: () => envStore.get(prop),
-      }
-    }
-    return undefined
-  },
-})

package/src/lib/extmarks-history.ts

@@ -1,51 +0,0 @@
-import type { Extmark } from "./extmarks.js"
-
-export interface ExtmarksSnapshot {
-  extmarks: Map<number, Extmark>
-  nextId: number
-}
-
-export class ExtmarksHistory {
-  private undoStack: ExtmarksSnapshot[] = []
-  private redoStack: ExtmarksSnapshot[] = []
-
-  saveSnapshot(extmarks: Map<number, Extmark>, nextId: number): void {
-    const snapshot: ExtmarksSnapshot = {
-      extmarks: new Map(Array.from(extmarks.entries()).map(([id, extmark]) => [id, { ...extmark }])),
-      nextId,
-    }
-    this.undoStack.push(snapshot)
-    this.redoStack = []
-  }
-
-  undo(): ExtmarksSnapshot | null {
-    if (this.undoStack.length === 0) return null
-    return this.undoStack.pop()!
-  }
-
-  redo(): ExtmarksSnapshot | null {
-    if (this.redoStack.length === 0) return null
-    return this.redoStack.pop()!
-  }
-
-  pushRedo(snapshot: ExtmarksSnapshot): void {
-    this.redoStack.push(snapshot)
-  }
-
-  pushUndo(snapshot: ExtmarksSnapshot): void {
-    this.undoStack.push(snapshot)
-  }
-
-  clear(): void {
-    this.undoStack = []
-    this.redoStack = []
-  }
-
-  canUndo(): boolean {
-    return this.undoStack.length > 0
-  }
-
-  canRedo(): boolean {
-    return this.redoStack.length > 0
-  }
-}