@xincli/opentui-core 0.4.6

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.js"
+
+// 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
+  }
+}