@jasonshimmy/vite-plugin-cer-app 0.1.0 → 0.1.2

package/src/__tests__/plugin/dts-generator.test.ts

@@ -0,0 +1,246 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>()
+  return {
+    ...actual,
+    existsSync: vi.fn().mockReturnValue(false),
+    writeFileSync: vi.fn(),
+    readFileSync: vi.fn().mockReturnValue(''),
+  }
+})
+vi.mock('../../plugin/scanner.js', () => ({ scanDirectory: vi.fn().mockResolvedValue([]) }))
+
+import { existsSync, writeFileSync, readFileSync } from 'node:fs'
+import { scanDirectory } from '../../plugin/scanner.js'
+import {
+  writeTsconfigPaths,
+  scanComposableExports,
+  generateAutoImportDts,
+  generateVirtualModuleDts,
+  writeAutoImportDts,
+} from '../../plugin/dts-generator.js'
+
+const ROOT = '/project'
+const COMPOSABLES_DIR = '/project/app/composables'
+
+beforeEach(() => {
+  vi.mocked(existsSync).mockReturnValue(false)
+  vi.mocked(writeFileSync).mockClear()
+  vi.mocked(scanDirectory).mockResolvedValue([])
+  vi.mocked(readFileSync).mockReturnValue('')
+})
+
+describe('writeTsconfigPaths', () => {
+  it('writes cer-tsconfig.json to the root directory', () => {
+    writeTsconfigPaths(ROOT, `${ROOT}/app`)
+    expect(writeFileSync).toHaveBeenCalledWith(
+      `${ROOT}/cer-tsconfig.json`,
+      expect.any(String),
+      'utf-8',
+    )
+  })
+
+  it('includes ~/\\* path alias in tsconfig', () => {
+    writeTsconfigPaths(ROOT, `${ROOT}/app`)
+    const content = vi.mocked(writeFileSync).mock.calls[0][1] as string
+    expect(content).toContain('~/*')
+  })
+
+  it('includes ~/pages/* path alias', () => {
+    writeTsconfigPaths(ROOT, `${ROOT}/app`)
+    const content = vi.mocked(writeFileSync).mock.calls[0][1] as string
+    expect(content).toContain('~/pages/*')
+  })
+
+  it('generates valid JSON', () => {
+    writeTsconfigPaths(ROOT, `${ROOT}/app`)
+    const content = vi.mocked(writeFileSync).mock.calls[0][1] as string
+    expect(() => JSON.parse(content)).not.toThrow()
+  })
+
+  it('wraps paths in compilerOptions', () => {
+    writeTsconfigPaths(ROOT, `${ROOT}/app`)
+    const content = vi.mocked(writeFileSync).mock.calls[0][1] as string
+    const json = JSON.parse(content)
+    expect(json).toHaveProperty('compilerOptions.paths')
+  })
+})
+
+describe('scanComposableExports', () => {
+  it('returns empty map when composablesDir does not exist', async () => {
+    const result = await scanComposableExports(COMPOSABLES_DIR)
+    expect(result.size).toBe(0)
+  })
+
+  it('returns empty map when no files found', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const result = await scanComposableExports(COMPOSABLES_DIR)
+    expect(result.size).toBe(0)
+  })
+
+  it('finds exported functions', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([`${COMPOSABLES_DIR}/use-counter.ts`])
+    vi.mocked(readFileSync).mockReturnValue('export function useCounter() {}')
+    const result = await scanComposableExports(COMPOSABLES_DIR)
+    expect(result.has('useCounter')).toBe(true)
+    expect(result.get('useCounter')).toBe(`${COMPOSABLES_DIR}/use-counter.ts`)
+  })
+
+  it('finds exported const', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([`${COMPOSABLES_DIR}/use-state.ts`])
+    vi.mocked(readFileSync).mockReturnValue('export const useState = () => {}')
+    const result = await scanComposableExports(COMPOSABLES_DIR)
+    expect(result.has('useState')).toBe(true)
+  })
+
+  it('finds multiple exports from a single file', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([`${COMPOSABLES_DIR}/utils.ts`])
+    vi.mocked(readFileSync).mockReturnValue(`
+export function useFoo() {}
+export const useBar = () => {}
+    `)
+    const result = await scanComposableExports(COMPOSABLES_DIR)
+    expect(result.has('useFoo')).toBe(true)
+    expect(result.has('useBar')).toBe(true)
+  })
+
+  it('handles multiple files', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([
+      `${COMPOSABLES_DIR}/a.ts`,
+      `${COMPOSABLES_DIR}/b.ts`,
+    ])
+    vi.mocked(readFileSync)
+      .mockReturnValueOnce('export function useA() {}')
+      .mockReturnValueOnce('export function useB() {}')
+    const result = await scanComposableExports(COMPOSABLES_DIR)
+    expect(result.has('useA')).toBe(true)
+    expect(result.has('useB')).toBe(true)
+  })
+})
+
+describe('generateAutoImportDts', () => {
+  it('includes AUTO-GENERATED comment', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain('AUTO-GENERATED')
+  })
+
+  it('declares component as a global', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("const component: typeof import('@jasonshimmy/custom-elements-runtime')['component']")
+  })
+
+  it('declares html as a global', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("const html: typeof import('@jasonshimmy/custom-elements-runtime')['html']")
+  })
+
+  it('declares ref as a global', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("const ref: typeof import('@jasonshimmy/custom-elements-runtime')['ref']")
+  })
+
+  it('declares useHead as a framework global', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("const useHead: typeof import('@jasonshimmy/vite-plugin-cer-app/composables')['useHead']")
+  })
+
+  it('declares usePageData as a framework global', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("const usePageData: typeof import('@jasonshimmy/vite-plugin-cer-app/composables')['usePageData']")
+  })
+
+  it('declares when directive as a global', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("const when: typeof import('@jasonshimmy/custom-elements-runtime/directives')['when']")
+  })
+
+  it('declares __CER_DATA__ global variable', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain('var __CER_DATA__')
+  })
+
+  it('wraps declarations in declare global block', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain('declare global {')
+    expect(dts).toContain('}')
+  })
+
+  it('includes user composable exports when provided', async () => {
+    const exports = new Map([['useMyThing', `${COMPOSABLES_DIR}/my-thing.ts`]])
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR, exports)
+    expect(dts).toContain('useMyThing')
+  })
+
+  it('uses relative path for user composables', async () => {
+    const exports = new Map([['useFoo', `${ROOT}/app/composables/foo.ts`]])
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR, exports)
+    // Path should be relative from root
+    expect(dts).toContain('./app/composables/foo')
+  })
+})
+
+describe('generateVirtualModuleDts', () => {
+  it('includes AUTO-GENERATED comment', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain('AUTO-GENERATED')
+  })
+
+  it('declares virtual:cer-routes module', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("declare module 'virtual:cer-routes'")
+  })
+
+  it('declares virtual:cer-layouts module', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("declare module 'virtual:cer-layouts'")
+  })
+
+  it('declares virtual:cer-plugins module', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("declare module 'virtual:cer-plugins'")
+  })
+
+  it('declares virtual:cer-loading module with hasLoading and loadingTag', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("declare module 'virtual:cer-loading'")
+    expect(dts).toContain('hasLoading')
+    expect(dts).toContain('loadingTag')
+  })
+
+  it('declares virtual:cer-error module with hasError and errorTag', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("declare module 'virtual:cer-error'")
+    expect(dts).toContain('hasError')
+    expect(dts).toContain('errorTag')
+  })
+
+  it('includes user composable re-exports in virtual:cer-composables', async () => {
+    const exports = new Map([['useMyThing', `${ROOT}/app/composables/my-thing.ts`]])
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR, exports)
+    expect(dts).toContain('useMyThing')
+  })
+})
+
+describe('writeAutoImportDts', () => {
+  it('writes cer-auto-imports.d.ts to root', async () => {
+    await writeAutoImportDts(ROOT, COMPOSABLES_DIR)
+    const paths = vi.mocked(writeFileSync).mock.calls.map(([p]) => String(p))
+    expect(paths.some(p => p.includes('cer-auto-imports.d.ts'))).toBe(true)
+  })
+
+  it('writes cer-env.d.ts to root', async () => {
+    await writeAutoImportDts(ROOT, COMPOSABLES_DIR)
+    const paths = vi.mocked(writeFileSync).mock.calls.map(([p]) => String(p))
+    expect(paths.some(p => p.includes('cer-env.d.ts'))).toBe(true)
+  })
+
+  it('writes exactly two files', async () => {
+    await writeAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(writeFileSync).toHaveBeenCalledTimes(2)
+  })
+})

package/src/__tests__/plugin/resolve-config.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect } from 'vitest'
+import { resolveConfig } from '../../plugin/index.js'
+
+const ROOT = '/project'
+
+describe('resolveConfig', () => {
+  it('defaults mode to "spa"', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.mode).toBe('spa')
+  })
+
+  it('respects explicit mode', () => {
+    expect(resolveConfig({ mode: 'ssr' }, ROOT).mode).toBe('ssr')
+    expect(resolveConfig({ mode: 'ssg' }, ROOT).mode).toBe('ssg')
+  })
+
+  it('defaults srcDir to <root>/app', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.srcDir).toBe('/project/app')
+  })
+
+  it('respects explicit srcDir', () => {
+    const cfg = resolveConfig({ srcDir: 'src' }, ROOT)
+    expect(cfg.srcDir).toBe('/project/src')
+  })
+
+  it('derives pagesDir from srcDir', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.pagesDir).toBe('/project/app/pages')
+  })
+
+  it('derives layoutsDir from srcDir', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.layoutsDir).toBe('/project/app/layouts')
+  })
+
+  it('derives componentsDir from srcDir', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.componentsDir).toBe('/project/app/components')
+  })
+
+  it('derives composablesDir from srcDir', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.composablesDir).toBe('/project/app/composables')
+  })
+
+  it('derives pluginsDir from srcDir', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.pluginsDir).toBe('/project/app/plugins')
+  })
+
+  it('derives middlewareDir from srcDir', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.middlewareDir).toBe('/project/app/middleware')
+  })
+
+  it('derives serverApiDir from root (not srcDir)', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.serverApiDir).toBe('/project/server/api')
+  })
+
+  it('derives serverMiddlewareDir from root (not srcDir)', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.serverMiddlewareDir).toBe('/project/server/middleware')
+  })
+
+  it('defaults port to 3000', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.port).toBe(3000)
+  })
+
+  it('respects explicit port', () => {
+    const cfg = resolveConfig({ port: 4000 }, ROOT)
+    expect(cfg.port).toBe(4000)
+  })
+
+  it('defaults ssr.dsd to true', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.ssr.dsd).toBe(true)
+  })
+
+  it('respects explicit ssr.dsd=false', () => {
+    const cfg = resolveConfig({ ssr: { dsd: false } }, ROOT)
+    expect(cfg.ssr.dsd).toBe(false)
+  })
+
+  it('defaults ssr.streaming to false', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.ssr.streaming).toBe(false)
+  })
+
+  it('defaults ssg.routes to "auto"', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.ssg.routes).toBe('auto')
+  })
+
+  it('respects explicit ssg.routes array', () => {
+    const cfg = resolveConfig({ ssg: { routes: ['/a', '/b'] } }, ROOT)
+    expect(cfg.ssg.routes).toEqual(['/a', '/b'])
+  })
+
+  it('defaults ssg.concurrency to 4', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.ssg.concurrency).toBe(4)
+  })
+
+  it('defaults ssg.fallback to false', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.ssg.fallback).toBe(false)
+  })
+
+  it('defaults autoImports.components to true', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.autoImports.components).toBe(true)
+  })
+
+  it('defaults autoImports.composables to true', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.autoImports.composables).toBe(true)
+  })
+
+  it('defaults autoImports.directives to true', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.autoImports.directives).toBe(true)
+  })
+
+  it('defaults autoImports.runtime to true', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.autoImports.runtime).toBe(true)
+  })
+
+  it('sets jitCss.content defaults relative to srcDir', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.jitCss.content).toContain('/project/app/pages/**/*.ts')
+    expect(cfg.jitCss.content).toContain('/project/app/components/**/*.ts')
+    expect(cfg.jitCss.content).toContain('/project/app/layouts/**/*.ts')
+  })
+
+  it('defaults jitCss.extendedColors to false', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.jitCss.extendedColors).toBe(false)
+  })
+
+  it('passes router.base through', () => {
+    const cfg = resolveConfig({ router: { base: '/app', scrollToFragment: false } }, ROOT)
+    expect(cfg.router.base).toBe('/app')
+  })
+
+  it('passes router.scrollToFragment through', () => {
+    const cfg = resolveConfig({ router: { base: undefined, scrollToFragment: true } }, ROOT)
+    expect(cfg.router.scrollToFragment).toBe(true)
+  })
+
+  it('includes root in the resolved config', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.root).toBe(ROOT)
+  })
+})

package/src/__tests__/plugin/transforms/auto-import.test.ts

@@ -6,7 +6,7 @@ const opts = { srcDir }
 
 const RUNTIME_PKG = `'@jasonshimmy/custom-elements-runtime'`
 const DIRECTIVES_PKG = `'@jasonshimmy/custom-elements-runtime/directives'`
-const FRAMEWORK_PKG = `'vite-plugin-cer-app/composables'`
+const FRAMEWORK_PKG = `'@jasonshimmy/vite-plugin-cer-app/composables'`
 
 // ─── Target-directory gating ─────────────────────────────────────────────────
 

package/src/__tests__/plugin/virtual/components.test.ts

@@ -29,7 +29,7 @@ describe('generateComponentsCode', () => {
   it('includes AUTO-GENERATED comment', async () => {
     vi.mocked(scanDirectory).mockResolvedValue([`${COMPONENTS}/my-button.ts`])
     const code = await generateComponentsCode(COMPONENTS)
-    expect(code).toContain('AUTO-GENERATED by vite-plugin-cer-app')
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
   })
 
   it('generates side-effect imports for each component file', async () => {

package/src/__tests__/plugin/virtual/composables.test.ts

@@ -29,7 +29,7 @@ describe('generateComposablesCode', () => {
   it('includes AUTO-GENERATED comment', async () => {
     vi.mocked(scanDirectory).mockResolvedValue([`${COMPOSABLES}/useTheme.ts`])
     const code = await generateComposablesCode(COMPOSABLES)
-    expect(code).toContain('AUTO-GENERATED by vite-plugin-cer-app')
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
   })
 
   it('generates export * from for each composable file', async () => {

package/src/__tests__/plugin/virtual/error.test.ts

@@ -0,0 +1,71 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+
+vi.mock('node:fs', () => ({ existsSync: vi.fn() }))
+
+import { existsSync } from 'node:fs'
+import { generateErrorCode } from '../../../plugin/virtual/error.js'
+
+const SRC_DIR = '/project/app'
+
+describe('generateErrorCode', () => {
+  beforeEach(() => {
+    vi.mocked(existsSync).mockReturnValue(false)
+  })
+
+  it('returns falsy exports when error.ts does not exist', async () => {
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code).toContain('export const hasError = false')
+    expect(code).toContain('export const errorTag = null')
+  })
+
+  it('includes AUTO-GENERATED comment when no error file', async () => {
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
+  })
+
+  it('returns truthy exports when error.ts exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code).toContain('export const hasError = true')
+    expect(code).toContain("export const errorTag = 'page-error'")
+  })
+
+  it('imports the error file when it exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code).toContain(`${SRC_DIR}/error.ts`)
+  })
+
+  it('includes AUTO-GENERATED comment when error file exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
+  })
+
+  it('checks for error.ts specifically (not error.js)', async () => {
+    await generateErrorCode(SRC_DIR)
+    expect(existsSync).toHaveBeenCalledWith(`${SRC_DIR}/error.ts`)
+  })
+
+  it('does not include hasError=true when file is missing', async () => {
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code).not.toContain('hasError = true')
+  })
+
+  it('does not include hasError=false when file exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code).not.toContain('hasError = false')
+  })
+
+  it('ends with a newline', async () => {
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code.endsWith('\n')).toBe(true)
+  })
+
+  it('ends with a newline when file exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateErrorCode(SRC_DIR)
+    expect(code.endsWith('\n')).toBe(true)
+  })
+})

package/src/__tests__/plugin/virtual/layouts.test.ts

@@ -30,7 +30,7 @@ describe('generateLayoutsCode', () => {
 
   it('includes AUTO-GENERATED comment', async () => {
     const code = await generateLayoutsCode(LAYOUTS)
-    expect(code).toContain('AUTO-GENERATED by vite-plugin-cer-app')
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
   })
 
   it('generates a side-effect import for each layout file', async () => {

package/src/__tests__/plugin/virtual/loading.test.ts

@@ -0,0 +1,72 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+
+vi.mock('node:fs', () => ({ existsSync: vi.fn() }))
+vi.mock('../../../plugin/scanner.js', () => ({ scanDirectory: vi.fn() }))
+
+import { existsSync } from 'node:fs'
+import { generateLoadingCode } from '../../../plugin/virtual/loading.js'
+
+const SRC_DIR = '/project/app'
+
+describe('generateLoadingCode', () => {
+  beforeEach(() => {
+    vi.mocked(existsSync).mockReturnValue(false)
+  })
+
+  it('returns falsy exports when loading.ts does not exist', async () => {
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code).toContain('export const hasLoading = false')
+    expect(code).toContain('export const loadingTag = null')
+  })
+
+  it('includes AUTO-GENERATED comment when no loading file', async () => {
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
+  })
+
+  it('returns truthy exports when loading.ts exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code).toContain('export const hasLoading = true')
+    expect(code).toContain("export const loadingTag = 'page-loading'")
+  })
+
+  it('imports the loading file when it exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code).toContain(`${SRC_DIR}/loading.ts`)
+  })
+
+  it('includes AUTO-GENERATED comment when loading file exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
+  })
+
+  it('checks for loading.ts specifically', async () => {
+    await generateLoadingCode(SRC_DIR)
+    expect(existsSync).toHaveBeenCalledWith(`${SRC_DIR}/loading.ts`)
+  })
+
+  it('does not include hasLoading=true when file is missing', async () => {
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code).not.toContain('hasLoading = true')
+  })
+
+  it('does not include hasLoading=false when file exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code).not.toContain('hasLoading = false')
+  })
+
+  it('ends with a newline when file is missing', async () => {
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code.endsWith('\n')).toBe(true)
+  })
+
+  it('ends with a newline when file exists', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    const code = await generateLoadingCode(SRC_DIR)
+    expect(code.endsWith('\n')).toBe(true)
+  })
+})

package/src/__tests__/plugin/virtual/middleware.test.ts

@@ -30,7 +30,7 @@ describe('generateMiddlewareCode', () => {
   it('includes AUTO-GENERATED comment', async () => {
     vi.mocked(scanDirectory).mockResolvedValue([`${MIDDLEWARE}/auth.ts`])
     const code = await generateMiddlewareCode(MIDDLEWARE)
-    expect(code).toContain('AUTO-GENERATED by vite-plugin-cer-app')
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
   })
 
   it('generates default import and registers under filename key', async () => {

package/src/__tests__/plugin/virtual/plugins.test.ts

@@ -30,7 +30,7 @@ describe('generatePluginsCode', () => {
   it('includes AUTO-GENERATED comment', async () => {
     vi.mocked(scanDirectory).mockResolvedValue([`${PLUGINS}/store.ts`])
     const code = await generatePluginsCode(PLUGINS)
-    expect(code).toContain('AUTO-GENERATED by vite-plugin-cer-app')
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
   })
 
   it('generates default import with alias _p0 for first plugin', async () => {

package/src/__tests__/plugin/virtual/routes.test.ts

@@ -33,7 +33,7 @@ describe('generateRoutesCode', () => {
 
   it('includes AUTO-GENERATED comment', async () => {
     const code = await generateRoutesCode(PAGES)
-    expect(code).toContain('AUTO-GENERATED by vite-plugin-cer-app')
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
   })
 
   it('generates a lazy load() route for a static page', async () => {

package/src/__tests__/plugin/virtual/server-api.test.ts

@@ -30,7 +30,7 @@ describe('generateServerApiCode', () => {
   it('includes AUTO-GENERATED comment', async () => {
     vi.mocked(scanDirectory).mockResolvedValue([`${API}/health.ts`])
     const code = await generateServerApiCode(API)
-    expect(code).toContain('AUTO-GENERATED by vite-plugin-cer-app')
+    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
   })
 
   it('prefixes route path with /api/', async () => {