@fairyhunter13/opentui-core 0.1.113 → 0.1.114

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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,228 @@
+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

@@ -0,0 +1,209 @@
+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

@@ -0,0 +1,51 @@
+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
+  }
+}