oddysee-react 0.2.0-canary.0 → 0.2.0-canary.1

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.0-canary.0",
+  "version": "0.2.0-canary.1",
   "type": "module",
   "author": "Karelle Hofler",
   "main": "dist/index.js",
@@ -30,7 +30,7 @@
     "pub:test": "npm run build && npm publish --tag test"
   },
   "dependencies": {
-    "oddysee-typescript": "^0.2.0-canary.0",
+    "oddysee-typescript": "^0.2.0-canary.1",
     "react": "^19.2.0",
     "react-dom": "^19.2.0"
   },
@@ -49,5 +49,10 @@
     "typescript-eslint": "^8.46.4",
     "vite": "^7.2.4",
     "vitest": "^4.0.16"
-  }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
 }

package/__tests__/retry.test.ts

@@ -1,148 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { useHlsAudioPlayer } from '../src/use-hls-audio-player'
-
-type HookDeps = unknown[] | undefined
-
-const hookState: unknown[] = []
-let hookIndex = 0
-
-const resetHookIndex = () => {
-  hookIndex = 0
-}
-
-const clearHookState = () => {
-  hookState.length = 0
-  hookIndex = 0
-}
-
-const depsEqual = (left: HookDeps, right: HookDeps) => {
-  if (!left || !right) return false
-  if (left.length !== right.length) return false
-  return left.every((dep, index) => Object.is(dep, right[index]))
-}
-
-vi.mock('react', () => ({
-  useState: (initial: unknown) => {
-    const index = hookIndex++
-    if (!(index in hookState)) {
-      hookState[index] =
-        typeof initial === 'function' ? (initial as () => unknown)() : initial
-    }
-    const setState = (next: unknown) => {
-      hookState[index] =
-        typeof next === 'function' ? (next as (prev: unknown) => unknown)(hookState[index]) : next
-    }
-    return [hookState[index], setState]
-  },
-  useRef: (initial: unknown) => {
-    const index = hookIndex++
-    if (!hookState[index]) {
-      hookState[index] = { current: initial }
-    }
-    return hookState[index]
-  },
-  useMemo: (factory: () => unknown, deps?: HookDeps) => {
-    const index = hookIndex++
-    const record = hookState[index] as { deps: HookDeps; value: unknown } | undefined
-    if (record && depsEqual(record.deps, deps)) {
-      return record.value
-    }
-    const value = factory()
-    hookState[index] = { deps, value }
-    return value
-  },
-  useCallback: (callback: (...args: unknown[]) => unknown, deps?: HookDeps) => {
-    const index = hookIndex++
-    const record = hookState[index] as { deps: HookDeps; value: unknown } | undefined
-    if (record && depsEqual(record.deps, deps)) {
-      return record.value
-    }
-    hookState[index] = { deps, value: callback }
-    return callback
-  },
-  useEffect: () => {},
-}))
-
-const MockHLSAudioPlayer = vi.hoisted(() => {
-  return class MockHLSAudioPlayer {
-    loading = false
-    error = null
-    readyState = 0
-    isPlaying = false
-    audioElement = { currentTime: 0 }
-    beginSeek = vi.fn()
-    updateSeek = vi.fn()
-    commitSeek = vi.fn()
-    retry = vi.fn()
-    destroy = vi.fn()
-    on = vi.fn()
-    off = vi.fn()
-    setSource = vi.fn().mockResolvedValue(this)
-    play = vi.fn().mockReturnValue(this)
-    playAsync = vi.fn().mockResolvedValue(this)
-    pause = vi.fn().mockReturnValue(this)
-    setVolume = vi.fn().mockReturnValue(this)
-    getState = vi.fn(() => ({
-      track: null,
-      currentTime: 5,
-      duration: 60,
-      volume: 1,
-      loading: false,
-      error: null,
-      readyState: 0,
-      isPlaying: false,
-    }))
-    getAudioElement = vi.fn(() => this.audioElement)
-  }
-})
-
-vi.mock('oddysee-typescript', () => ({
-  HLSAudioPlayer: MockHLSAudioPlayer,
-}))
-
-const renderHook = () => {
-  resetHookIndex()
-  return useHlsAudioPlayer({})
-}
-
-const setup = () => {
-  let result = renderHook()
-  return {
-    get result() {
-      return result
-    },
-    rerender: () => {
-      result = renderHook()
-      return result
-    },
-  }
-}
-
-beforeEach(() => {
-  clearHookState()
-  vi.clearAllMocks()
-})
-
-afterEach(() => {
-  vi.clearAllMocks()
-})
-
-describe('controls.retry()', () => {
-  it('delegates to the player retry method', () => {
-    const hook = setup()
-    const player = hook.result.player as unknown as InstanceType<typeof MockHLSAudioPlayer>
-
-    hook.result.controls.retry()
-
-    expect(player.retry).toHaveBeenCalledWith(undefined, undefined)
-  })
-
-  it('passes retry arguments to the player', () => {
-    const hook = setup()
-    const player = hook.result.player as unknown as InstanceType<typeof MockHLSAudioPlayer>
-
-    hook.result.controls.retry(3, 1500)
-
-    expect(player.retry).toHaveBeenCalledWith(3, 1500)
-  })
-})

package/__tests__/seek.test.ts

@@ -1,184 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { useHlsAudioPlayer } from '../src/use-hls-audio-player'
-
-type HookDeps = unknown[] | undefined
-
-const hookState: unknown[] = []
-let hookIndex = 0
-
-const resetHookIndex = () => {
-  hookIndex = 0
-}
-
-const clearHookState = () => {
-  hookState.length = 0
-  hookIndex = 0
-}
-
-const depsEqual = (left: HookDeps, right: HookDeps) => {
-  if (!left || !right) return false
-  if (left.length !== right.length) return false
-  return left.every((dep, index) => Object.is(dep, right[index]))
-}
-
-vi.mock('react', () => ({
-  useState: (initial: unknown) => {
-    const index = hookIndex++
-    if (!(index in hookState)) {
-      hookState[index] =
-        typeof initial === 'function' ? (initial as () => unknown)() : initial
-    }
-    const setState = (next: unknown) => {
-      hookState[index] =
-        typeof next === 'function' ? (next as (prev: unknown) => unknown)(hookState[index]) : next
-    }
-    return [hookState[index], setState]
-  },
-  useRef: (initial: unknown) => {
-    const index = hookIndex++
-    if (!hookState[index]) {
-      hookState[index] = { current: initial }
-    }
-    return hookState[index]
-  },
-  useMemo: (factory: () => unknown, deps?: HookDeps) => {
-    const index = hookIndex++
-    const record = hookState[index] as { deps: HookDeps; value: unknown } | undefined
-    if (record && depsEqual(record.deps, deps)) {
-      return record.value
-    }
-    const value = factory()
-    hookState[index] = { deps, value }
-    return value
-  },
-  useCallback: (callback: (...args: unknown[]) => unknown, deps?: HookDeps) => {
-    const index = hookIndex++
-    const record = hookState[index] as { deps: HookDeps; value: unknown } | undefined
-    if (record && depsEqual(record.deps, deps)) {
-      return record.value
-    }
-    hookState[index] = { deps, value: callback }
-    return callback
-  },
-  useEffect: () => {},
-}))
-
-const MockHLSAudioPlayer = vi.hoisted(() => {
-  return class MockHLSAudioPlayer {
-  loading = false
-  error = null
-  readyState = 0
-  isPlaying = false
-  audioElement = { currentTime: 0 }
-  beginSeek = vi.fn()
-  updateSeek = vi.fn()
-  commitSeek = vi.fn()
-  destroy = vi.fn()
-  on = vi.fn()
-  off = vi.fn()
-  setSource = vi.fn().mockResolvedValue(this)
-  play = vi.fn().mockReturnValue(this)
-  playAsync = vi.fn().mockResolvedValue(this)
-  pause = vi.fn().mockReturnValue(this)
-  setVolume = vi.fn().mockReturnValue(this)
-  getState = vi.fn(() => ({
-    track: null,
-    currentTime: 5,
-    duration: 60,
-    volume: 1,
-    loading: false,
-    error: null,
-    readyState: 0,
-    isPlaying: false,
-  }))
-  getAudioElement = vi.fn(() => this.audioElement)
-  }
-})
-
-vi.mock('oddysee-typescript', () => ({
-  HLSAudioPlayer: MockHLSAudioPlayer,
-}))
-
-const renderHook = () => {
-  resetHookIndex()
-  return useHlsAudioPlayer({})
-}
-
-const setup = () => {
-  let result = renderHook()
-  return {
-    get result() {
-      return result
-    },
-    rerender: () => {
-      result = renderHook()
-      return result
-    },
-  }
-}
-
-beforeEach(() => {
-  clearHookState()
-  vi.clearAllMocks()
-})
-
-afterEach(() => {
-  vi.clearAllMocks()
-})
-
-describe('scrub.begin()', () => {
-  it('enters scrubbing mode and triggers player seek', () => {
-    const hook = setup()
-    const player = hook.result.player as unknown as InstanceType<typeof MockHLSAudioPlayer>
-
-    hook.result.scrub.begin()
-    hook.rerender()
-
-    expect(player.beginSeek).toHaveBeenCalledTimes(1)
-    expect(hook.result.scrub.isScrubbing).toBe(true)
-    expect(hook.result.scrub.displayTime).toBe(5)
-  })
-})
-
-describe('scrub.update()', () => {
-  it('updates the preview time while scrubbing', () => {
-    const hook = setup()
-
-    hook.result.scrub.begin()
-    hook.rerender()
-
-    hook.result.scrub.update(12)
-    hook.rerender()
-
-    expect(hook.result.scrub.displayTime).toBe(12)
-  })
-})
-
-describe('scrub.commit()', () => {
-  it('commits the preview time through the player', () => {
-    const hook = setup()
-    const player = hook.result.player as unknown as InstanceType<typeof MockHLSAudioPlayer>
-
-    hook.result.scrub.begin()
-    hook.rerender()
-
-    hook.result.scrub.update(12)
-    hook.result.scrub.commit()
-    hook.rerender()
-
-    expect(player.updateSeek).toHaveBeenCalledWith(12)
-    expect(player.commitSeek).toHaveBeenCalledTimes(1)
-    expect(hook.result.scrub.isScrubbing).toBe(false)
-    expect(hook.result.scrub.displayTime).toBe(5)
-  })
-
-  it('does nothing when commit is called outside scrubbing', () => {
-    const hook = setup()
-    const player = hook.result.player as unknown as InstanceType<typeof MockHLSAudioPlayer>
-
-    hook.result.scrub.commit()
-
-    expect(player.updateSeek).not.toHaveBeenCalled()
-    expect(player.commitSeek).not.toHaveBeenCalled()
-  })
-})

package/eslint.config.js

@@ -1,23 +0,0 @@
-import js from '@eslint/js'
-import globals from 'globals'
-import reactHooks from 'eslint-plugin-react-hooks'
-import reactRefresh from 'eslint-plugin-react-refresh'
-import tseslint from 'typescript-eslint'
-import { defineConfig, globalIgnores } from 'eslint/config'
-
-export default defineConfig([
-  globalIgnores(['dist']),
-  {
-    files: ['**/*.{ts,tsx}'],
-    extends: [
-      js.configs.recommended,
-      tseslint.configs.recommended,
-      reactHooks.configs.flat.recommended,
-      reactRefresh.configs.vite,
-    ],
-    languageOptions: {
-      ecmaVersion: 2020,
-      globals: globals.browser,
-    },
-  },
-])

package/src/index.ts

@@ -1,2 +0,0 @@
-export { useHlsAudioPlayer } from './use-hls-audio-player'
-export type { UseHlsAudioPlayerOptions, UseHlsAudioPlayerResult, PlayerEventMap } from './use-hls-audio-player'

package/src/use-hls-audio-player.ts

@@ -1,379 +0,0 @@
-import {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-  type ChangeEvent,
-  type PointerEvent,
-  type MouseEvent,
-  type TouchEvent,
-} from 'react'
-import {
-  HLSAudioPlayer,
-  type HLSAudioPlayerInterface,
-  type PlayerConfig,
-  type SourceOptions,
-  type PlayerEvent,
-  type PlayerError,
-  type Track,
-  type QualityLevel,
-  type PlayerState
-} 
-from 'oddysee-typescript'
-
-// Local mirror of the core's PlayerEventMap so we don't depend on it being exported
-export type PlayerEventMap = {
-  play: void
-  pause: void
-  'track-end': Track | null
-  error: PlayerError
-  'quality-change': QualityLevel
-  'playlist-ready': void
-  loadedmetadata: Track | null
-  timeupdate: { currentTime: number; duration: number | null }
-  loading: void
-  canplay: void
-}
-
-export interface UseHlsAudioPlayerOptions {
-  config?: PlayerConfig
-  src?: { url: string; options?: SourceOptions }
-  autoPlay?: boolean
-  on?: Partial<{
-    [K in PlayerEvent]: (data: PlayerEventMap[K]) => void
-  }>
-}
-
-export interface UseHlsAudioPlayerResult {
-  player: HLSAudioPlayerInterface | null
-  state: PlayerState
-  isPlaying: boolean
-  duration: number
-  isLoading: boolean
-  loading: boolean
-  error: PlayerError | null
-  readyState: number
-  scrub: {
-    isScrubbing: boolean
-    displayTime: number
-    begin: () => void
-    update: (time: number) => void
-    commit: (time?: number) => void
-  }
-  seekBar: {
-    isScrubbing: boolean
-    displayTime: number
-    onChange: (event: ChangeEvent<HTMLInputElement>) => void
-    onPointerDown: () => void
-    onPointerUp: (event: PointerEvent<HTMLInputElement>) => void
-    onPointerCancel: () => void
-    onMouseDown: () => void
-    onMouseUp: (event: MouseEvent<HTMLInputElement>) => void
-    onTouchStart: () => void
-    onTouchEnd: (event: TouchEvent<HTMLInputElement>) => void
-    onFocus: () => void
-    onBlur: () => void
-  }
-  controls: {
-    setSource: (
-      url: string,
-      options?: SourceOptions,
-    ) => Promise<HLSAudioPlayerInterface | null>
-    play: () => void
-    playAsync: () => Promise<HLSAudioPlayerInterface | null>
-    pause: () => void
-    setVolume: (volume: number) => void
-    setCurrentTime: (time: number) => void
-    beginSeek: () => void
-    updateSeek: (time: number) => void
-    commitSeek: () => void
-    retry: (count?: number, interval?: number) => void
-  }
-}
-
-const defaultState: PlayerState = {
-  track: null,
-  currentTime: 0,
-  duration: null,
-  volume: 1,
-  loading: false,
-  error: null,
-  readyState: 0,
-  isPlaying: false,
-}
-
-export function useHlsAudioPlayer(
-  options: UseHlsAudioPlayerOptions = {},
-): UseHlsAudioPlayerResult {
-  const { config, src, autoPlay, on } = options
-
-  const player = useMemo(() => {
-    return new HLSAudioPlayer(config)
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-
-  const [state, setState] = useState<PlayerState>(
-    () => player.getState() ?? defaultState,
-  )
-
-  const [loading, setLoading] = useState<boolean>(player.loading ?? false)
-  const [error, setError] = useState<PlayerError | null>(player.error ?? null)
-  const [readyState, setReadyState] = useState<number>(player.readyState ?? 0)
-  const [isPlaying, setIsPlaying] = useState<boolean>(player.isPlaying ?? false)
-  const [duration, setDuration] = useState<number>(player.getState()?.duration ?? 0)
-  const [isLoading, setIsLoading] = useState<boolean>(player.loading ?? false)
-  const [isScrubbing, setIsScrubbing] = useState(false)
-  const [scrubTime, setScrubTime] = useState(0)
-  const scrubTimeRef = useRef(0)
-
-  useEffect(() => {
-    const handleStateChange = () => {
-      const next = player.getState()
-      setState(next)
-      setLoading(next.loading)
-      setError(next.error)
-      setReadyState(next.readyState)
-      setIsPlaying(next.isPlaying)
-      setDuration(next.duration ?? 0)
-      setIsLoading(next.loading)
-    }
-
-    const listeners: { [K in PlayerEvent]?: (data: PlayerEventMap[K]) => void } = {
-      play: data => {
-        handleStateChange()
-        on?.play?.(data as PlayerEventMap['play'])
-      },
-      pause: data => {
-        handleStateChange()
-        on?.pause?.(data as PlayerEventMap['pause'])
-      },
-      'track-end': data => {
-        handleStateChange()
-        on?.['track-end']?.(data as PlayerEventMap['track-end'])
-      },
-      error: data => {
-        handleStateChange()
-        on?.error?.(data as PlayerEventMap['error'])
-      },
-      'quality-change': data => {
-        handleStateChange()
-        on?.['quality-change']?.(data as PlayerEventMap['quality-change'])
-      },
-      'playlist-ready': data => {
-        handleStateChange()
-        on?.['playlist-ready']?.(data as PlayerEventMap['playlist-ready'])
-      },
-      loadedmetadata: data => {
-        handleStateChange()
-        on?.loadedmetadata?.(data as PlayerEventMap['loadedmetadata'])
-      },
-      timeupdate: data => {
-        handleStateChange()
-        on?.timeupdate?.(data as PlayerEventMap['timeupdate'])
-      },
-      loading: data => {
-        handleStateChange()
-        on?.loading?.(data as PlayerEventMap['loading'])
-      },
-      canplay: data => {
-        handleStateChange()
-        on?.canplay?.(data as PlayerEventMap['canplay'])
-      },
-    }
-
-    ;(Object.keys(listeners) as PlayerEvent[]).forEach(event => {
-      const handler = listeners[event]!
-      player.on(event, handler as any)
-    })
-
-    return () => {
-      ;(Object.keys(listeners) as PlayerEvent[]).forEach(event => {
-        const handler = listeners[event]
-        if (handler) {
-          player.off(event, handler as any)
-        }
-      })
-    }
-  }, [player, on])
-
-  useEffect(() => {
-    let cancelled = false
-
-    if (!src) return
-
-    player
-      .setSource(src.url, src.options)
-      .then((p: HLSAudioPlayerInterface) => {
-        if (cancelled) return
-        if (autoPlay) {
-          p.play()
-        }
-      })
-      .catch((err: unknown) => {
-        if (cancelled) return
-        console.error('Failed to set HLS source', err)
-      })
-
-    return () => {
-      cancelled = true
-    }
-  }, [player, src?.url, src?.options, autoPlay])
-
-  useEffect(() => {
-    return () => {
-      player.destroy()
-    }
-  }, [player])
-
-  const controls = useMemo(
-    () => ({
-      setSource: async (url: string, options?: SourceOptions) => {
-        try {
-          const p = await player.setSource(url, options)
-          if (autoPlay) {
-            p.play()
-          }
-          return p
-        } catch {
-          return null
-        }
-      },
-      play: () => {
-        player.play()
-      },
-      playAsync: async () => {
-        try {
-          const p = await player.playAsync()
-          return p
-        } catch {
-          return null
-        }
-      },
-      pause: () => {
-        player.pause()
-      },
-      setVolume: (volume: number) => {
-        player.setVolume(volume)
-        const next = player.getState()
-        setState(next)
-      },
-      setCurrentTime: (time: number) => {
-        const audioElement = player.getAudioElement()
-        audioElement.currentTime = time
-      },
-      beginSeek:() =>
-        player.beginSeek(),
-      updateSeek: (time: number) =>
-        player.updateSeek(time),
-      commitSeek: () =>
-        player.commitSeek(),
-      retry: (count?: number, interval?: number) => {
-        player.retry(count, interval)
-      },
-    }),
-    [player, autoPlay],
-  )
-
-  const beginScrub = useCallback(() => {
-    if (!state.duration) return
-    setIsScrubbing(true)
-    scrubTimeRef.current = state.currentTime
-    setScrubTime(state.currentTime)
-    player.beginSeek()
-  }, [player, state.currentTime, state.duration])
-
-  const updateScrub = useCallback((time: number) => {
-    scrubTimeRef.current = time
-    setScrubTime(time)
-  }, [])
-
-  const commitScrub = useCallback(
-    (time?: number) => {
-      if (!isScrubbing) return
-      if (typeof time === 'number' && !Number.isNaN(time)) {
-        scrubTimeRef.current = time
-        setScrubTime(time)
-      }
-      setIsScrubbing(false)
-      player.updateSeek(scrubTimeRef.current)
-      player.commitSeek()
-    },
-    [player, isScrubbing],
-  )
-
-  const commitScrubFromElement = useCallback(
-    (element: HTMLInputElement) => {
-      requestAnimationFrame(() => {
-        const nextTime = Number(element.value)
-        commitScrub(nextTime)
-      })
-    },
-    [commitScrub],
-  )
-
-  return {
-    player,
-    state,
-    isPlaying,
-    duration,
-    isLoading,
-    loading,
-    error,
-    readyState,
-    seekBar: {
-      isScrubbing,
-      displayTime: isScrubbing ? scrubTime : state.currentTime,
-      onChange: (event: ChangeEvent<HTMLInputElement>) => {
-        const nextTime = Number(event.target.value)
-        if (!isScrubbing) {
-          beginScrub()
-        }
-        updateScrub(nextTime)
-      },
-      onPointerDown: () => {
-        if (!isScrubbing) {
-          beginScrub()
-        }
-      },
-      onPointerUp: (event: PointerEvent<HTMLInputElement>) => {
-        commitScrubFromElement(event.currentTarget)
-      },
-      onPointerCancel: () => {
-        commitScrub()
-      },
-      onMouseDown: () => {
-        if (!isScrubbing) {
-          beginScrub()
-        }
-      },
-      onMouseUp: (event: MouseEvent<HTMLInputElement>) => {
-        commitScrubFromElement(event.currentTarget)
-      },
-      onTouchStart: () => {
-        if (!isScrubbing) {
-          beginScrub()
-        }
-      },
-      onTouchEnd: (event: TouchEvent<HTMLInputElement>) => {
-        commitScrubFromElement(event.currentTarget)
-      },
-      onFocus: () => {
-        if (!isScrubbing) {
-          beginScrub()
-        }
-      },
-      onBlur: () => {
-        commitScrub()
-      },
-    },
-    scrub: {
-      isScrubbing,
-      displayTime: isScrubbing ? scrubTime : state.currentTime,
-      begin: beginScrub,
-      update: updateScrub,
-      commit: commitScrub,
-    },
-    controls
-  }
-}

package/tsconfig.app.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
-    "target": "ES2022",
-    "useDefineForClassFields": true,
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "types": ["vite/client"],
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-    "jsx": "react-jsx",
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
-  },
-  "include": ["src"]
-}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "files": [],
-  "references": [
-    { "path": "./tsconfig.app.json" },
-    { "path": "./tsconfig.node.json" }
-  ]
-}

package/tsconfig.lib.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext", 
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "jsx": "react-jsx"
-  },
-  "include": ["src/index.ts", "src/use-hls-audio-player.ts"],
-  "exclude": ["dist", "node_modules"]
-}

package/tsconfig.node.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
-    "target": "ES2023",
-    "lib": ["ES2023"],
-    "module": "ESNext",
-    "types": ["node"],
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
-  },
-  "include": ["vite.config.ts"]
-}

package/vite.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
-
-// https://vite.dev/config/
-export default defineConfig({
-  plugins: [react()],
-})