@363045841yyt/klinechart-core 0.8.14 → 0.9.0-alpha.0

package/src/input/keyboard.ts

@@ -1,371 +0,0 @@
-/**
- * Keyboard shortcut registry — framework-agnostic, signal-based.
- *
- * Why this exists: every chart library either hard-codes shortcuts (TV-style
- * inflexibility) or punts to the host app (every adapter reinvents the
- * wheel). The registry below is the shared primitive: controllers and
- * adapters publish `ShortcutDef[]`s, host apps query by combo, and the
- * normalisation/conflict layer lives in one place.
- *
- * Design choices:
- *
- *   - Combos are STRINGS like `'Mod+K'`, `'Shift+ArrowRight'`,
- *     `'Alt+Mod+0'`. Parsed deterministically; whitespace ignored;
- *     modifier order in the source doesn't matter (`'Shift+Mod+K'`
- *     and `'Mod+Shift+K'` normalise to the same canonical form).
- *
- *   - `Mod` is platform-agnostic: maps to `Meta` on macOS and `Ctrl`
- *     elsewhere. Host apps query with their own `KeyboardEvent` and
- *     the registry hands back the matching shortcut.
- *
- *   - Conflict detection: registering two `ShortcutDef`s with the same
- *     normalised combo throws `KLineChartError('INPUT_SHORTCUT_CONFLICT')`.
- *     Pulls the prior registration into the error message so the
- *     developer sees both ids.
- *
- *   - The signal-based shape mirrors every other controller in this
- *     package (alerts, indicators, drawing). Subscribers — typically
- *     a debug-overlay or settings UI — see the live registration list.
- *
- *   - Pure data: no `addEventListener`, no `window` access. The bridge
- *     to DOM events is the *consumer's* job, and a one-liner:
- *
- *       document.addEventListener('keydown', e => {
- *         const hit = registry.findByKeyboardEvent(e)
- *         if (hit !== null) {
- *           e.preventDefault()
- *           runCommand(hit.command, hit.args)
- *         }
- *       })
- */
-
-import { KLineChartError } from '../errors'
-import { createSignal, type Signal } from '../reactivity'
-
-// ---------------------------------------------------------------------------
-// Public shape
-// ---------------------------------------------------------------------------
-
-/**
- * Modifier flag set. Booleans match `KeyboardEvent` getter names so consumers
- * can pass an event directly.
- */
-export interface ModifierState {
-  readonly ctrlKey: boolean
-  readonly metaKey: boolean
-  readonly altKey: boolean
-  readonly shiftKey: boolean
-}
-
-/**
- * Result of parsing a combo string. `key` is the case-preserved KeyboardEvent
- * `key` value (e.g. `'k'`, `'ArrowRight'`, `'F5'`). Modifiers are split into
- * the four boolean flags.
- *
- * `Mod` from the source string is recorded in `requiresMod`: true means
- * "match if Ctrl on non-mac OR Meta on mac"; false means the combo doesn't
- * use the platform modifier.
- */
-export interface ParsedCombo {
-  readonly key: string
-  readonly requiresMod: boolean
-  readonly ctrlKey: boolean
-  readonly metaKey: boolean
-  readonly altKey: boolean
-  readonly shiftKey: boolean
-}
-
-/**
- * The shape registered via `registry.register({...})`. `args` is opaque to
- * the registry; consumers pass it through to their command runner.
- */
-export interface ShortcutDef<TArgs = unknown> {
-  /** Stable id (e.g. `'pan.left'`). Used for unregister + error messages. */
-  readonly id: string
-  /** Human label for tooltips / settings UI. */
-  readonly label: string
-  /** Combo source string. See module header for the grammar. */
-  readonly combo: string
-  /** Opaque command identifier — typically a key into your command map. */
-  readonly command: string
-  /** Optional opaque arg payload for the command. */
-  readonly args?: TArgs
-  /**
-   * Optional gating predicate. Evaluated at `findByKeyboardEvent` time
-   * with no arguments. Returning false means the shortcut won't match.
-   * Use this for context-sensitive bindings (e.g. only fire `ESC` when
-   * a drawing tool is active).
-   */
-  readonly when?: () => boolean
-}
-
-export interface ShortcutRegistry {
-  /** Read-only signal of all currently-registered shortcuts. */
-  readonly shortcuts: Signal<ReadonlyArray<ShortcutDef>>
-  register<TArgs = unknown>(def: ShortcutDef<TArgs>): void
-  unregister(id: string): void
-  /** Lookup by raw combo string (normalised). */
-  findByCombo(combo: string): ShortcutDef | null
-  /**
-   * Lookup by KeyboardEvent. The platform is detected once at registry
-   * construction time (override via `opts.platform` for testing).
-   */
-  findByKeyboardEvent(event: KeyboardEventLike): ShortcutDef | null
-  /** Returns the canonical form of a combo, useful for tests + tooltips. */
-  canonical(combo: string): string
-  dispose(): void
-}
-
-/**
- * The fields of `KeyboardEvent` we consume. Declaring this locally avoids
- * pulling in DOM types and lets server-side smoke tests pass plain objects.
- */
-export interface KeyboardEventLike {
-  readonly key: string
-  readonly ctrlKey: boolean
-  readonly metaKey: boolean
-  readonly altKey: boolean
-  readonly shiftKey: boolean
-}
-
-export interface ShortcutRegistryOptions {
-  /**
-   * Override platform detection. `'mac'` makes `Mod → Meta`; everything
-   * else (`'win'`, `'linux'`, etc.) makes `Mod → Ctrl`. Default:
-   * sniff `navigator.platform` if available, else assume non-mac.
-   */
-  readonly platform?: 'mac' | 'win' | 'linux' | string
-}
-
-// ---------------------------------------------------------------------------
-// Parser
-// ---------------------------------------------------------------------------
-
-const MODIFIER_TOKENS = new Set([
-  'mod',
-  'ctrl',
-  'control',
-  'meta',
-  'cmd',
-  'command',
-  'alt',
-  'option',
-  'shift',
-])
-
-/**
- * Parse a combo source string into the normalised {@link ParsedCombo}.
- * Throws `KLineChartError('INVALID_PARAM')` on malformed input — empty,
- * modifiers without a key, unknown modifier token.
- */
-export function parseCombo(source: string): ParsedCombo {
-  if (typeof source !== 'string' || source.trim() === '') {
-    throw new KLineChartError('INVALID_PARAM', `parseCombo: empty combo`)
-  }
-  const tokens = source
-    .split('+')
-    .map((t) => t.trim())
-    .filter((t) => t.length > 0)
-  if (tokens.length === 0) {
-    throw new KLineChartError('INVALID_PARAM', `parseCombo: no tokens in ${JSON.stringify(source)}`)
-  }
-  let requiresMod = false
-  let ctrlKey = false
-  let metaKey = false
-  let altKey = false
-  let shiftKey = false
-  let keyToken: string | null = null
-  for (const t of tokens) {
-    const lower = t.toLowerCase()
-    if (MODIFIER_TOKENS.has(lower)) {
-      switch (lower) {
-        case 'mod':
-          requiresMod = true
-          break
-        case 'ctrl':
-        case 'control':
-          ctrlKey = true
-          break
-        case 'meta':
-        case 'cmd':
-        case 'command':
-          metaKey = true
-          break
-        case 'alt':
-        case 'option':
-          altKey = true
-          break
-        case 'shift':
-          shiftKey = true
-          break
-      }
-    } else {
-      // Non-modifier token — must be the (single) key.
-      if (keyToken !== null) {
-        throw new KLineChartError(
-          'INVALID_PARAM',
-          `parseCombo: multiple keys in ${JSON.stringify(source)} — combos take exactly one non-modifier`,
-        )
-      }
-      keyToken = t
-    }
-  }
-  if (keyToken === null) {
-    throw new KLineChartError(
-      'INVALID_PARAM',
-      `parseCombo: ${JSON.stringify(source)} has only modifiers, no key`,
-    )
-  }
-  return {
-    key: keyToken,
-    requiresMod,
-    ctrlKey,
-    metaKey,
-    altKey,
-    shiftKey,
-  }
-}
-
-/**
- * Canonicalise a combo source string. Sorts modifiers into the
- * canonical order (Mod, Ctrl, Meta, Alt, Shift) and lower-cases
- * single-letter keys. `'shift+mod+k'` → `'Mod+Shift+K'`.
- */
-export function canonicalCombo(source: string): string {
-  const p = parseCombo(source)
-  const out: string[] = []
-  if (p.requiresMod) out.push('Mod')
-  if (p.ctrlKey) out.push('Ctrl')
-  if (p.metaKey) out.push('Meta')
-  if (p.altKey) out.push('Alt')
-  if (p.shiftKey) out.push('Shift')
-  out.push(p.key.length === 1 ? p.key.toUpperCase() : p.key)
-  return out.join('+')
-}
-
-// ---------------------------------------------------------------------------
-// Platform detection
-// ---------------------------------------------------------------------------
-
-function detectPlatform(): 'mac' | 'other' {
-  const nav = (globalThis as { navigator?: { platform?: string; userAgent?: string } }).navigator
-  const platform = nav?.platform ?? nav?.userAgent ?? ''
-  return /mac/i.test(platform) ? 'mac' : 'other'
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createShortcutRegistry(opts?: ShortcutRegistryOptions): ShortcutRegistry {
-  const platformIsMac =
-    opts?.platform !== undefined ? opts.platform === 'mac' : detectPlatform() === 'mac'
-
-  const byCanonical = new Map<string, ShortcutDef>()
-  const byId = new Map<string, string>() // id → canonical
-  const shortcuts = createSignal<ReadonlyArray<ShortcutDef>>([])
-  let disposed = false
-
-  function publish(): void {
-    shortcuts.set([...byCanonical.values()])
-  }
-
-  function register<TArgs>(def: ShortcutDef<TArgs>): void {
-    if (disposed) return
-    if (def.id === '' || typeof def.id !== 'string') {
-      throw new KLineChartError(
-        'INVALID_PARAM',
-        `ShortcutRegistry.register: def.id must be a non-empty string`,
-      )
-    }
-    const canonical = canonicalCombo(def.combo)
-    const existing = byCanonical.get(canonical)
-    if (existing !== undefined && existing.id !== def.id) {
-      throw new KLineChartError(
-        'INVALID_PARAM',
-        `ShortcutRegistry.register: combo ${JSON.stringify(canonical)} is already bound to id ${JSON.stringify(existing.id)} — unregister it before re-binding to ${JSON.stringify(def.id)}`,
-      )
-    }
-    // Re-registering the same id with a new combo: drop the old binding.
-    const prevCanonical = byId.get(def.id)
-    if (prevCanonical !== undefined && prevCanonical !== canonical) {
-      byCanonical.delete(prevCanonical)
-    }
-    byCanonical.set(canonical, def as ShortcutDef)
-    byId.set(def.id, canonical)
-    publish()
-  }
-
-  function unregister(id: string): void {
-    if (disposed) return
-    const canonical = byId.get(id)
-    if (canonical === undefined) return
-    byCanonical.delete(canonical)
-    byId.delete(id)
-    publish()
-  }
-
-  function findByCombo(combo: string): ShortcutDef | null {
-    if (disposed) return null
-    return byCanonical.get(canonicalCombo(combo)) ?? null
-  }
-
-  function findByKeyboardEvent(event: KeyboardEventLike): ShortcutDef | null {
-    if (disposed) return null
-    for (const def of byCanonical.values()) {
-      const parsed = parseCombo(def.combo)
-      // Modifier match — Mod expands to platform-correct modifier.
-      const modOk = parsed.requiresMod
-        ? platformIsMac
-          ? event.metaKey && !event.ctrlKey
-          : event.ctrlKey && !event.metaKey
-        : true
-      if (!modOk) continue
-      // Explicit Ctrl / Meta / Alt / Shift must match exactly UNLESS
-      // requiresMod already accounts for the platform modifier.
-      const ctrlOk = parsed.requiresMod
-        ? !platformIsMac
-          ? event.ctrlKey
-          : event.ctrlKey === parsed.ctrlKey
-        : event.ctrlKey === parsed.ctrlKey
-      const metaOk = parsed.requiresMod
-        ? platformIsMac
-          ? event.metaKey
-          : event.metaKey === parsed.metaKey
-        : event.metaKey === parsed.metaKey
-      const altOk = event.altKey === parsed.altKey
-      const shiftOk = event.shiftKey === parsed.shiftKey
-      // Key match: case-insensitive for single-letter keys, exact for
-      // named keys (ArrowRight, F5, ...).
-      const keyOk =
-        parsed.key.length === 1
-          ? parsed.key.toLowerCase() === event.key.toLowerCase()
-          : parsed.key === event.key
-      if (!ctrlOk || !metaOk || !altOk || !shiftOk || !keyOk) continue
-      if (def.when !== undefined && !def.when()) continue
-      return def
-    }
-    return null
-  }
-
-  function canonical(combo: string): string {
-    return canonicalCombo(combo)
-  }
-
-  function dispose(): void {
-    if (disposed) return
-    disposed = true
-    byCanonical.clear()
-    byId.clear()
-  }
-
-  return {
-    shortcuts,
-    register,
-    unregister,
-    findByCombo,
-    findByKeyboardEvent,
-    canonical,
-    dispose,
-  }
-}

package/src/mcp/chartBridge.ts

@@ -1,259 +0,0 @@
-import { Effect, Fiber, pipe, Schedule } from 'effect'
-
-import { KLineChartError } from '../errors'
-import { generateUUID } from '../utils/uuid'
-
-import type { ToolCall, ToolResult, ControllerDescription, ToolCallHandler } from './types'
-
-
-export interface ChartBridgeOptions {
-  wsUrl: string
-  onToolCall: ToolCallHandler
-  sessionId?: string
-  autoReconnect?: boolean
-  reconnectDelay?: number
-  maxReconnectDelay?: number
-  heartbeatInterval?: number
-  wsImpl?: new (url: string) => WebSocket
-}
-
-export type ChartBridgeEvent = 'connected' | 'disconnected' | 'error' | 'stateChanged'
-
-type MessageHandler = (...args: unknown[]) => void
-
-export class ChartBridge {
-  readonly sessionId: string
-  private readonly autoReconnect: boolean
-  private readonly reconnectDelay: number
-  private readonly maxReconnectDelay: number
-  private readonly heartbeatInterval: number
-  private readonly onToolCall: ToolCallHandler
-
-  private readonly wsImpl: new (url: string) => WebSocket
-  private ws: WebSocket | null = null
-  private _heartbeatFiber: Fiber.Fiber<void> | null = null
-  private _reconnectFiber: Fiber.Fiber<void> | null = null
-  private _reconnectAttempt = 0
-  private destroyed = false
-
-  private listeners = new Map<ChartBridgeEvent, Set<MessageHandler>>()
-
-  onConnected?: () => void
-  onDisconnected?: () => void
-  onError?: (err: Error) => void
-  onStateChange?: () => void
-
-  constructor(options: ChartBridgeOptions) {
-    this.sessionId = options.sessionId ?? generateUUID()
-    this.autoReconnect = options.autoReconnect ?? true
-    this.reconnectDelay = options.reconnectDelay ?? 3000
-    this.maxReconnectDelay = options.maxReconnectDelay ?? 30_000
-    this.heartbeatInterval = options.heartbeatInterval ?? 30_000
-    this.onToolCall = options.onToolCall
-    this.wsImpl = options.wsImpl ?? WebSocket
-    this.wsUrl = options.wsUrl
-  }
-
-  private wsUrl: string
-
-  async connect(): Promise<void> {
-    if (this.destroyed) return
-    this.disconnect()
-
-    await Effect.runPromise(
-      pipe(
-        Effect.async<void, Error>((resume) => {
-          try {
-            const ws = new this.wsImpl(this.wsUrl)
-
-            ws.onopen = () => {
-              this._reconnectAttempt = 0
-              this.ws = ws
-              console.info(
-                `[ChartBridge] WS opened → sending register (sessionId=${this.sessionId})`,
-              )
-              ws.send(JSON.stringify({ type: 'register', sessionId: this.sessionId }))
-              this.startHeartbeat()
-              this.onConnected?.()
-              this.emit('connected')
-              resume(Effect.succeed(undefined))
-            }
-
-            ws.onmessage = (event: MessageEvent) => {
-              let msg: Record<string, unknown>
-              try {
-                msg = JSON.parse(event.data as string)
-              } catch {
-                return
-              }
-              this.handleMessage(msg)
-            }
-
-            ws.onclose = () => {
-              console.warn(`[ChartBridge] WS closed, autoReconnect=${this.autoReconnect}`)
-              this.ws = null
-              this.stopHeartbeat()
-              this.onDisconnected?.()
-              this.emit('disconnected')
-              if (this.autoReconnect && !this.destroyed) {
-                this.scheduleReconnect()
-              }
-            }
-
-            ws.onerror = () => {
-              console.error(`[ChartBridge] WS error — connection failed`)
-              const err = new KLineChartError('FETCH_FAILED', 'WebSocket connection failed')
-              this.onError?.(err)
-              this.emit('error', err)
-              resume(Effect.fail(err))
-            }
-          } catch (err) {
-            resume(Effect.fail(err as Error))
-          }
-        }),
-        Effect.timeout('15 seconds'),
-        Effect.mapError((err) => {
-          if (err instanceof KLineChartError) return err
-          return new KLineChartError('FETCH_FAILED', `Connection failed: ${String(err)}`)
-        }),
-      ),
-    )
-  }
-
-  disconnect(): void {
-    this.ws?.close()
-    this.ws = null
-    this.cancelReconnect()
-    this.stopHeartbeat()
-  }
-
-  destroy(): void {
-    this.destroyed = true
-    this._reconnectAttempt = 0
-    this.disconnect()
-    this.listeners.clear()
-  }
-
-  private handleMessage(msg: Record<string, unknown>): void {
-    switch (msg.type) {
-      case 'registered':
-        break
-
-      case 'tool:call': {
-        const call = msg.call as ToolCall
-        const requestId = msg.requestId as string
-        this.dispatchToolCall(requestId, call)
-        break
-      }
-
-      case 'ping': {
-        this.ws?.send(JSON.stringify({ type: 'pong' }))
-        break
-      }
-    }
-  }
-
-  private async dispatchToolCall(requestId: string, call: ToolCall): Promise<void> {
-    const result = await this.onToolCall(call)
-    this.sendResult(requestId, result)
-
-    if (this.onStateChange) {
-      this.onStateChange()
-    }
-    this.emit('stateChanged')
-  }
-
-  private sendResult(requestId: string, result: ToolResult): void {
-    this.ws?.send(
-      JSON.stringify({
-        type: 'tool:result',
-        requestId,
-        result,
-      }),
-    )
-  }
-
-  sendStateUpdate(descriptions: Record<string, ControllerDescription>): void {
-    this.ws?.send(
-      JSON.stringify({
-        type: 'state:update',
-        sessionId: this.sessionId,
-        descriptions,
-      }),
-    )
-  }
-
-  private startHeartbeat(): void {
-    this.stopHeartbeat()
-    this._heartbeatFiber = Effect.runFork(
-      pipe(
-        Effect.repeat(
-          Effect.sync(() => {
-            if (this.ws?.readyState === 1) {
-              this.ws.send(JSON.stringify({ type: 'ping' }))
-            }
-          }),
-          Schedule.fixed(this.heartbeatInterval),
-        ),
-        Effect.asVoid,
-      ),
-    )
-  }
-
-  private stopHeartbeat(): void {
-    if (this._heartbeatFiber) {
-      Fiber.interrupt(this._heartbeatFiber)
-      this._heartbeatFiber = null
-    }
-  }
-
-  private scheduleReconnect(): void {
-    this.cancelReconnect()
-    const attempt = this._reconnectAttempt
-    this._reconnectAttempt = attempt + 1
-
-    const base = this.reconnectDelay
-    const exponential = Math.min(base * Math.pow(2, attempt), this.maxReconnectDelay)
-    const jitter = 0.5 + Math.random() * 0.5
-    const delay = Math.round(exponential * jitter)
-
-    this._reconnectFiber = Effect.runFork(
-      pipe(
-        Effect.sleep(delay),
-        Effect.tap(() =>
-          Effect.sync(() => {
-            if (!this.destroyed) {
-              console.info(
-                `[ChartBridge] reconnect scheduled in ${delay}ms (attempt ${attempt + 1})`,
-              )
-              this.connect().catch(() => {})
-            }
-          }),
-        ),
-      ),
-    )
-  }
-
-  private cancelReconnect(): void {
-    if (this._reconnectFiber) {
-      Fiber.interrupt(this._reconnectFiber)
-      this._reconnectFiber = null
-    }
-  }
-
-  private emit(event: ChartBridgeEvent, ...args: unknown[]): void {
-    this.listeners.get(event)?.forEach((fn) => fn(...args))
-  }
-
-  on(event: ChartBridgeEvent, handler: MessageHandler): () => void {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, new Set())
-    }
-    this.listeners.get(event)!.add(handler)
-    return () => this.listeners.get(event)?.delete(handler)
-  }
-
-  off(event: ChartBridgeEvent, handler: MessageHandler): void {
-    this.listeners.get(event)?.delete(handler)
-  }
-}