@jasonshimmy/vite-plugin-cer-app 0.23.2 → 0.24.0

package/src/__tests__/plugin/cer-app-plugin.test.ts

@@ -1,552 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest'
-
-vi.mock('@jasonshimmy/custom-elements-runtime/vite-plugin', () => ({
-  cerPlugin: vi.fn().mockReturnValue([{ name: 'cer-runtime-plugin' }]),
-  cerComponentImports: vi.fn().mockReturnValue({ name: 'cer-component-imports' }),
-}))
-vi.mock('node:fs', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('node:fs')>()
-  return { ...actual, existsSync: vi.fn().mockReturnValue(true), readFileSync: vi.fn().mockReturnValue('') }
-})
-vi.mock('../../plugin/dev-server.js', () => ({
-  configureCerDevServer: vi.fn().mockResolvedValue(undefined),
-}))
-vi.mock('../../plugin/scanner.js', () => ({
-  createWatcher: vi.fn().mockReturnValue({ on: vi.fn(), close: vi.fn() }),
-  scanDirectory: vi.fn().mockResolvedValue([]),
-}))
-vi.mock('../../plugin/dts-generator.js', () => ({
-  scanComposableExports: vi.fn().mockResolvedValue(new Map()),
-  writeAutoImportDts: vi.fn().mockResolvedValue(undefined),
-  writeTsconfigPaths: vi.fn(),
-}))
-vi.mock('../../plugin/generated-dir.js', () => ({
-  writeGeneratedDir: vi.fn(),
-  getGeneratedDir: vi.fn().mockReturnValue('/project/.cer'),
-  GENERATED_DIR_NAME: '.cer',
-}))
-vi.mock('../../plugin/virtual/routes.js', () => ({ generateRoutesCode: vi.fn().mockResolvedValue('// routes') }))
-vi.mock('../../plugin/virtual/layouts.js', () => ({ generateLayoutsCode: vi.fn().mockResolvedValue('// layouts') }))
-vi.mock('../../plugin/virtual/composables.js', () => ({ generateComposablesCode: vi.fn().mockResolvedValue('// composables') }))
-vi.mock('../../plugin/virtual/plugins.js', () => ({ generatePluginsCode: vi.fn().mockResolvedValue('// plugins') }))
-vi.mock('../../plugin/virtual/middleware.js', () => ({ generateMiddlewareCode: vi.fn().mockResolvedValue('// middleware') }))
-vi.mock('../../plugin/virtual/server-api.js', () => ({ generateServerApiCode: vi.fn().mockResolvedValue('// server-api') }))
-vi.mock('../../plugin/virtual/server-middleware.js', () => ({ generateServerMiddlewareCode: vi.fn().mockResolvedValue('// server-middleware') }))
-vi.mock('../../plugin/virtual/loading.js', () => ({ generateLoadingCode: vi.fn().mockResolvedValue('// loading') }))
-vi.mock('../../plugin/virtual/error.js', () => ({ generateErrorCode: vi.fn().mockResolvedValue('// error') }))
-vi.mock('../../plugin/virtual/content-components.js', () => ({ generateContentComponentsCode: vi.fn().mockResolvedValue('// content-components') }))
-vi.mock('../../plugin/transforms/auto-import.js', () => ({ autoImportTransform: vi.fn().mockReturnValue(null) }))
-
-import { cerApp } from '../../plugin/index.js'
-import { generateAppEntryTemplate } from '../../runtime/app-template.js'
-
-
-type TestPlugin = {
-  name: string
-  config: (viteConfig: Record<string, unknown>, env: Record<string, unknown>) => unknown
-  configResolved: (resolved: Record<string, unknown>) => void
-  resolveId: (id: string) => string | undefined
-  load: (id: string, options?: { ssr?: boolean }) => Promise<string | null>
-  transform: (code: string, id: string) => unknown
-  transformIndexHtml: (html: string) => string
-  buildStart: () => Promise<void>
-  configureServer: (server: unknown) => Promise<void>
-}
-
-// Helper to get the cerAppPlugin (first plugin in the returned array)
-function getCerPlugin(userConfig = {}): TestPlugin {
-  return cerApp(userConfig)[0] as unknown as TestPlugin
-}
-
-// Minimal resolved config that mirrors what Vite passes to configResolved
-const FAKE_RESOLVED = { root: '/project' }
-
-describe('cerApp()', () => {
-  it('returns an array of plugins', () => {
-    const plugins = cerApp()
-    expect(Array.isArray(plugins)).toBe(true)
-    expect(plugins.length).toBeGreaterThan(0)
-  })
-
-  it('first plugin is named @jasonshimmy/vite-plugin-cer-app', () => {
-    const plugin = getCerPlugin()
-    expect(plugin.name).toBe('@jasonshimmy/vite-plugin-cer-app')
-  })
-
-  it('includes cerComponentImports plugin when autoImports.components is unset', () => {
-    const plugins = cerApp()
-    const names = plugins.map((p) => (p as { name: string }).name)
-    expect(names).toContain('cer-component-imports')
-  })
-
-  it('includes cerComponentImports plugin when autoImports.components is true', () => {
-    const plugins = cerApp({ autoImports: { components: true } })
-    const names = plugins.map((p) => (p as { name: string }).name)
-    expect(names).toContain('cer-component-imports')
-  })
-
-  it('excludes cerComponentImports plugin when autoImports.components is false', () => {
-    const plugins = cerApp({ autoImports: { components: false } })
-    const names = plugins.map((p) => (p as { name: string }).name)
-    expect(names).not.toContain('cer-component-imports')
-  })
-})
-
-describe('cerApp plugin — config hook', () => {
-  it('returns build.target: esnext', () => {
-    const plugin = getCerPlugin()
-    const result = plugin.config({ root: '/project' }, { command: 'build', mode: 'production' }) as Record<string, unknown>
-    expect((result.build as Record<string, unknown>).target).toBe('esnext')
-  })
-
-  it('config hook resolves the root', () => {
-    const plugin = getCerPlugin()
-    const result = plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(result).toBeDefined()
-  })
-})
-
-describe('cerApp plugin — configResolved hook', () => {
-  it('does not throw when called', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(() => plugin.configResolved(FAKE_RESOLVED)).not.toThrow()
-  })
-})
-
-describe('cerApp plugin — resolveId hook', () => {
-  beforeEach(() => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-  })
-
-  it('resolves virtual:cer-routes to \\0virtual:cer-routes', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('virtual:cer-routes')).toBe('\0virtual:cer-routes')
-  })
-
-  it('resolves virtual:cer-layouts', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('virtual:cer-layouts')).toBe('\0virtual:cer-layouts')
-  })
-
-  it('resolves virtual:cer-plugins', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('virtual:cer-plugins')).toBe('\0virtual:cer-plugins')
-  })
-
-  it('resolves virtual:cer-server-api', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('virtual:cer-server-api')).toBe('\0virtual:cer-server-api')
-  })
-
-  it('resolves virtual:cer-loading', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('virtual:cer-loading')).toBe('\0virtual:cer-loading')
-  })
-
-  it('resolves virtual:cer-error', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('virtual:cer-error')).toBe('\0virtual:cer-error')
-  })
-
-  it('resolves /@cer/app.ts to \\0cer-app-entry (virtual module)', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('/@cer/app.ts')).toBe('\0cer-app-entry')
-  })
-
-  it('does not resolve /.cer/app.ts (old URL, rewritten by transformIndexHtml)', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('/.cer/app.ts')).toBeUndefined()
-  })
-
-  it('returns undefined for unknown ids', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    expect(plugin.resolveId('some-unknown-id')).toBeUndefined()
-  })
-})
-
-describe('cerApp plugin — load hook', () => {
-  it('loads \\0cer-app-entry with generated app entry content', async () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = await plugin.load('\0cer-app-entry')
-    expect(result).toBe(generateAppEntryTemplate())
-  })
-
-  it('returns null for unknown resolved ids', async () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = await plugin.load('\0unknown-module')
-    expect(result).toBeNull()
-  })
-
-  it('loads virtual:cer-routes module code', async () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = await plugin.load('\0virtual:cer-routes')
-    expect(result).toBe('// routes')
-  })
-
-  it('loads virtual:cer-layouts module code', async () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = await plugin.load('\0virtual:cer-layouts')
-    expect(result).toBe('// layouts')
-  })
-
-  it('loads virtual:cer-loading module code', async () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = await plugin.load('\0virtual:cer-loading')
-    expect(result).toBe('// loading')
-  })
-
-  it('loads virtual:cer-error module code', async () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = await plugin.load('\0virtual:cer-error')
-    expect(result).toBe('// error')
-  })
-
-  it('returns cached code on repeated load calls', async () => {
-    const { generateRoutesCode } = await import('../../plugin/virtual/routes.js')
-    vi.mocked(generateRoutesCode).mockClear()
-
-    // Use a SINGLE plugin instance so the module cache persists across calls
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-
-    const first = await plugin.load('\0virtual:cer-routes')
-    const second = await plugin.load('\0virtual:cer-routes')
-
-    expect(first).toBe(second)
-    // generateRoutesCode should only be called once (cache hit on second call)
-    expect(generateRoutesCode).toHaveBeenCalledTimes(1)
-  })
-
-  it('loads virtual:cer-app-config and exports appConfig', async () => {
-    const plugin = getCerPlugin({ mode: 'ssg' })
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = await plugin.load('\0virtual:cer-app-config') as string
-    expect(result).toContain('appConfig')
-    expect(result).toContain('ssg')
-  })
-
-  it('excludes _runtimePrivateDefaults from the client bundle', async () => {
-    const plugin = getCerPlugin({ runtimeConfig: { private: { dbUrl: '', secretKey: '' } } })
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    // Client load (ssr: false / omitted)
-    const clientResult = await plugin.load('\0virtual:cer-app-config') as string
-    expect(clientResult).not.toContain('_runtimePrivateDefaults')
-    expect(clientResult).not.toContain('dbUrl')
-  })
-
-  it('includes _runtimePrivateDefaults in the SSR bundle', async () => {
-    const plugin = getCerPlugin({ runtimeConfig: { private: { dbUrl: '', secretKey: '' } } })
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    // SSR load (ssr: true)
-    const ssrResult = await plugin.load('\0virtual:cer-app-config', { ssr: true }) as string
-    expect(ssrResult).toContain('_runtimePrivateDefaults')
-    expect(ssrResult).toContain('dbUrl')
-  })
-
-  it('caches SSR and client virtual:cer-app-config separately', async () => {
-    const plugin = getCerPlugin({ runtimeConfig: { private: { token: '' } } })
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const client = await plugin.load('\0virtual:cer-app-config') as string
-    const ssr = await plugin.load('\0virtual:cer-app-config', { ssr: true }) as string
-    expect(client).not.toContain('_runtimePrivateDefaults')
-    expect(ssr).toContain('_runtimePrivateDefaults')
-  })
-})
-
-describe('cerApp plugin — transform hook', () => {
-  it('returns null for virtual module ids', async () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = plugin.transform('// code', '\0virtual:cer-routes')
-    expect(result).toBeNull()
-  })
-
-  it('calls autoImportTransform for regular files', async () => {
-    const { autoImportTransform } = await import('../../plugin/transforms/auto-import.js')
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-
-    plugin.transform('const x = 1', '/project/app/pages/index.ts')
-    expect(autoImportTransform).toHaveBeenCalled()
-  })
-
-  it('returns null when autoImportTransform returns null', async () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = plugin.transform('const x = 1', '/project/app/pages/index.ts')
-    expect(result).toBeNull()
-  })
-
-  it('returns { code, map } when autoImportTransform returns a string', async () => {
-    const { autoImportTransform } = await import('../../plugin/transforms/auto-import.js')
-    vi.mocked(autoImportTransform).mockReturnValueOnce('transformed code')
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = plugin.transform('const x = 1', '/project/app/pages/index.ts') as { code: string; map: null }
-    expect(result).toEqual({ code: 'transformed code', map: null })
-  })
-
-  it('returns null when autoImports.runtime is false', async () => {
-    const plugin = getCerPlugin({ autoImports: { runtime: false } })
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const result = plugin.transform('const x = 1', '/project/app/pages/index.ts')
-    expect(result).toBeNull()
-  })
-})
-
-describe('cerApp plugin — transformIndexHtml hook', () => {
-  it('rewrites /.cer/app.ts src to /@cer/app.ts', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    const input = '<script type="module" src="/.cer/app.ts"></script>'
-    const output = plugin.transformIndexHtml(input)
-    expect(output).toContain('src="/@cer/app.ts"')
-    expect(output).not.toContain('src="/.cer/app.ts"')
-  })
-
-  it('leaves html unchanged when /.cer/app.ts is not present', () => {
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    const input = '<script type="module" src="/@cer/app.ts"></script>'
-    expect(plugin.transformIndexHtml(input)).toBe(input)
-  })
-})
-
-describe('cerApp plugin — configResolved hook', () => {
-  it('calls writeGeneratedDir during configResolved', async () => {
-    const { writeGeneratedDir } = await import('../../plugin/generated-dir.js')
-    vi.mocked(writeGeneratedDir).mockClear()
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    expect(writeGeneratedDir).toHaveBeenCalledTimes(1)
-  })
-})
-
-describe('cerApp plugin — buildStart hook', () => {
-  it('calls writeGeneratedDir on build start', async () => {
-    const { writeGeneratedDir } = await import('../../plugin/generated-dir.js')
-    vi.mocked(writeGeneratedDir).mockClear()
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'build', mode: 'production' })
-    plugin.configResolved(FAKE_RESOLVED)
-    await plugin.buildStart()
-    // writeGeneratedDir is called once in configResolved and once in buildStart
-    expect(writeGeneratedDir).toHaveBeenCalledTimes(2)
-  })
-
-  it('calls scanComposableExports on build start', async () => {
-    const { scanComposableExports } = await import('../../plugin/dts-generator.js')
-    vi.mocked(scanComposableExports).mockClear()
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'build', mode: 'production' })
-    plugin.configResolved(FAKE_RESOLVED)
-    await plugin.buildStart()
-    expect(scanComposableExports).toHaveBeenCalledTimes(1)
-  })
-
-  it('calls writeAutoImportDts on build start', async () => {
-    const { writeAutoImportDts } = await import('../../plugin/dts-generator.js')
-    vi.mocked(writeAutoImportDts).mockClear()
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'build', mode: 'production' })
-    plugin.configResolved(FAKE_RESOLVED)
-    await plugin.buildStart()
-    expect(writeAutoImportDts).toHaveBeenCalledTimes(1)
-  })
-
-  it('calls writeTsconfigPaths on build start', async () => {
-    const { writeTsconfigPaths } = await import('../../plugin/dts-generator.js')
-    vi.mocked(writeTsconfigPaths).mockClear()
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'build', mode: 'production' })
-    plugin.configResolved(FAKE_RESOLVED)
-    await plugin.buildStart()
-    expect(writeTsconfigPaths).toHaveBeenCalledTimes(1)
-  })
-
-  it('warms virtual:cer-app-config cache under :client key so load() hits it', async () => {
-    // After buildStart(), a subsequent client load (ssr: false) should be served
-    // from cache (generateAppConfigModule is not a public mock, so we verify by
-    // ensuring the load hook returns a non-null result without triggering the
-    // real generator — which is mocked at module level to a fixed string '// mock'
-    // for other modules; appConfig is not mocked, so it generates real code).
-    const plugin = getCerPlugin({ runtimeConfig: { private: { token: '' } } })
-    plugin.config({ root: '/project' }, { command: 'build', mode: 'production' })
-    plugin.configResolved(FAKE_RESOLVED)
-    await plugin.buildStart()
-
-    // Client load should return a result that does NOT include _runtimePrivateDefaults
-    const result = await plugin.load('\0virtual:cer-app-config') as string
-    expect(result).not.toContain('_runtimePrivateDefaults')
-
-    // SSR load (different cache key) should include _runtimePrivateDefaults
-    const ssrResult = await plugin.load('\0virtual:cer-app-config', { ssr: true }) as string
-    expect(ssrResult).toContain('_runtimePrivateDefaults')
-  })
-})
-
-describe('cerApp plugin — configureServer hook', () => {
-  it('calls writeGeneratedDir on server configure', async () => {
-    const { writeGeneratedDir } = await import('../../plugin/generated-dir.js')
-    vi.mocked(writeGeneratedDir).mockClear()
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-    const mockServer = {
-      watcher: { on: vi.fn() },
-      moduleGraph: { getModuleById: vi.fn().mockReturnValue(null), invalidateModule: vi.fn() },
-      ws: { send: vi.fn() },
-      middlewares: { use: vi.fn() },
-    }
-    await plugin.configureServer(mockServer)
-    // configResolved calls it once, configureServer calls it again
-    expect(writeGeneratedDir).toHaveBeenCalledTimes(2)
-  })
-
-  it('calls scanComposableExports on server configure', async () => {
-    const { scanComposableExports } = await import('../../plugin/dts-generator.js')
-    vi.mocked(scanComposableExports).mockClear()
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-
-    const mockServer = {
-      watcher: { on: vi.fn() },
-      moduleGraph: { getModuleById: vi.fn().mockReturnValue(null), invalidateModule: vi.fn() },
-      ws: { send: vi.fn() },
-    }
-    await plugin.configureServer(mockServer)
-    expect(scanComposableExports).toHaveBeenCalled()
-  })
-
-  it('calls configureCerDevServer on server configure', async () => {
-    const { configureCerDevServer } = await import('../../plugin/dev-server.js')
-    vi.mocked(configureCerDevServer).mockClear()
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-
-    const mockServer = {
-      watcher: { on: vi.fn() },
-      moduleGraph: { getModuleById: vi.fn().mockReturnValue(null), invalidateModule: vi.fn() },
-      ws: { send: vi.fn() },
-    }
-    await plugin.configureServer(mockServer)
-    expect(configureCerDevServer).toHaveBeenCalled()
-  })
-
-  it('invokes the file-change watcher callback on add event', async () => {
-    const { createWatcher } = await import('../../plugin/scanner.js')
-    const { scanComposableExports } = await import('../../plugin/dts-generator.js')
-    vi.mocked(scanComposableExports).mockClear()
-
-    let capturedCallback: ((event: string, file: string) => void) | null = null
-    vi.mocked(createWatcher).mockImplementationOnce((_watcher, _dirs, cb) => {
-      capturedCallback = cb
-      return { on: vi.fn(), close: vi.fn() } as unknown as ReturnType<typeof createWatcher>
-    })
-
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-
-    const mockServer = {
-      watcher: { on: vi.fn() },
-      moduleGraph: { getModuleById: vi.fn().mockReturnValue(null), invalidateModule: vi.fn() },
-      ws: { send: vi.fn() },
-    }
-    await plugin.configureServer(mockServer)
-
-    // Simulate an 'add' event on a pages file — covers getDirtyVirtualIds and watcher callback
-    await capturedCallback!('add', '/project/app/pages/new-page.ts')
-    expect((mockServer.ws.send as ReturnType<typeof vi.fn>)).toHaveBeenCalledWith({ type: 'full-reload' })
-  })
-
-  it('re-scans composables when a composable file is added', async () => {
-    const { createWatcher } = await import('../../plugin/scanner.js')
-    const { scanComposableExports } = await import('../../plugin/dts-generator.js')
-    vi.mocked(scanComposableExports).mockClear()
-
-    let capturedCallback: ((event: string, file: string) => void) | null = null
-    vi.mocked(createWatcher).mockImplementationOnce((_watcher, _dirs, cb) => {
-      capturedCallback = cb
-      return { on: vi.fn(), close: vi.fn() } as unknown as ReturnType<typeof createWatcher>
-    })
-
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-
-    const mockServer = {
-      watcher: { on: vi.fn() },
-      moduleGraph: { getModuleById: vi.fn().mockReturnValue(null), invalidateModule: vi.fn() },
-      ws: { send: vi.fn() },
-    }
-    await plugin.configureServer(mockServer)
-
-    const callsBeforeEvent = vi.mocked(scanComposableExports).mock.calls.length
-    await capturedCallback!('add', '/project/app/composables/use-new.ts')
-    expect(vi.mocked(scanComposableExports).mock.calls.length).toBeGreaterThan(callsBeforeEvent)
-  })
-
-  it('does not trigger HMR on non-add/unlink events', async () => {
-    const { createWatcher } = await import('../../plugin/scanner.js')
-
-    let capturedCallback: ((event: string, file: string) => void) | null = null
-    vi.mocked(createWatcher).mockImplementationOnce((_watcher, _dirs, cb) => {
-      capturedCallback = cb
-      return { on: vi.fn(), close: vi.fn() } as unknown as ReturnType<typeof createWatcher>
-    })
-
-    const plugin = getCerPlugin()
-    plugin.config({ root: '/project' }, { command: 'serve', mode: 'development' })
-    plugin.configResolved(FAKE_RESOLVED)
-
-    const wsSend = vi.fn()
-    const mockServer = {
-      watcher: { on: vi.fn() },
-      moduleGraph: { getModuleById: vi.fn().mockReturnValue(null), invalidateModule: vi.fn() },
-      ws: { send: wsSend },
-    }
-    await plugin.configureServer(mockServer)
-    wsSend.mockClear()
-
-    await capturedCallback!('change', '/project/app/pages/index.ts')
-    expect(wsSend).not.toHaveBeenCalled()
-  })
-})

package/src/__tests__/plugin/content/emitter.test.ts

@@ -1,117 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { contentPathToFile, emitContentFiles } from '../../../plugin/content/emitter.js'
-import { mkdtempSync, readFileSync, existsSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'pathe'
-import type { ContentItem } from '../../../types/content.js'
-
-// ─── contentPathToFile ────────────────────────────────────────────────────────
-
-describe('contentPathToFile', () => {
-  it('maps / to index.json', () => {
-    expect(contentPathToFile('/')).toBe('index.json')
-  })
-
-  it('maps /about to about.json', () => {
-    expect(contentPathToFile('/about')).toBe('about.json')
-  })
-
-  it('maps /blog/hello to blog/hello.json', () => {
-    expect(contentPathToFile('/blog/hello')).toBe('blog/hello.json')
-  })
-
-  it('maps /blog to blog.json', () => {
-    expect(contentPathToFile('/blog')).toBe('blog.json')
-  })
-
-  it('maps /docs/getting-started to docs/getting-started.json', () => {
-    expect(contentPathToFile('/docs/getting-started')).toBe('docs/getting-started.json')
-  })
-})
-
-// ─── emitContentFiles ─────────────────────────────────────────────────────────
-
-describe('emitContentFiles', () => {
-  const items: ContentItem[] = [
-    {
-      _path: '/',
-      _file: 'index.md',
-      _type: 'markdown',
-      title: 'Home',
-      description: 'Welcome',
-      body: '<h1>Home</h1>',
-      toc: [],
-    },
-    {
-      _path: '/blog/hello',
-      _file: 'blog/hello.md',
-      _type: 'markdown',
-      title: 'Hello',
-      description: 'First post',
-      date: '2026-04-03',
-      draft: false,
-      body: '<h1>Hello</h1>',
-      toc: [{ depth: 1, id: 'hello', text: 'Hello' }],
-      excerpt: '<p>Intro</p>',
-    },
-  ]
-
-  it('writes manifest.json with lean ContentMeta (no body/toc/excerpt/_file)', () => {
-    const outDir = mkdtempSync(join(tmpdir(), 'cer-emitter-'))
-    emitContentFiles(items, outDir, '{}')
-    const manifest = JSON.parse(readFileSync(join(outDir, '_content/manifest.json'), 'utf-8'))
-    expect(Array.isArray(manifest)).toBe(true)
-    expect(manifest).toHaveLength(2)
-    const root = manifest.find((m: { _path: string }) => m._path === '/')
-    expect(root.title).toBe('Home')
-    expect('body' in root).toBe(false)
-    expect('toc' in root).toBe(false)
-    expect('excerpt' in root).toBe(false)
-    expect('_file' in root).toBe(false)
-  })
-
-  it('writes search-index.json with provided content', () => {
-    const outDir = mkdtempSync(join(tmpdir(), 'cer-emitter-'))
-    emitContentFiles(items, outDir, '{"test":true}')
-    const idx = JSON.parse(readFileSync(join(outDir, '_content/search-index.json'), 'utf-8'))
-    expect(idx).toEqual({ test: true })
-  })
-
-  it('writes root document to _content/index.json', () => {
-    const outDir = mkdtempSync(join(tmpdir(), 'cer-emitter-'))
-    emitContentFiles(items, outDir, '{}')
-    expect(existsSync(join(outDir, '_content/index.json'))).toBe(true)
-    const doc = JSON.parse(readFileSync(join(outDir, '_content/index.json'), 'utf-8'))
-    expect(doc._path).toBe('/')
-    expect(doc.body).toBe('<h1>Home</h1>')
-  })
-
-  it('writes nested document to correct subdirectory', () => {
-    const outDir = mkdtempSync(join(tmpdir(), 'cer-emitter-'))
-    emitContentFiles(items, outDir, '{}')
-    const docPath = join(outDir, '_content/blog/hello.json')
-    expect(existsSync(docPath)).toBe(true)
-    const doc = JSON.parse(readFileSync(docPath, 'utf-8'))
-    expect(doc._path).toBe('/blog/hello')
-    expect(doc.toc).toEqual([{ depth: 1, id: 'hello', text: 'Hello' }])
-    expect(doc.excerpt).toBe('<p>Intro</p>')
-  })
-
-  it('coexisting blog.json and blog/ dir is allowed', () => {
-    const items2: ContentItem[] = [
-      ...items,
-      {
-        _path: '/blog',
-        _file: 'blog/index.md',
-        _type: 'markdown',
-        title: 'Blog',
-        body: '<p>Blog</p>',
-        toc: [],
-      },
-    ]
-    const outDir = mkdtempSync(join(tmpdir(), 'cer-emitter-'))
-    emitContentFiles(items2, outDir, '{}')
-    expect(existsSync(join(outDir, '_content/blog.json'))).toBe(true)
-    expect(existsSync(join(outDir, '_content/blog/hello.json'))).toBe(true)
-  })
-})