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

package/src/indicators/zlema.ts

@@ -1,42 +0,0 @@
-import { KLineChartError } from '../errors'
-/**
- * ZLEMA — Zero-Lag Exponential Moving Average (Ehlers).
- *
- * Removes EMA lag by feeding the EMA a "momentum-adjusted" series:
- *   lag = floor((period - 1) / 2)
- *   adj[i] = price[i] + (price[i] - price[i - lag])
- *   zlema  = EMA(adj, period)
- *
- * Output length === input length. Indices < lag are NaN (no adjustment
- * available); the EMA seeds on the first valid sample.
- */
-
-export interface ZlemaOptions {
-  period: number
-}
-
-export function computeZLEMA(prices: ReadonlyArray<number>, opts: ZlemaOptions): Float64Array {
-  const { period } = opts
-  if (period < 2 || !Number.isFinite(period))
-    throw new KLineChartError('INDICATOR_INVALID_PARAM', 'computeZLEMA: period must be >= 2')
-
-  const out = new Float64Array(prices.length)
-  const lag = Math.floor((period - 1) / 2)
-  const k = 2 / (period + 1)
-
-  let ema = Number.NaN
-  for (let i = 0; i < prices.length; i++) {
-    if (i < lag) {
-      out[i] = Number.NaN
-      continue
-    }
-    const adj = 2 * (prices[i] as number) - (prices[i - lag] as number)
-    if (Number.isNaN(ema)) {
-      ema = adj
-    } else {
-      ema = k * adj + (1 - k) * ema
-    }
-    out[i] = ema
-  }
-  return out
-}

package/src/input/__tests__/gesture.test.ts

@@ -1,271 +0,0 @@
-/**
- * Tests for `createGestureRecognizer`.
- *
- * Coverage:
- *   1. State machine — idle / tracking / pan / pinch transitions.
- *   2. Tap — single pointer down/up within deadzone.
- *   3. Pan — primary pointer escapes deadzone, emits panStart + pan + panEnd.
- *   4. Swipe — pan with fast release crosses velocity threshold → swipe.
- *   5. Pinch — two pointers down, scale computed against initial distance.
- *   6. Pinch → tracking demotion when one of the two pointers releases.
- *   7. cancel() resets without emit.
- *   8. Config validation — negative deadzone / velocity rejected.
- *   9. dispose() makes everything a no-op.
- */
-
-import { describe, it, expect } from 'vitest'
-
-import { createGestureRecognizer, type PointerEventLike, type GestureEvent } from '..'
-import { isKLineChartError } from '../../errors'
-
-function pt(id: number, x: number, y: number, ts: number): PointerEventLike {
-  return { pointerId: id, x, y, timestamp: ts }
-}
-
-/**
- * Drive the recognizer and collect every emitted event in order.
- */
-function drive(
-  g: ReturnType<typeof createGestureRecognizer>,
-  steps: Array<['down' | 'move' | 'up', PointerEventLike]>,
-): GestureEvent[] {
-  const out: GestureEvent[] = []
-  g.events.subscribe(() => {
-    const e = g.events.peek()
-    if (e !== null) out.push(e)
-  })
-  for (const [op, e] of steps) {
-    if (op === 'down') g.onPointerDown(e)
-    else if (op === 'move') g.onPointerMove(e)
-    else g.onPointerUp(e)
-  }
-  return out
-}
-
-// ---------------------------------------------------------------------------
-// Tap
-// ---------------------------------------------------------------------------
-
-describe('tap', () => {
-  it('down + up within deadzone emits a tap', () => {
-    const g = createGestureRecognizer({ panDeadzone: 6 })
-    const events = drive(g, [
-      ['down', pt(1, 100, 100, 0)],
-      ['up', pt(1, 102, 101, 50)],
-    ])
-    expect(events.map((e) => e.type)).toEqual(['tap'])
-    expect(g.state.peek()).toBe('idle')
-  })
-
-  it('down + up at exact same point emits a tap (no movement at all)', () => {
-    const g = createGestureRecognizer()
-    const events = drive(g, [
-      ['down', pt(1, 50, 50, 0)],
-      ['up', pt(1, 50, 50, 100)],
-    ])
-    expect(events.map((e) => e.type)).toEqual(['tap'])
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Pan
-// ---------------------------------------------------------------------------
-
-describe('pan', () => {
-  it('promotes to pan when movement escapes deadzone', () => {
-    const g = createGestureRecognizer({ panDeadzone: 6, swipeMinVelocity: 999 })
-    const events = drive(g, [
-      ['down', pt(1, 100, 100, 0)],
-      ['move', pt(1, 102, 102, 10)],
-      ['move', pt(1, 120, 100, 20)], // 20px from start → past deadzone
-      ['move', pt(1, 140, 100, 30)],
-      ['up', pt(1, 140, 100, 1000)], // slow release → panEnd, not swipe
-    ])
-    const types = events.map((e) => e.type)
-    expect(types).toContain('panStart')
-    expect(types.filter((t) => t === 'pan').length).toBeGreaterThanOrEqual(1)
-    expect(types[types.length - 1]).toBe('panEnd')
-  })
-
-  it('panStart fires exactly once per gesture', () => {
-    const g = createGestureRecognizer({ panDeadzone: 6, swipeMinVelocity: 999 })
-    const events = drive(g, [
-      ['down', pt(1, 0, 0, 0)],
-      ['move', pt(1, 20, 0, 10)],
-      ['move', pt(1, 40, 0, 20)],
-      ['move', pt(1, 60, 0, 30)],
-      ['up', pt(1, 60, 0, 1000)],
-    ])
-    expect(events.filter((e) => e.type === 'panStart').length).toBe(1)
-  })
-
-  it('pan events carry running dx/dy', () => {
-    const g = createGestureRecognizer({ panDeadzone: 0, swipeMinVelocity: 999 })
-    const events = drive(g, [
-      ['down', pt(1, 0, 0, 0)],
-      ['move', pt(1, 10, 5, 10)],
-      ['move', pt(1, 30, 12, 20)],
-      ['up', pt(1, 30, 12, 1000)],
-    ])
-    const pans = events.filter((e): e is Extract<GestureEvent, { type: 'pan' }> => e.type === 'pan')
-    // First pan: dx = 10 - 0 = 10, dy = 5 - 0 = 5
-    expect(pans[0]?.dx).toBe(10)
-    expect(pans[0]?.dy).toBe(5)
-    // Second pan: dx = 30 - 10 = 20, dy = 12 - 5 = 7
-    expect(pans[1]?.dx).toBe(20)
-    expect(pans[1]?.dy).toBe(7)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Swipe
-// ---------------------------------------------------------------------------
-
-describe('swipe', () => {
-  it('fast release after pan emits swipe instead of panEnd', () => {
-    const g = createGestureRecognizer({
-      panDeadzone: 6,
-      swipeMinVelocity: 0.5,
-      swipeVelocityWindowMs: 100,
-    })
-    // 100px in 50ms → 2 px/ms, comfortably above 0.5
-    const events = drive(g, [
-      ['down', pt(1, 0, 0, 0)],
-      ['move', pt(1, 20, 0, 10)],
-      ['move', pt(1, 60, 0, 30)],
-      ['move', pt(1, 100, 0, 50)],
-      ['up', pt(1, 100, 0, 50)],
-    ])
-    const last = events[events.length - 1]
-    expect(last?.type).toBe('swipe')
-    const swipe = last as Extract<GestureEvent, { type: 'swipe' }>
-    expect(swipe.vx).toBeGreaterThan(0.5)
-  })
-
-  it('slow release after pan emits panEnd, not swipe', () => {
-    const g = createGestureRecognizer({
-      panDeadzone: 6,
-      swipeMinVelocity: 0.5,
-      swipeVelocityWindowMs: 100,
-    })
-    // 20px in 200ms → 0.1 px/ms, below threshold
-    const events = drive(g, [
-      ['down', pt(1, 0, 0, 0)],
-      ['move', pt(1, 10, 0, 100)],
-      ['move', pt(1, 20, 0, 200)],
-      ['up', pt(1, 20, 0, 200)],
-    ])
-    expect(events[events.length - 1]?.type).toBe('panEnd')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Pinch
-// ---------------------------------------------------------------------------
-
-describe('pinch', () => {
-  it('second pointer down → pinchStart', () => {
-    const g = createGestureRecognizer()
-    const events = drive(g, [
-      ['down', pt(1, 0, 0, 0)],
-      ['down', pt(2, 100, 0, 10)],
-    ])
-    const start = events.find((e) => e.type === 'pinchStart') as
-      | Extract<GestureEvent, { type: 'pinchStart' }>
-      | undefined
-    expect(start).toBeDefined()
-    expect(start?.cx).toBe(50)
-    expect(start?.distance).toBe(100)
-    expect(g.state.peek()).toBe('pinch')
-  })
-
-  it('scale doubles when distance doubles', () => {
-    const g = createGestureRecognizer()
-    const events = drive(g, [
-      ['down', pt(1, 0, 0, 0)],
-      ['down', pt(2, 100, 0, 10)],
-      ['move', pt(2, 200, 0, 20)], // distance 200, started at 100 → scale 2
-    ])
-    const pinches = events.filter(
-      (e): e is Extract<GestureEvent, { type: 'pinch' }> => e.type === 'pinch',
-    )
-    expect(pinches[pinches.length - 1]?.scale).toBeCloseTo(2, 10)
-  })
-
-  it('lifting one finger emits pinchEnd and demotes to tracking', () => {
-    const g = createGestureRecognizer()
-    const events = drive(g, [
-      ['down', pt(1, 0, 0, 0)],
-      ['down', pt(2, 100, 0, 10)],
-      ['up', pt(2, 100, 0, 20)],
-    ])
-    expect(events.find((e) => e.type === 'pinchEnd')).toBeDefined()
-    expect(g.state.peek()).toBe('tracking')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Cancel
-// ---------------------------------------------------------------------------
-
-describe('cancel', () => {
-  it('resets to idle without emitting', () => {
-    const g = createGestureRecognizer()
-    const seen: GestureEvent[] = []
-    g.events.subscribe(() => {
-      const e = g.events.peek()
-      if (e !== null) seen.push(e)
-    })
-    g.onPointerDown(pt(1, 0, 0, 0))
-    g.onPointerMove(pt(1, 100, 0, 10))
-    const before = seen.length
-    g.cancel()
-    expect(g.state.peek()).toBe('idle')
-    expect(seen.length).toBe(before) // no emit on cancel
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Config validation
-// ---------------------------------------------------------------------------
-
-describe('options validation', () => {
-  it('rejects negative panDeadzone', () => {
-    try {
-      createGestureRecognizer({ panDeadzone: -1 })
-      expect.fail('expected throw')
-    } catch (e) {
-      expect(isKLineChartError(e, 'INVALID_PARAM')).toBe(true)
-    }
-  })
-
-  it('rejects negative swipeMinVelocity', () => {
-    try {
-      createGestureRecognizer({ swipeMinVelocity: -0.1 })
-      expect.fail('expected throw')
-    } catch (e) {
-      expect(isKLineChartError(e, 'INVALID_PARAM')).toBe(true)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Dispose
-// ---------------------------------------------------------------------------
-
-describe('dispose', () => {
-  it('makes pointer handlers and cancel into no-ops', () => {
-    const g = createGestureRecognizer()
-    g.dispose()
-    const seen: GestureEvent[] = []
-    g.events.subscribe(() => {
-      const e = g.events.peek()
-      if (e !== null) seen.push(e)
-    })
-    g.onPointerDown(pt(1, 0, 0, 0))
-    g.onPointerMove(pt(1, 100, 0, 10))
-    g.onPointerUp(pt(1, 100, 0, 20))
-    expect(seen).toEqual([])
-    expect(g.state.peek()).toBe('idle')
-  })
-})

package/src/input/__tests__/keyboard.test.ts

@@ -1,310 +0,0 @@
-/**
- * Tests for `createShortcutRegistry` + the parser helpers.
- *
- * Coverage:
- *   1. parseCombo  — happy paths, all modifier aliases, errors on
- *      malformed inputs (empty, no key, multi-key).
- *   2. canonicalCombo — canonical order, modifier-order independence,
- *      single-letter uppercasing, named-key preservation.
- *   3. register / unregister / findByCombo — basic CRUD.
- *   4. Conflict detection — same combo, different ids throws.
- *   5. Re-binding same id to a new combo drops the old binding.
- *   6. findByKeyboardEvent — happy path + missing modifier + extra
- *      modifier + non-matching key.
- *   7. Platform Mod resolution — mac → metaKey, other → ctrlKey.
- *   8. `when` predicate gates lookup.
- *   9. dispose() makes everything a no-op.
- */
-
-import { describe, it, expect } from 'vitest'
-
-import { createShortcutRegistry, parseCombo, canonicalCombo, type KeyboardEventLike } from '..'
-import { isKLineChartError } from '../../errors'
-
-function evt(over: Partial<KeyboardEventLike>): KeyboardEventLike {
-  return {
-    key: '',
-    ctrlKey: false,
-    metaKey: false,
-    altKey: false,
-    shiftKey: false,
-    ...over,
-  }
-}
-
-// ---------------------------------------------------------------------------
-// parseCombo
-// ---------------------------------------------------------------------------
-
-describe('parseCombo', () => {
-  it('parses a simple letter', () => {
-    const p = parseCombo('k')
-    expect(p.key).toBe('k')
-    expect(p.requiresMod).toBe(false)
-    expect(p.ctrlKey).toBe(false)
-  })
-
-  it.each([
-    ['Mod+K', { requiresMod: true, key: 'K' }],
-    ['Ctrl+K', { ctrlKey: true, key: 'K' }],
-    ['Control+K', { ctrlKey: true, key: 'K' }],
-    ['Meta+K', { metaKey: true, key: 'K' }],
-    ['Cmd+K', { metaKey: true, key: 'K' }],
-    ['Command+K', { metaKey: true, key: 'K' }],
-    ['Alt+K', { altKey: true, key: 'K' }],
-    ['Option+K', { altKey: true, key: 'K' }],
-    ['Shift+K', { shiftKey: true, key: 'K' }],
-  ] as const)('%s parses modifier correctly', (src, expected) => {
-    const p = parseCombo(src)
-    for (const [k, v] of Object.entries(expected)) {
-      expect((p as unknown as Record<string, unknown>)[k]).toBe(v)
-    }
-  })
-
-  it('parses named keys', () => {
-    expect(parseCombo('ArrowRight').key).toBe('ArrowRight')
-    expect(parseCombo('Shift+ArrowRight').shiftKey).toBe(true)
-    expect(parseCombo('F5').key).toBe('F5')
-  })
-
-  it('throws on empty input', () => {
-    try {
-      parseCombo('')
-      expect.fail('expected throw')
-    } catch (e) {
-      expect(isKLineChartError(e, 'INVALID_PARAM')).toBe(true)
-    }
-  })
-
-  it('throws on only modifiers, no key', () => {
-    try {
-      parseCombo('Shift+Mod')
-      expect.fail('expected throw')
-    } catch (e) {
-      expect(isKLineChartError(e, 'INVALID_PARAM')).toBe(true)
-    }
-  })
-
-  it('throws on multiple non-modifier keys', () => {
-    try {
-      parseCombo('K+J')
-      expect.fail('expected throw')
-    } catch (e) {
-      expect(isKLineChartError(e, 'INVALID_PARAM')).toBe(true)
-    }
-  })
-
-  it('ignores extra whitespace', () => {
-    expect(parseCombo('  Mod + K ').key).toBe('K')
-    expect(parseCombo('  Mod + K ').requiresMod).toBe(true)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// canonicalCombo
-// ---------------------------------------------------------------------------
-
-describe('canonicalCombo', () => {
-  it('sorts modifiers into canonical order', () => {
-    expect(canonicalCombo('Shift+Mod+K')).toBe('Mod+Shift+K')
-    expect(canonicalCombo('Alt+Shift+Mod+K')).toBe('Mod+Alt+Shift+K')
-  })
-
-  it('uppercases single-letter keys', () => {
-    expect(canonicalCombo('mod+k')).toBe('Mod+K')
-  })
-
-  it('preserves named-key casing', () => {
-    expect(canonicalCombo('shift+arrowright')).toBe('Shift+arrowright')
-    expect(canonicalCombo('Shift+ArrowRight')).toBe('Shift+ArrowRight')
-  })
-
-  it('is idempotent', () => {
-    const c = canonicalCombo('alt+shift+mod+k')
-    expect(canonicalCombo(c)).toBe(c)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// register / unregister / findByCombo
-// ---------------------------------------------------------------------------
-
-describe('register / unregister / findByCombo', () => {
-  it('round-trips a registered shortcut by canonical combo', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'pan.left', label: 'Pan left', combo: 'ArrowLeft', command: 'pan' })
-    expect(r.findByCombo('ArrowLeft')?.id).toBe('pan.left')
-    expect(r.shortcuts.peek()).toHaveLength(1)
-  })
-
-  it('canonicalises during lookup', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'open', label: 'Open', combo: 'Mod+K', command: 'open' })
-    expect(r.findByCombo('Shift+Mod+K')).toBeNull()
-    expect(r.findByCombo('Mod+K')?.id).toBe('open')
-  })
-
-  it('unregister removes the binding', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'open', label: 'Open', combo: 'Mod+K', command: 'open' })
-    r.unregister('open')
-    expect(r.findByCombo('Mod+K')).toBeNull()
-    expect(r.shortcuts.peek()).toHaveLength(0)
-  })
-
-  it('unregistering an unknown id is a no-op', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    expect(() => r.unregister('nope')).not.toThrow()
-  })
-
-  it('throws on empty id', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    try {
-      r.register({ id: '', label: '', combo: 'K', command: 'x' })
-      expect.fail('expected throw')
-    } catch (e) {
-      expect(isKLineChartError(e, 'INVALID_PARAM')).toBe(true)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Conflict detection
-// ---------------------------------------------------------------------------
-
-describe('conflict detection', () => {
-  it('throws when a second id registers the same canonical combo', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'a', label: 'A', combo: 'Mod+K', command: 'aCmd' })
-    try {
-      r.register({ id: 'b', label: 'B', combo: 'Shift+Mod+K', command: 'bCmd' })
-      // Note: Shift+Mod+K canonicalises differently, so this is the
-      // POSITIVE path — the test below covers the conflict.
-    } catch {
-      expect.fail('Shift+Mod+K is a different combo and must not conflict')
-    }
-    try {
-      r.register({ id: 'c', label: 'C', combo: 'Mod+K', command: 'cCmd' })
-      expect.fail('expected conflict throw')
-    } catch (e) {
-      expect(isKLineChartError(e, 'INVALID_PARAM')).toBe(true)
-      expect((e as Error).message).toContain('a')
-    }
-  })
-
-  it('re-registering the same id with the same combo is a no-op', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'a', label: 'A', combo: 'Mod+K', command: 'aCmd' })
-    expect(() =>
-      r.register({ id: 'a', label: 'A-renamed', combo: 'Mod+K', command: 'aCmd' }),
-    ).not.toThrow()
-    expect(r.findByCombo('Mod+K')?.label).toBe('A-renamed')
-  })
-
-  it('re-binding same id to a different combo drops the old binding', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'a', label: 'A', combo: 'Mod+K', command: 'aCmd' })
-    r.register({ id: 'a', label: 'A', combo: 'Mod+J', command: 'aCmd' })
-    expect(r.findByCombo('Mod+K')).toBeNull()
-    expect(r.findByCombo('Mod+J')?.id).toBe('a')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// findByKeyboardEvent
-// ---------------------------------------------------------------------------
-
-describe('findByKeyboardEvent', () => {
-  it('matches a basic letter', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'r', label: 'Reset', combo: 'R', command: 'reset' })
-    expect(r.findByKeyboardEvent(evt({ key: 'r' }))?.id).toBe('r')
-    expect(r.findByKeyboardEvent(evt({ key: 'R' }))?.id).toBe('r')
-  })
-
-  it('rejects when modifier missing', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'open', label: 'Open', combo: 'Mod+K', command: 'open' })
-    expect(r.findByKeyboardEvent(evt({ key: 'k' }))).toBeNull()
-  })
-
-  it('rejects when extra modifier present', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'r', label: 'Reset', combo: 'R', command: 'reset' })
-    expect(r.findByKeyboardEvent(evt({ key: 'r', shiftKey: true }))).toBeNull()
-  })
-
-  it('rejects when key differs', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'open', label: 'Open', combo: 'Mod+K', command: 'open' })
-    expect(r.findByKeyboardEvent(evt({ key: 'j', ctrlKey: true }))).toBeNull()
-  })
-
-  it('matches named keys', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'panL', label: 'Pan left', combo: 'ArrowLeft', command: 'pan' })
-    expect(r.findByKeyboardEvent(evt({ key: 'ArrowLeft' }))?.id).toBe('panL')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Platform Mod resolution
-// ---------------------------------------------------------------------------
-
-describe('platform Mod resolution', () => {
-  it('on mac: Mod matches metaKey, not ctrlKey', () => {
-    const r = createShortcutRegistry({ platform: 'mac' })
-    r.register({ id: 'open', label: 'Open', combo: 'Mod+K', command: 'open' })
-    expect(r.findByKeyboardEvent(evt({ key: 'k', metaKey: true }))?.id).toBe('open')
-    expect(r.findByKeyboardEvent(evt({ key: 'k', ctrlKey: true }))).toBeNull()
-  })
-
-  it('on win: Mod matches ctrlKey, not metaKey', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'open', label: 'Open', combo: 'Mod+K', command: 'open' })
-    expect(r.findByKeyboardEvent(evt({ key: 'k', ctrlKey: true }))?.id).toBe('open')
-    expect(r.findByKeyboardEvent(evt({ key: 'k', metaKey: true }))).toBeNull()
-  })
-
-  it('explicit Ctrl + Meta still bind on both platforms', () => {
-    const r = createShortcutRegistry({ platform: 'mac' })
-    r.register({ id: 'a', label: 'A', combo: 'Ctrl+K', command: 'a' })
-    expect(r.findByKeyboardEvent(evt({ key: 'k', ctrlKey: true }))?.id).toBe('a')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// `when` predicate
-// ---------------------------------------------------------------------------
-
-describe('when predicate', () => {
-  it('false predicate skips the shortcut', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    let active = false
-    r.register({
-      id: 'esc',
-      label: 'Cancel tool',
-      combo: 'Escape',
-      command: 'cancel',
-      when: () => active,
-    })
-    expect(r.findByKeyboardEvent(evt({ key: 'Escape' }))).toBeNull()
-    active = true
-    expect(r.findByKeyboardEvent(evt({ key: 'Escape' }))?.id).toBe('esc')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// dispose
-// ---------------------------------------------------------------------------
-
-describe('dispose', () => {
-  it('makes register / unregister / findByCombo no-ops', () => {
-    const r = createShortcutRegistry({ platform: 'win' })
-    r.register({ id: 'a', label: 'A', combo: 'K', command: 'a' })
-    r.dispose()
-    expect(r.findByCombo('K')).toBeNull()
-    expect(() => r.register({ id: 'b', label: 'B', combo: 'J', command: 'b' })).not.toThrow()
-    expect(r.findByCombo('J')).toBeNull()
-  })
-})