@macedon-technologies/batman 1.23.0 → 1.24.1

package/lib/ViteReactProject.js

@@ -14,7 +14,7 @@ class ViteReactProject extends typescript_1.TypeScriptAppProject {
     devCommand;
     configFields;
     constructor(options) {
-        const { sampleCode = true, srcdir = 'src', publicDir = 'public', title, ...restOptions } = options;
+        const { sampleCode = true, srcdir = 'src', publicDir = 'public', title, e2eTesting = true, ...restOptions } = options;
         super({
             ...restOptions,
             sampleCode: false, // We'll handle sample code ourselves
@@ -87,6 +87,12 @@ class ViteReactProject extends typescript_1.TypeScriptAppProject {
                 publicDir: this.publicDir,
             });
         }
+        // Add Playwright e2e testing support
+        if (e2eTesting) {
+            new PlaywrightE2EComponent(this, {
+                publicDir: this.publicDir,
+            });
+        }
         // Use relative path for devCommand
         const relativeOutdir = this.parent
             ? (0, path_1.relative)(this.parent.outdir, this.outdir)
@@ -667,4 +673,290 @@ html, body, #root {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ViteReactProject.js","sourceRoot":"","sources":["../src/ViteReactProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { relative, basename } from 'path';\nimport { Component, FileBase, JsonFile, Project, SampleFile, TextFile } from 'projen';\nimport { TypeScriptAppProject, TypeScriptProjectOptions } from 'projen/lib/typescript';\nimport { BatmanProject } from './BatmanProject';\nimport { runScriptCommand } from './utils';\n\nexport interface ViteReactProjectOptions extends TypeScriptProjectOptions {\n  /**\n   * Whether to generate sample code\n   * @default true\n   */\n  readonly sampleCode?: boolean;\n\n  /**\n   * Source directory\n   * @default \"src\"\n   */\n  readonly srcdir?: string;\n\n  /**\n   * Public directory for static assets\n   * @default \"public\"\n   */\n  readonly publicDir?: string;\n\n  /**\n   * Title for the HTML page\n   * @default project name\n   */\n  readonly title?: string;\n}\n\n/**\n * Vite + React TypeScript project\n */\nexport class ViteReactProject extends TypeScriptAppProject {\n  public readonly srcdir: string;\n  public readonly publicDir: string;\n  public readonly devCommand: string;\n  private readonly configFields: Map<string, string>;\n\n  constructor(options: ViteReactProjectOptions) {\n    const {\n      sampleCode = true,\n      srcdir = 'src',\n      publicDir = 'public',\n      title,\n      ...restOptions\n    } = options;\n    super({\n      ...restOptions,\n      sampleCode: false, // We'll handle sample code ourselves\n      eslint: false, // We'll configure eslint ourselves\n      jest: false, // Vite uses vitest typically\n      package: true,\n      disableTsconfig: true, // We'll manage tsconfig ourselves\n      packageManager: (restOptions.parent as BatmanProject).package.packageManager,\n      pnpmOptions: {\n        workspaceYamlOptions: {\n          // This subproject has its own separate lockfile/store from its parent,\n          // so it needs its own approval for the native postinstall scripts its\n          // fixed dependency set always needs (esbuild's binary download, and\n          // @clerk/clerk-react's transitive @clerk/shared setup script).\n          allowBuilds: {\n            'esbuild': true,\n            '@clerk/shared': true,\n          },\n          ...restOptions.pnpmOptions?.workspaceYamlOptions,\n        },\n      },\n      deps: [\n        '@clerk/clerk-react',\n        '@tanstack/react-query',\n        '@tailwindcss/postcss',\n        'autoprefixer',\n        'postcss',\n        'tailwindcss',\n        'rollup',\n        ...(options.deps ? options.deps : []),\n      ],\n    });\n\n    // Initialize config fields storage\n    this.configFields = new Map<string, string>();\n\n    this.srcdir = srcdir;\n    this.publicDir = publicDir;\n\n    // Add Vite component\n    new ViteComponent(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add ESLint configuration\n    new ViteEslintConfig(this);\n\n    // Add index.html\n    new IndexHtml(this, {\n      title: title ?? this.name,\n      srcdir: this.srcdir,\n    });\n\n    // Add TypeScript configs\n    new ViteTsConfigs(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add .gitignore entries\n    this.gitignore?.addPatterns('dist', 'dist-ssr', '*.local');\n\n    // Add vite-env.d.ts for type declarations\n    new ViteEnvDts(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add PostCSS config for Tailwind\n    new PostCSSConfigFile(this);\n\n    // Add config.ts for runtime configuration\n    new ConfigFile(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add sample config.json\n    new ConfigJsonFile(this, { });\n\n\n    // Add sample code if requested\n    if (sampleCode) {\n      new ViteSampleCode(this, {\n        srcdir: this.srcdir,\n        publicDir: this.publicDir,\n      });\n    }\n\n    // Use relative path for devCommand\n    const relativeOutdir = this.parent\n      ? relative(this.parent.outdir, this.outdir)\n      : basename(this.outdir);\n    this.devCommand = `cd ${relativeOutdir} && ${runScriptCommand(this.package.packageManager, 'dev')}`;\n  }\n\n  /**\n   * Add a custom field to the Config type\n   * @param fieldName The name of the field\n   * @param fieldType The TypeScript type of the field (e.g., 'string', 'number', 'boolean', 'string[]')\n   * @returns this project instance for chaining\n   */\n  addConfigField(fieldName: string, fieldType: string): this {\n    this.configFields.set(fieldName, fieldType);\n    return this;\n  }\n\n  /**\n   * Get the config fields map (for internal use by ConfigFile)\n   * @internal\n   */\n  getConfigFields(): Map<string, string> {\n    return this.configFields;\n  }\n}\n\ninterface ViteComponentOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Configures Vite dependencies and scripts\n */\nclass ViteComponent extends Component {\n  constructor(project: TypeScriptAppProject, _options: ViteComponentOptions) {\n    super(project);\n\n    const tsProject = project as TypeScriptAppProject;\n\n    // Set package type to module for ESM support\n    tsProject.package.addField('type', 'module');\n\n    // Add React dependencies\n    tsProject.addDeps('react@^19.2.0', 'react-dom@^19.2.0');\n\n    // Add dev dependencies\n    tsProject.addDevDeps(\n      '@types/react@^19.2.2',\n      '@types/react-dom@^19.2.2',\n      '@vitejs/plugin-react@^5.1.0',\n      'vite@^5.4.0',\n      'typescript@~5.9.3',\n      '@eslint/js@^9.39.1',\n      'eslint@^9.39.1',\n      'eslint-plugin-react-hooks@^5.2.0',\n      'eslint-plugin-react-refresh@^0.4.24',\n      'globals@^16.5.0',\n      'typescript-eslint@^8.46.3',\n    );\n\n    // Create vite.config.ts as a managed file\n    new ViteConfigFile(project);\n\n    // Add scripts\n    tsProject.addTask('dev', {\n      description: 'Start development server',\n      exec: 'vite',\n    });\n\n    // Remove and recreate build task to customize it for Vite\n    tsProject.removeTask('build');\n    tsProject.addTask('build', {\n      description: 'Build for production',\n      exec: 'tsc -b && vite build',\n    });\n\n    tsProject.addTask('preview', {\n      description: 'Preview production build',\n      exec: 'vite preview',\n    });\n\n    tsProject.addTask('lint', {\n      description: 'Lint code',\n      exec: 'eslint .',\n    });\n  }\n}\n\n/**\n * Creates the ESLint configuration for Vite + React\n */\nclass ViteEslintConfig extends FileBase {\n  constructor(project: Project) {\n    super(project, 'eslint.config.js', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `import js from '@eslint/js'\nimport globals from 'globals'\nimport reactHooks from 'eslint-plugin-react-hooks'\nimport reactRefresh from 'eslint-plugin-react-refresh'\nimport tseslint from 'typescript-eslint'\n\nexport default [\n  { ignores: ['dist'] },\n  {\n    files: ['**/*.{ts,tsx}'],\n    languageOptions: {\n      ecmaVersion: 2020,\n      globals: globals.browser,\n    },\n    plugins: {\n      'react-hooks': reactHooks,\n      'react-refresh': reactRefresh,\n    },\n    rules: {\n      ...reactHooks.configs.recommended.rules,\n      'react-refresh/only-export-components': [\n        'warn',\n        { allowConstantExport: true },\n      ],\n    },\n  },\n  js.configs.recommended,\n  ...tseslint.configs.recommended,\n]\n`;\n  }\n}\n\n/**\n * Creates the vite.config.ts file\n */\nclass ViteConfigFile extends FileBase {\n  constructor(project: Project) {\n    super(project, 'vite.config.ts', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `import { defineConfig } from 'vite'\nimport react from '@vitejs/plugin-react'\n\n// https://vite.dev/config/\nexport default defineConfig({\n  plugins: [react()],\n})\n`;\n  }\n}\n\n/**\n * Creates the postcss.config.js file for Tailwind CSS v4\n */\nclass PostCSSConfigFile extends FileBase {\n  constructor(project: Project) {\n    super(project, 'postcss.config.js', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `export default {\n  plugins: {\n    \"@tailwindcss/postcss\": {},\n    autoprefixer: {},\n  },\n}\n`;\n  }\n}\n\ninterface ViteEnvDtsOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the vite-env.d.ts file for type declarations\n */\nclass ViteEnvDts extends FileBase {\n  constructor(project: Project, options: ViteEnvDtsOptions) {\n    super(project, `${options.srcdir}/vite-env.d.ts`, {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `/// <reference types=\"vite/client\" />\n`;\n  }\n}\n\ninterface ConfigFileOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the config.ts file for runtime configuration\n */\nclass ConfigFile extends FileBase {\n  constructor(project: Project, options: ConfigFileOptions) {\n    super(project, `${options.srcdir}/config.ts`, {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    // Get custom config fields from parent project\n    const viteProject = this.project as ViteReactProject;\n    const customFields = viteProject.getConfigFields();\n\n    // Generate base config type\n    const baseConfigType = `type BaseConfig = {\n  clerkPublishableKey: string;\n  apiBaseUrl: string;\n  timeout: number;\n}`;\n\n    // Generate custom fields type if any exist\n    let configTypeDefinition: string;\n    if (customFields.size > 0) {\n      const fieldDefinitions = Array.from(customFields.entries())\n        .map(([name, type]) => `  ${name}: ${type};`)\n        .join('\\n');\n\n      const customFieldsType = `type CustomConfig = {\n${fieldDefinitions}\n}`;\n\n      configTypeDefinition = `${customFieldsType}\n\nexport type Config = BaseConfig & CustomConfig;`;\n    } else {\n      configTypeDefinition = 'export type Config = BaseConfig;';\n    }\n\n    return `import { useEffect, useState } from 'react';\n\n${baseConfigType}\n\n${configTypeDefinition}\n\nexport function useConfig() {\n  const [loadedConfig, setLoadedConfig] = useState<Config|undefined>();\n  const [isLoading, setIsLoading] = useState(false);\n\n  useEffect(() => {\n    if (!loadedConfig) {\n      fetch('/config.json', { cache: 'no-store' }).then(response=>{\n        response.json().then((config) => {\n          setIsLoading(false)\n          setLoadedConfig(config)\n        });\n      });\n\n    }\n  }, [loadedConfig]);\n\n  return { config: loadedConfig, isLoading };\n}\n`;\n  }\n}\n\ninterface ConfigJsonFileOptions {}\n\n/**\n * Creates the config.json sample file for runtime configuration\n */\nclass ConfigJsonFile extends SampleFile {\n  path: string;\n  constructor(project: ViteReactProject, _options: ConfigJsonFileOptions) {\n    super(project, `${project.publicDir}/config.json`, {\n      contents: JSON.stringify({\n        apiBaseUrl: 'http://localhost:3000/api',\n        clerkPublishableKey: 'tbd',\n      }, null, 2),\n    });\n    this.path = `${project.publicDir}/config.json`;\n  }\n}\n\ninterface IndexHtmlOptions {\n  readonly title: string;\n  readonly srcdir: string;\n}\n\n/**\n * Creates the index.html file\n */\nclass IndexHtml extends SampleFile {\n  constructor(project: Project, options: IndexHtmlOptions) {\n    super(project, 'index.html', {\n      contents: `<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <link rel=\"icon\" type=\"image/svg+xml\" href=\"/vite.svg\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>${options.title}</title>\n  </head>\n  <body>\n    <div id=\"root\"></div>\n    <script type=\"module\" src=\"/${options.srcdir}/main.tsx\"></script>\n  </body>\n</html>\n`,\n    });\n  }\n}\n\ninterface ViteTsConfigsOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the TypeScript configuration files for Vite\n */\nclass ViteTsConfigs extends Component {\n  constructor(project: Project, options: ViteTsConfigsOptions) {\n    super(project);\n\n    // Main tsconfig.json (project references)\n    new JsonFile(project, 'tsconfig.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        files: [],\n        references: [\n          { path: './tsconfig.app.json' },\n          { path: './tsconfig.node.json' },\n        ],\n      },\n    });\n\n    // tsconfig.app.json (for application code)\n    new JsonFile(project, 'tsconfig.app.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        compilerOptions: {\n          target: 'ES2020',\n          useDefineForClassFields: true,\n          lib: ['ES2020', 'DOM', 'DOM.Iterable'],\n          module: 'ESNext',\n          skipLibCheck: true,\n\n          // Bundler mode\n          moduleResolution: 'bundler',\n          allowImportingTsExtensions: true,\n          isolatedModules: true,\n          moduleDetection: 'force',\n          noEmit: true,\n          jsx: 'react-jsx',\n\n          // Linting\n          strict: true,\n          noUnusedLocals: true,\n          noUnusedParameters: true,\n          noFallthroughCasesInSwitch: true,\n          noUncheckedSideEffectImports: true,\n        },\n        include: [options.srcdir],\n      },\n    });\n\n    // tsconfig.node.json (for Vite config)\n    new JsonFile(project, 'tsconfig.node.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        compilerOptions: {\n          target: 'ES2022',\n          lib: ['ES2023'],\n          module: 'ESNext',\n          skipLibCheck: true,\n\n          // Bundler mode\n          moduleResolution: 'bundler',\n          allowImportingTsExtensions: true,\n          isolatedModules: true,\n          moduleDetection: 'force',\n          noEmit: true,\n\n          // Linting\n          strict: true,\n          noUnusedLocals: true,\n          noUnusedParameters: true,\n          noFallthroughCasesInSwitch: true,\n        },\n        include: ['vite.config.ts'],\n      },\n    });\n  }\n}\n\ninterface ViteSampleCodeOptions {\n  readonly srcdir: string;\n  readonly publicDir: string;\n}\n\n/**\n * Generates sample code for a Vite + React project\n */\nclass ViteSampleCode extends Component {\n  constructor(project: Project, options: ViteSampleCodeOptions) {\n    super(project);\n\n    // Create App.tsx\n    new SampleFile(project, `${options.srcdir}/App.tsx`, {\n      contents: `import './App.css'\nimport { SignedIn, UserButton } from '@clerk/clerk-react';\nimport { useBaseQuery } from \"./services/BaseService.ts\";\n\n\nfunction App() {\n  const {data, isLoading} = useBaseQuery('/', {retryOnMount: true});\n\n\n  return (\n    <>\n        <header>\n\n          <SignedIn>\n            <UserButton/>\n          </SignedIn>\n        </header>\n        <div className=\"card\">\n          { isLoading ? 'Loading...' : JSON.stringify(data, null ,)}\n        </div>\n    </>\n  )\n}\n\nexport default App\n`,\n    });\n\n    // Create BaseService.ts\n    new TextFile(project, `${options.srcdir}/services/BaseService.ts`, {\n      marker: true,\n      readonly: true,\n      lines: [\n        'import { useQuery, UseQueryOptions } from \\'@tanstack/react-query\\';',\n        'import { useAuth } from \\'@clerk/clerk-react\\';',\n        'import { useConfig } from \\'../config\\';',\n        '',\n        'export function useBaseQuery<TData = unknown>(',\n        '  path: string,',\n        '  options?: Omit<UseQueryOptions<TData>, \\'queryKey\\' | \\'queryFn\\'>',\n        ') {',\n        '  const { config } = useConfig();',\n        '  const { getToken } = useAuth();',\n        '',\n        '  return useQuery<TData>({',\n        '    queryKey: [\\'base\\'],',\n        '    queryFn: async () => {',\n        '      if (!config?.apiBaseUrl) {',\n        '        throw new Error(\\'API base URL not configured\\');',\n        '      }',\n        '',\n        '      const token = await getToken();',\n        '',\n        '      // Normalize URL by removing trailing slash from baseUrl and ensuring path starts with slash',\n        '      const baseUrl = config.apiBaseUrl.replace(/\\\\/+$/, \\'\\');',\n        '      const normalizedPath = path.startsWith(\\'/\\') ? path : `/${path}`;',\n        '      ',\n        '      const response = await fetch(`${baseUrl}${normalizedPath}`, {',\n        '        headers: {',\n        '          \\'Authorization\\': `Bearer ${token}`,',\n        '        },',\n        '      });',\n        '',\n        '      if (!response.ok) {',\n        '        throw new Error(`HTTP error! status: ${response.status}`);',\n        '      }',\n        '',\n        '      return response.json();',\n        '    },',\n        '    enabled: !!config?.apiBaseUrl,',\n        '    ...options,',\n        '  });',\n        '}',\n      ],\n    });\n\n    // Create RootService.ts\n    new SampleFile(project, `${options.srcdir}/services/RootService.ts`, {\n      contents: `import { UseQueryOptions } from '@tanstack/react-query';\nimport { useBaseQuery } from './BaseService';\n\nexport function useRootQuery<TData = unknown>(\n  options?: Omit<UseQueryOptions<TData>, 'queryKey' | 'queryFn'>\n) {\n  return useBaseQuery<TData>('/', options);\n}\n`,\n    });\n\n    // Create App.css\n    new SampleFile(project, `${options.srcdir}/App.css`, {\n      contents: `#root {\n  width: 100%;\n  height: 100%;\n}\n\n.logo {\n  height: 6em;\n  padding: 1.5em;\n  will-change: filter;\n  transition: filter 300ms;\n}\n.logo:hover {\n  filter: drop-shadow(0 0 2em #646cffaa);\n}\n.logo.react:hover {\n  filter: drop-shadow(0 0 2em #61dafbaa);\n}\n\n@keyframes logo-spin {\n  from {\n    transform: rotate(0deg);\n  }\n  to {\n    transform: rotate(360deg);\n  }\n}\n\n@media (prefers-reduced-motion: no-preference) {\n  a:nth-of-type(2) .logo {\n    animation: logo-spin infinite 20s linear;\n  }\n}\n\n.card {\n  padding: 2em;\n}\n\n.read-the-docs {\n  color: #888;\n}\n`,\n    });\n\n    // Create main.tsx\n    new SampleFile(project, `${options.srcdir}/main.tsx`, {\n      contents: `import { StrictMode } from 'react'\nimport { createRoot } from 'react-dom/client'\nimport './index.css'\nimport App from './App.tsx'\nimport { ClerkProvider, SignedIn, SignedOut, SignInButton } from '@clerk/clerk-react'\nimport { useConfig } from './config'\nimport { QueryClient, QueryClientProvider } from \"@tanstack/react-query\"\n\nfunction AppWrapper() {\n  const { config, isLoading } = useConfig();\n  const queryClient = new QueryClient()\n  if (isLoading || !config) {\n    return (\n      <div className=\"loading-screen\">\n        Loading...\n      </div>\n    );\n  }\n\n  return (\n    <ClerkProvider publishableKey={config.clerkPublishableKey}>\n      <QueryClientProvider client={queryClient}>\n        <div className=\"w-full h-full\">\n          <SignedOut>\n            <div className=\"flex items-center justify-center min-h-screen\">\n              <SignInButton/>\n            </div>\n          </SignedOut>\n          <SignedIn>\n            <App/>\n          </SignedIn>\n        </div>\n      </QueryClientProvider>\n    </ClerkProvider>\n  );\n}\n\ncreateRoot(document.getElementById('root')!).render(\n  <StrictMode>\n    <AppWrapper/>\n  </StrictMode>\n)\n`,\n    });\n\n    // Create index.css\n    new SampleFile(project, `${options.srcdir}/index.css`, {\n      contents: `@import \"tailwindcss\";\n\n@theme {\n  --color-scheme: light dark;\n}\n\n:root {\n  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;\n  line-height: 1.5;\n  font-weight: 400;\n\n  color-scheme: light dark;\n\n  font-synthesis: none;\n  text-rendering: optimizeLegibility;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\na {\n  font-weight: 500;\n  color: #646cff;\n  text-decoration: inherit;\n}\na:hover {\n  color: #535bf2;\n}\n\nbody {\n  margin: 0;\n  min-width: 320px;\n  min-height: 100vh;\n}\n\nh1 {\n  font-size: 3.2em;\n  line-height: 1.1;\n}\n\nbutton {\n  font-family: inherit;\n  cursor: pointer;\n}\n\n.loading-screen {\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  height: 100vh;\n  font-size: 1.5rem;\n}\n\nhtml, body, #root {\n  width: 100%;\n  height: 100%;\n}\n`,\n    });\n\n  }\n}\n"]}
+/**
+ * Adds Playwright e2e testing support: devDeps, a `test:e2e` task, e2e-related
+ * .gitignore entries, and a scaffolded (one-time, not regenerated on synth)
+ * `playwright.config.ts` + `e2e/` starter suite. Generalizes the hand-authored
+ * suite added in macedon-technologies/exman#112 so every ViteReactProject
+ * consumer gets it for free (macedon-technologies/platform-common#98).
+ */
+class PlaywrightE2EComponent extends projen_1.Component {
+    constructor(project, options) {
+        super(project);
+        project.addDevDeps('@playwright/test@^1.63.0', '@clerk/testing@^2.2.34', '@clerk/backend@^3.17.2', 'dotenv@^17.4.2');
+        project.addTask('test:e2e', {
+            description: 'Run the Playwright e2e suite (needs CLERK_SECRET_KEY and E2E_CLERK_USER_ID -- see e2e/README.md)',
+            exec: 'playwright test',
+        });
+        project.addGitIgnore('playwright-report/');
+        project.addGitIgnore('test-results/');
+        project.addGitIgnore('blob-report/');
+        // `*.local` (added elsewhere) already covers `.env.local`, but not a plain `.env` --
+        // exactly where CLERK_SECRET_KEY (a real secret) is documented to go (e2e/README.md).
+        project.addGitIgnore('.env');
+        new PlaywrightConfigFile(project);
+        new E2EGlobalSetupFile(project, options);
+        new E2EClerkSignInFile(project);
+        new E2ELiveHelperFile(project);
+        new E2ESmokeSpecFile(project);
+        new E2EReadmeFile(project);
+    }
+}
+/**
+ * Creates the playwright.config.ts file. A `SampleFile`, not a managed `FileBase` --
+ * consumers need to customize this (e.g. exman's own config needed a live/stub
+ * branch), the same reason ViteReactProject's App.tsx/main.tsx are SampleFiles too.
+ */
+class PlaywrightConfigFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'playwright.config.ts', {
+            contents: `import { config as loadDotenv } from 'dotenv'
+import { defineConfig, devices } from '@playwright/test'
+import { isLiveRun } from './e2e/support/live'
+
+// Loaded here, first, rather than left to @clerk/testing's own internal dotenv call
+// inside global-setup.ts: that call runs inside globalSetup, which executes AFTER
+// Playwright has already collected every spec file and run their module-level code --
+// so anything reading process.env before then would only ever see a .env file's values
+// as unset. Loading it here, at the top of the config file Playwright reads before
+// anything else, means it's populated for collection, globalSetup, and every test.
+loadDotenv()
+
+// Set E2E_BASE_URL to run against a real deployment (e.g. a PR's pr-deploy WebsiteUrl)
+// instead of a local dev server -- see e2e/support/live.ts and e2e/README.md.
+// \`|| undefined\`, not \`??\`: an empty string (e.g. an unset GitHub Actions output) is
+// not null/undefined, so ?? would leave baseURL as '' while isLiveRun()'s plain !!
+// check still read the run as non-live -- an invalid, silently-mismatched config.
+const liveBaseUrl = process.env.E2E_BASE_URL || undefined
+
+export default defineConfig({
+  testDir: './e2e',
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 1 : 0,
+  reporter: process.env.CI ? [['html', { open: 'never' }]] : 'list',
+  globalSetup: './e2e/support/global-setup.ts',
+  use: {
+    baseURL: liveBaseUrl ?? 'http://localhost:5173',
+    trace: 'on-first-retry',
+  },
+  projects: [
+    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
+  ],
+  // No local server to manage when pointed at a live deployment.
+  webServer: isLiveRun() ? undefined : {
+    command: '${(0, utils_1.runScriptCommand)(project.package.packageManager, 'dev')}',
+    url: 'http://localhost:5173',
+    reuseExistingServer: !process.env.CI,
+    timeout: 60_000,
+  },
+})
+`,
+        });
+    }
+}
+/**
+ * Creates e2e/support/global-setup.ts, which primes @clerk/testing for the sign-in
+ * flow in clerk-sign-in.ts. Reads the Clerk publishable key from the scaffolded
+ * public/config.json (ConfigJsonFile) rather than hardcoding one -- ViteReactProject's
+ * own app fetches that key at runtime the same way (see config.ts), so there's no
+ * build-time constant this construct could embed instead.
+ */
+class E2EGlobalSetupFile extends projen_1.SampleFile {
+    constructor(project, options) {
+        super(project, 'e2e/support/global-setup.ts', {
+            contents: `import { readFileSync } from 'fs'
+import { clerkSetup } from '@clerk/testing/playwright'
+
+// A no-op (not a throw) when CLERK_SECRET_KEY is missing: every spec that needs a
+// signed-in user already skips itself in that case (see ../smoke.spec.ts), so running
+// the suite without secrets configured yet reports "skipped", not a crashed global
+// setup. See e2e/README.md for how to get a secret key.
+export default async function globalSetup() {
+  if (!process.env.CLERK_SECRET_KEY) {
+    return
+  }
+
+  // import.meta.url, not __dirname: the web package sets "type": "module" (ViteComponent),
+  // so this file runs as ESM, where __dirname isn't defined. fs.readFileSync accepts a URL
+  // directly, so no need to convert it to a path first.
+  const configPath = new URL('../../${options.publicDir}/config.json', import.meta.url)
+  const { clerkPublishableKey } = JSON.parse(readFileSync(configPath, 'utf-8'))
+
+  await clerkSetup({ publishableKey: clerkPublishableKey })
+}
+`,
+        });
+    }
+}
+/**
+ * Creates e2e/support/clerk-sign-in.ts. Signs in as a specific Clerk user by id via a
+ * backend-issued sign-in token (ticket strategy), bypassing the app's actual sign-in
+ * UI -- which typically only exposes an OAuth provider button that can't be driven
+ * reliably from a test. @clerk/testing/playwright's own `clerk.signIn({ emailAddress })`
+ * does the same ticket exchange internally after an extra email->user lookup; going
+ * from a user id directly (E2E_CLERK_USER_ID) skips that lookup and its failure mode
+ * (an existing user without a verified email attached).
+ */
+class E2EClerkSignInFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'e2e/support/clerk-sign-in.ts', {
+            contents: `import { createClerkClient } from '@clerk/backend'
+import { clerk } from '@clerk/testing/playwright'
+import type { Page } from '@playwright/test'
+
+/**
+ * Signs in as a specific Clerk user by id. Requires CLERK_SECRET_KEY (also used by
+ * global-setup.ts) and a prior page.goto() to a page that loads Clerk.
+ */
+export async function signInAsUser(page: Page, userId: string): Promise<void> {
+  const clerkClient = createClerkClient({ secretKey: process.env.CLERK_SECRET_KEY })
+  const { token } = await clerkClient.signInTokens.createSignInToken({
+    userId,
+    expiresInSeconds: 300,
+  })
+  await clerk.signIn({ page, signInParams: { strategy: 'ticket', ticket: token } })
+}
+`,
+        });
+    }
+}
+/**
+ * Creates e2e/support/live.ts.
+ */
+class E2ELiveHelperFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'e2e/support/live.ts', {
+            contents: `/**
+ * True when this run targets a real deployment (E2E_BASE_URL set -- see
+ * playwright.config.ts) rather than a local dev server. Specs read this to decide
+ * whether to stub the backend: a live run must hit the real API to prove anything,
+ * and stubbing it would just be testing the stub.
+ */
+export function isLiveRun(): boolean {
+  return !!process.env.E2E_BASE_URL
+}
+`,
+        });
+    }
+}
+/**
+ * Creates e2e/smoke.spec.ts -- a generic starter test that only relies on markup
+ * ViteReactProject's own scaffolded main.tsx/App.tsx always render (SignedIn/
+ * UserButton), so it works before a consumer has written any real pages. Consumers
+ * are expected to extend/replace this with real flows, the same way they already
+ * customize App.tsx.
+ */
+class E2ESmokeSpecFile extends projen_1.SampleFile {
+    constructor(project) {
+        super(project, 'e2e/smoke.spec.ts', {
+            contents: `import { test, expect } from '@playwright/test'
+import { signInAsUser } from './support/clerk-sign-in'
+
+test('signs in and shows the authenticated UserButton', async ({ page }) => {
+  // Read from inside the test body, not module scope: Playwright collects (requires)
+  // this file before running globalSetup, so a module-level check would always see a
+  // .env-sourced value as unset. Exporting the var in the shell works either way.
+  const testUserId = process.env.E2E_CLERK_USER_ID
+  test.skip(
+    !testUserId || !process.env.CLERK_SECRET_KEY,
+    'E2E_CLERK_USER_ID and CLERK_SECRET_KEY must both be set -- see e2e/README.md',
+  )
+
+  // signInAsUser requires a prior page.goto() to a page that loads Clerk.
+  await page.goto('/')
+  await signInAsUser(page, testUserId!)
+  await page.goto('/')
+
+  // '.cl-userButtonTrigger' is one of Clerk's own documented, stable \`cl-\`-prefixed
+  // class hooks (part of its theming/appearance API), not an incidental DOM detail --
+  // safer to depend on across Clerk versions than app-specific markup this construct
+  // doesn't control.
+  await expect(page.locator('.cl-userButtonTrigger')).toBeVisible()
+})
+`,
+        });
+    }
+}
+/**
+ * Creates e2e/README.md documenting the one-time setup and env var convention every
+ * consumer needs, so it doesn't have to be re-derived by hand per repo.
+ */
+class E2EReadmeFile extends projen_1.SampleFile {
+    constructor(project) {
+        const testE2eCommand = (0, utils_1.runScriptCommand)(project.package.packageManager, 'test:e2e');
+        super(project, 'e2e/README.md', {
+            contents: `# Playwright e2e suite
+
+Runs against a real dev server (or a live deployment, via \`E2E_BASE_URL\`) and real
+Clerk authentication.
+
+## One-time setup
+
+1. Install Playwright's browser binary (not covered by a plain dependency install):
+
+   \`\`\`bash
+   npx playwright install chromium
+   \`\`\`
+
+2. Get two values from your Clerk dashboard's dev instance:
+
+   - \`CLERK_SECRET_KEY\` -- the **secret** key (API Keys). Never commit this; export it
+     in your shell or put it in a local, gitignored \`.env\`.
+   - \`E2E_CLERK_USER_ID\` -- the id (\`user_...\`) of an existing test user (Users -> click
+     a user, the id is shown at the top). The user needs a verified email address, not
+     just an OAuth connection -- a sign-in token has to bind to a verified
+     identification. Creating a dedicated test user with an email set explicitly is the
+     safer default.
+
+   A run with either variable unset **skips** rather than failing, so \`${testE2eCommand}\`
+   is always safe to run without them.
+
+3. This construct doesn't manage \`vitest.config.ts\` (it's a hand-authored,
+   per-consumer file). Add an \`exclude\` entry so vitest's default test glob doesn't
+   also try to pick up these Playwright spec files:
+
+   \`\`\`ts
+   import { defineConfig, configDefaults } from 'vitest/config'
+
+   export default defineConfig({
+     test: {
+       exclude: [...configDefaults.exclude, 'e2e/**'],
+       // ...your existing config
+     },
+   })
+   \`\`\`
+
+## Running
+
+\`\`\`bash
+CLERK_SECRET_KEY=... E2E_CLERK_USER_ID=... ${testE2eCommand}
+\`\`\`
+
+## Running against a live environment
+
+Set \`E2E_BASE_URL\` to point the suite at a real deployment (a personal dev stack, or a
+PR's pr-deploy \`WebsiteUrl\`, posted as a PR comment) instead of a local dev server:
+
+\`\`\`bash
+E2E_BASE_URL=https://<your-stack>.example.com \\
+CLERK_SECRET_KEY=... E2E_CLERK_USER_ID=... \\
+${testE2eCommand}
+\`\`\`
+
+## CI
+
+The generated \`pr-deploy.yml\` workflow (see \`PrDeployWorkflow\`) already runs this
+suite against each PR's deployed \`WebsiteUrl\` and uploads the HTML report as a build
+artifact on failure. It self-skips exactly like a local run until both secrets exist
+in the repo:
+
+\`\`\`bash
+gh secret set CLERK_SECRET_KEY
+gh secret set E2E_CLERK_USER_ID
+\`\`\`
+`,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ViteReactProject.js","sourceRoot":"","sources":["../src/ViteReactProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { relative, basename } from 'path';\nimport { Component, FileBase, JsonFile, Project, SampleFile, TextFile } from 'projen';\nimport { TypeScriptAppProject, TypeScriptProjectOptions } from 'projen/lib/typescript';\nimport { BatmanProject } from './BatmanProject';\nimport { runScriptCommand } from './utils';\n\nexport interface ViteReactProjectOptions extends TypeScriptProjectOptions {\n  /**\n   * Whether to generate sample code\n   * @default true\n   */\n  readonly sampleCode?: boolean;\n\n  /**\n   * Source directory\n   * @default \"src\"\n   */\n  readonly srcdir?: string;\n\n  /**\n   * Public directory for static assets\n   * @default \"public\"\n   */\n  readonly publicDir?: string;\n\n  /**\n   * Title for the HTML page\n   * @default project name\n   */\n  readonly title?: string;\n\n  /**\n   * Whether to add Playwright e2e testing support (devDeps, a `test:e2e` task,\n   * and a scaffolded `playwright.config.ts` + `e2e/` starter suite).\n   * @default true\n   */\n  readonly e2eTesting?: boolean;\n}\n\n/**\n * Vite + React TypeScript project\n */\nexport class ViteReactProject extends TypeScriptAppProject {\n  public readonly srcdir: string;\n  public readonly publicDir: string;\n  public readonly devCommand: string;\n  private readonly configFields: Map<string, string>;\n\n  constructor(options: ViteReactProjectOptions) {\n    const {\n      sampleCode = true,\n      srcdir = 'src',\n      publicDir = 'public',\n      title,\n      e2eTesting = true,\n      ...restOptions\n    } = options;\n    super({\n      ...restOptions,\n      sampleCode: false, // We'll handle sample code ourselves\n      eslint: false, // We'll configure eslint ourselves\n      jest: false, // Vite uses vitest typically\n      package: true,\n      disableTsconfig: true, // We'll manage tsconfig ourselves\n      packageManager: (restOptions.parent as BatmanProject).package.packageManager,\n      pnpmOptions: {\n        workspaceYamlOptions: {\n          // This subproject has its own separate lockfile/store from its parent,\n          // so it needs its own approval for the native postinstall scripts its\n          // fixed dependency set always needs (esbuild's binary download, and\n          // @clerk/clerk-react's transitive @clerk/shared setup script).\n          allowBuilds: {\n            'esbuild': true,\n            '@clerk/shared': true,\n          },\n          ...restOptions.pnpmOptions?.workspaceYamlOptions,\n        },\n      },\n      deps: [\n        '@clerk/clerk-react',\n        '@tanstack/react-query',\n        '@tailwindcss/postcss',\n        'autoprefixer',\n        'postcss',\n        'tailwindcss',\n        'rollup',\n        ...(options.deps ? options.deps : []),\n      ],\n    });\n\n    // Initialize config fields storage\n    this.configFields = new Map<string, string>();\n\n    this.srcdir = srcdir;\n    this.publicDir = publicDir;\n\n    // Add Vite component\n    new ViteComponent(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add ESLint configuration\n    new ViteEslintConfig(this);\n\n    // Add index.html\n    new IndexHtml(this, {\n      title: title ?? this.name,\n      srcdir: this.srcdir,\n    });\n\n    // Add TypeScript configs\n    new ViteTsConfigs(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add .gitignore entries\n    this.gitignore?.addPatterns('dist', 'dist-ssr', '*.local');\n\n    // Add vite-env.d.ts for type declarations\n    new ViteEnvDts(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add PostCSS config for Tailwind\n    new PostCSSConfigFile(this);\n\n    // Add config.ts for runtime configuration\n    new ConfigFile(this, {\n      srcdir: this.srcdir,\n    });\n\n    // Add sample config.json\n    new ConfigJsonFile(this, { });\n\n\n    // Add sample code if requested\n    if (sampleCode) {\n      new ViteSampleCode(this, {\n        srcdir: this.srcdir,\n        publicDir: this.publicDir,\n      });\n    }\n\n    // Add Playwright e2e testing support\n    if (e2eTesting) {\n      new PlaywrightE2EComponent(this, {\n        publicDir: this.publicDir,\n      });\n    }\n\n    // Use relative path for devCommand\n    const relativeOutdir = this.parent\n      ? relative(this.parent.outdir, this.outdir)\n      : basename(this.outdir);\n    this.devCommand = `cd ${relativeOutdir} && ${runScriptCommand(this.package.packageManager, 'dev')}`;\n  }\n\n  /**\n   * Add a custom field to the Config type\n   * @param fieldName The name of the field\n   * @param fieldType The TypeScript type of the field (e.g., 'string', 'number', 'boolean', 'string[]')\n   * @returns this project instance for chaining\n   */\n  addConfigField(fieldName: string, fieldType: string): this {\n    this.configFields.set(fieldName, fieldType);\n    return this;\n  }\n\n  /**\n   * Get the config fields map (for internal use by ConfigFile)\n   * @internal\n   */\n  getConfigFields(): Map<string, string> {\n    return this.configFields;\n  }\n}\n\ninterface ViteComponentOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Configures Vite dependencies and scripts\n */\nclass ViteComponent extends Component {\n  constructor(project: TypeScriptAppProject, _options: ViteComponentOptions) {\n    super(project);\n\n    const tsProject = project as TypeScriptAppProject;\n\n    // Set package type to module for ESM support\n    tsProject.package.addField('type', 'module');\n\n    // Add React dependencies\n    tsProject.addDeps('react@^19.2.0', 'react-dom@^19.2.0');\n\n    // Add dev dependencies\n    tsProject.addDevDeps(\n      '@types/react@^19.2.2',\n      '@types/react-dom@^19.2.2',\n      '@vitejs/plugin-react@^5.1.0',\n      'vite@^5.4.0',\n      'typescript@~5.9.3',\n      '@eslint/js@^9.39.1',\n      'eslint@^9.39.1',\n      'eslint-plugin-react-hooks@^5.2.0',\n      'eslint-plugin-react-refresh@^0.4.24',\n      'globals@^16.5.0',\n      'typescript-eslint@^8.46.3',\n    );\n\n    // Create vite.config.ts as a managed file\n    new ViteConfigFile(project);\n\n    // Add scripts\n    tsProject.addTask('dev', {\n      description: 'Start development server',\n      exec: 'vite',\n    });\n\n    // Remove and recreate build task to customize it for Vite\n    tsProject.removeTask('build');\n    tsProject.addTask('build', {\n      description: 'Build for production',\n      exec: 'tsc -b && vite build',\n    });\n\n    tsProject.addTask('preview', {\n      description: 'Preview production build',\n      exec: 'vite preview',\n    });\n\n    tsProject.addTask('lint', {\n      description: 'Lint code',\n      exec: 'eslint .',\n    });\n  }\n}\n\n/**\n * Creates the ESLint configuration for Vite + React\n */\nclass ViteEslintConfig extends FileBase {\n  constructor(project: Project) {\n    super(project, 'eslint.config.js', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `import js from '@eslint/js'\nimport globals from 'globals'\nimport reactHooks from 'eslint-plugin-react-hooks'\nimport reactRefresh from 'eslint-plugin-react-refresh'\nimport tseslint from 'typescript-eslint'\n\nexport default [\n  { ignores: ['dist'] },\n  {\n    files: ['**/*.{ts,tsx}'],\n    languageOptions: {\n      ecmaVersion: 2020,\n      globals: globals.browser,\n    },\n    plugins: {\n      'react-hooks': reactHooks,\n      'react-refresh': reactRefresh,\n    },\n    rules: {\n      ...reactHooks.configs.recommended.rules,\n      'react-refresh/only-export-components': [\n        'warn',\n        { allowConstantExport: true },\n      ],\n    },\n  },\n  js.configs.recommended,\n  ...tseslint.configs.recommended,\n]\n`;\n  }\n}\n\n/**\n * Creates the vite.config.ts file\n */\nclass ViteConfigFile extends FileBase {\n  constructor(project: Project) {\n    super(project, 'vite.config.ts', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `import { defineConfig } from 'vite'\nimport react from '@vitejs/plugin-react'\n\n// https://vite.dev/config/\nexport default defineConfig({\n  plugins: [react()],\n})\n`;\n  }\n}\n\n/**\n * Creates the postcss.config.js file for Tailwind CSS v4\n */\nclass PostCSSConfigFile extends FileBase {\n  constructor(project: Project) {\n    super(project, 'postcss.config.js', {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `export default {\n  plugins: {\n    \"@tailwindcss/postcss\": {},\n    autoprefixer: {},\n  },\n}\n`;\n  }\n}\n\ninterface ViteEnvDtsOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the vite-env.d.ts file for type declarations\n */\nclass ViteEnvDts extends FileBase {\n  constructor(project: Project, options: ViteEnvDtsOptions) {\n    super(project, `${options.srcdir}/vite-env.d.ts`, {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    return `/// <reference types=\"vite/client\" />\n`;\n  }\n}\n\ninterface ConfigFileOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the config.ts file for runtime configuration\n */\nclass ConfigFile extends FileBase {\n  constructor(project: Project, options: ConfigFileOptions) {\n    super(project, `${options.srcdir}/config.ts`, {\n      marker: true,\n      readonly: true,\n    });\n  }\n\n  synthesizeContent(): string | undefined {\n    // Get custom config fields from parent project\n    const viteProject = this.project as ViteReactProject;\n    const customFields = viteProject.getConfigFields();\n\n    // Generate base config type\n    const baseConfigType = `type BaseConfig = {\n  clerkPublishableKey: string;\n  apiBaseUrl: string;\n  timeout: number;\n}`;\n\n    // Generate custom fields type if any exist\n    let configTypeDefinition: string;\n    if (customFields.size > 0) {\n      const fieldDefinitions = Array.from(customFields.entries())\n        .map(([name, type]) => `  ${name}: ${type};`)\n        .join('\\n');\n\n      const customFieldsType = `type CustomConfig = {\n${fieldDefinitions}\n}`;\n\n      configTypeDefinition = `${customFieldsType}\n\nexport type Config = BaseConfig & CustomConfig;`;\n    } else {\n      configTypeDefinition = 'export type Config = BaseConfig;';\n    }\n\n    return `import { useEffect, useState } from 'react';\n\n${baseConfigType}\n\n${configTypeDefinition}\n\nexport function useConfig() {\n  const [loadedConfig, setLoadedConfig] = useState<Config|undefined>();\n  const [isLoading, setIsLoading] = useState(false);\n\n  useEffect(() => {\n    if (!loadedConfig) {\n      fetch('/config.json', { cache: 'no-store' }).then(response=>{\n        response.json().then((config) => {\n          setIsLoading(false)\n          setLoadedConfig(config)\n        });\n      });\n\n    }\n  }, [loadedConfig]);\n\n  return { config: loadedConfig, isLoading };\n}\n`;\n  }\n}\n\ninterface ConfigJsonFileOptions {}\n\n/**\n * Creates the config.json sample file for runtime configuration\n */\nclass ConfigJsonFile extends SampleFile {\n  path: string;\n  constructor(project: ViteReactProject, _options: ConfigJsonFileOptions) {\n    super(project, `${project.publicDir}/config.json`, {\n      contents: JSON.stringify({\n        apiBaseUrl: 'http://localhost:3000/api',\n        clerkPublishableKey: 'tbd',\n      }, null, 2),\n    });\n    this.path = `${project.publicDir}/config.json`;\n  }\n}\n\ninterface IndexHtmlOptions {\n  readonly title: string;\n  readonly srcdir: string;\n}\n\n/**\n * Creates the index.html file\n */\nclass IndexHtml extends SampleFile {\n  constructor(project: Project, options: IndexHtmlOptions) {\n    super(project, 'index.html', {\n      contents: `<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <link rel=\"icon\" type=\"image/svg+xml\" href=\"/vite.svg\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>${options.title}</title>\n  </head>\n  <body>\n    <div id=\"root\"></div>\n    <script type=\"module\" src=\"/${options.srcdir}/main.tsx\"></script>\n  </body>\n</html>\n`,\n    });\n  }\n}\n\ninterface ViteTsConfigsOptions {\n  readonly srcdir: string;\n}\n\n/**\n * Creates the TypeScript configuration files for Vite\n */\nclass ViteTsConfigs extends Component {\n  constructor(project: Project, options: ViteTsConfigsOptions) {\n    super(project);\n\n    // Main tsconfig.json (project references)\n    new JsonFile(project, 'tsconfig.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        files: [],\n        references: [\n          { path: './tsconfig.app.json' },\n          { path: './tsconfig.node.json' },\n        ],\n      },\n    });\n\n    // tsconfig.app.json (for application code)\n    new JsonFile(project, 'tsconfig.app.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        compilerOptions: {\n          target: 'ES2020',\n          useDefineForClassFields: true,\n          lib: ['ES2020', 'DOM', 'DOM.Iterable'],\n          module: 'ESNext',\n          skipLibCheck: true,\n\n          // Bundler mode\n          moduleResolution: 'bundler',\n          allowImportingTsExtensions: true,\n          isolatedModules: true,\n          moduleDetection: 'force',\n          noEmit: true,\n          jsx: 'react-jsx',\n\n          // Linting\n          strict: true,\n          noUnusedLocals: true,\n          noUnusedParameters: true,\n          noFallthroughCasesInSwitch: true,\n          noUncheckedSideEffectImports: true,\n        },\n        include: [options.srcdir],\n      },\n    });\n\n    // tsconfig.node.json (for Vite config)\n    new JsonFile(project, 'tsconfig.node.json', {\n      marker: true,\n      readonly: true,\n      obj: {\n        compilerOptions: {\n          target: 'ES2022',\n          lib: ['ES2023'],\n          module: 'ESNext',\n          skipLibCheck: true,\n\n          // Bundler mode\n          moduleResolution: 'bundler',\n          allowImportingTsExtensions: true,\n          isolatedModules: true,\n          moduleDetection: 'force',\n          noEmit: true,\n\n          // Linting\n          strict: true,\n          noUnusedLocals: true,\n          noUnusedParameters: true,\n          noFallthroughCasesInSwitch: true,\n        },\n        include: ['vite.config.ts'],\n      },\n    });\n  }\n}\n\ninterface ViteSampleCodeOptions {\n  readonly srcdir: string;\n  readonly publicDir: string;\n}\n\n/**\n * Generates sample code for a Vite + React project\n */\nclass ViteSampleCode extends Component {\n  constructor(project: Project, options: ViteSampleCodeOptions) {\n    super(project);\n\n    // Create App.tsx\n    new SampleFile(project, `${options.srcdir}/App.tsx`, {\n      contents: `import './App.css'\nimport { SignedIn, UserButton } from '@clerk/clerk-react';\nimport { useBaseQuery } from \"./services/BaseService.ts\";\n\n\nfunction App() {\n  const {data, isLoading} = useBaseQuery('/', {retryOnMount: true});\n\n\n  return (\n    <>\n        <header>\n\n          <SignedIn>\n            <UserButton/>\n          </SignedIn>\n        </header>\n        <div className=\"card\">\n          { isLoading ? 'Loading...' : JSON.stringify(data, null ,)}\n        </div>\n    </>\n  )\n}\n\nexport default App\n`,\n    });\n\n    // Create BaseService.ts\n    new TextFile(project, `${options.srcdir}/services/BaseService.ts`, {\n      marker: true,\n      readonly: true,\n      lines: [\n        'import { useQuery, UseQueryOptions } from \\'@tanstack/react-query\\';',\n        'import { useAuth } from \\'@clerk/clerk-react\\';',\n        'import { useConfig } from \\'../config\\';',\n        '',\n        'export function useBaseQuery<TData = unknown>(',\n        '  path: string,',\n        '  options?: Omit<UseQueryOptions<TData>, \\'queryKey\\' | \\'queryFn\\'>',\n        ') {',\n        '  const { config } = useConfig();',\n        '  const { getToken } = useAuth();',\n        '',\n        '  return useQuery<TData>({',\n        '    queryKey: [\\'base\\'],',\n        '    queryFn: async () => {',\n        '      if (!config?.apiBaseUrl) {',\n        '        throw new Error(\\'API base URL not configured\\');',\n        '      }',\n        '',\n        '      const token = await getToken();',\n        '',\n        '      // Normalize URL by removing trailing slash from baseUrl and ensuring path starts with slash',\n        '      const baseUrl = config.apiBaseUrl.replace(/\\\\/+$/, \\'\\');',\n        '      const normalizedPath = path.startsWith(\\'/\\') ? path : `/${path}`;',\n        '      ',\n        '      const response = await fetch(`${baseUrl}${normalizedPath}`, {',\n        '        headers: {',\n        '          \\'Authorization\\': `Bearer ${token}`,',\n        '        },',\n        '      });',\n        '',\n        '      if (!response.ok) {',\n        '        throw new Error(`HTTP error! status: ${response.status}`);',\n        '      }',\n        '',\n        '      return response.json();',\n        '    },',\n        '    enabled: !!config?.apiBaseUrl,',\n        '    ...options,',\n        '  });',\n        '}',\n      ],\n    });\n\n    // Create RootService.ts\n    new SampleFile(project, `${options.srcdir}/services/RootService.ts`, {\n      contents: `import { UseQueryOptions } from '@tanstack/react-query';\nimport { useBaseQuery } from './BaseService';\n\nexport function useRootQuery<TData = unknown>(\n  options?: Omit<UseQueryOptions<TData>, 'queryKey' | 'queryFn'>\n) {\n  return useBaseQuery<TData>('/', options);\n}\n`,\n    });\n\n    // Create App.css\n    new SampleFile(project, `${options.srcdir}/App.css`, {\n      contents: `#root {\n  width: 100%;\n  height: 100%;\n}\n\n.logo {\n  height: 6em;\n  padding: 1.5em;\n  will-change: filter;\n  transition: filter 300ms;\n}\n.logo:hover {\n  filter: drop-shadow(0 0 2em #646cffaa);\n}\n.logo.react:hover {\n  filter: drop-shadow(0 0 2em #61dafbaa);\n}\n\n@keyframes logo-spin {\n  from {\n    transform: rotate(0deg);\n  }\n  to {\n    transform: rotate(360deg);\n  }\n}\n\n@media (prefers-reduced-motion: no-preference) {\n  a:nth-of-type(2) .logo {\n    animation: logo-spin infinite 20s linear;\n  }\n}\n\n.card {\n  padding: 2em;\n}\n\n.read-the-docs {\n  color: #888;\n}\n`,\n    });\n\n    // Create main.tsx\n    new SampleFile(project, `${options.srcdir}/main.tsx`, {\n      contents: `import { StrictMode } from 'react'\nimport { createRoot } from 'react-dom/client'\nimport './index.css'\nimport App from './App.tsx'\nimport { ClerkProvider, SignedIn, SignedOut, SignInButton } from '@clerk/clerk-react'\nimport { useConfig } from './config'\nimport { QueryClient, QueryClientProvider } from \"@tanstack/react-query\"\n\nfunction AppWrapper() {\n  const { config, isLoading } = useConfig();\n  const queryClient = new QueryClient()\n  if (isLoading || !config) {\n    return (\n      <div className=\"loading-screen\">\n        Loading...\n      </div>\n    );\n  }\n\n  return (\n    <ClerkProvider publishableKey={config.clerkPublishableKey}>\n      <QueryClientProvider client={queryClient}>\n        <div className=\"w-full h-full\">\n          <SignedOut>\n            <div className=\"flex items-center justify-center min-h-screen\">\n              <SignInButton/>\n            </div>\n          </SignedOut>\n          <SignedIn>\n            <App/>\n          </SignedIn>\n        </div>\n      </QueryClientProvider>\n    </ClerkProvider>\n  );\n}\n\ncreateRoot(document.getElementById('root')!).render(\n  <StrictMode>\n    <AppWrapper/>\n  </StrictMode>\n)\n`,\n    });\n\n    // Create index.css\n    new SampleFile(project, `${options.srcdir}/index.css`, {\n      contents: `@import \"tailwindcss\";\n\n@theme {\n  --color-scheme: light dark;\n}\n\n:root {\n  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;\n  line-height: 1.5;\n  font-weight: 400;\n\n  color-scheme: light dark;\n\n  font-synthesis: none;\n  text-rendering: optimizeLegibility;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n\na {\n  font-weight: 500;\n  color: #646cff;\n  text-decoration: inherit;\n}\na:hover {\n  color: #535bf2;\n}\n\nbody {\n  margin: 0;\n  min-width: 320px;\n  min-height: 100vh;\n}\n\nh1 {\n  font-size: 3.2em;\n  line-height: 1.1;\n}\n\nbutton {\n  font-family: inherit;\n  cursor: pointer;\n}\n\n.loading-screen {\n  display: flex;\n  justify-content: center;\n  align-items: center;\n  height: 100vh;\n  font-size: 1.5rem;\n}\n\nhtml, body, #root {\n  width: 100%;\n  height: 100%;\n}\n`,\n    });\n\n  }\n}\n\ninterface PlaywrightE2EComponentOptions {\n  readonly publicDir: string;\n}\n\n/**\n * Adds Playwright e2e testing support: devDeps, a `test:e2e` task, e2e-related\n * .gitignore entries, and a scaffolded (one-time, not regenerated on synth)\n * `playwright.config.ts` + `e2e/` starter suite. Generalizes the hand-authored\n * suite added in macedon-technologies/exman#112 so every ViteReactProject\n * consumer gets it for free (macedon-technologies/platform-common#98).\n */\nclass PlaywrightE2EComponent extends Component {\n  constructor(project: ViteReactProject, options: PlaywrightE2EComponentOptions) {\n    super(project);\n\n    project.addDevDeps(\n      '@playwright/test@^1.63.0',\n      '@clerk/testing@^2.2.34',\n      '@clerk/backend@^3.17.2',\n      'dotenv@^17.4.2',\n    );\n\n    project.addTask('test:e2e', {\n      description: 'Run the Playwright e2e suite (needs CLERK_SECRET_KEY and E2E_CLERK_USER_ID -- see e2e/README.md)',\n      exec: 'playwright test',\n    });\n\n    project.addGitIgnore('playwright-report/');\n    project.addGitIgnore('test-results/');\n    project.addGitIgnore('blob-report/');\n    // `*.local` (added elsewhere) already covers `.env.local`, but not a plain `.env` --\n    // exactly where CLERK_SECRET_KEY (a real secret) is documented to go (e2e/README.md).\n    project.addGitIgnore('.env');\n\n    new PlaywrightConfigFile(project);\n    new E2EGlobalSetupFile(project, options);\n    new E2EClerkSignInFile(project);\n    new E2ELiveHelperFile(project);\n    new E2ESmokeSpecFile(project);\n    new E2EReadmeFile(project);\n  }\n}\n\n/**\n * Creates the playwright.config.ts file. A `SampleFile`, not a managed `FileBase` --\n * consumers need to customize this (e.g. exman's own config needed a live/stub\n * branch), the same reason ViteReactProject's App.tsx/main.tsx are SampleFiles too.\n */\nclass PlaywrightConfigFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'playwright.config.ts', {\n      contents: `import { config as loadDotenv } from 'dotenv'\nimport { defineConfig, devices } from '@playwright/test'\nimport { isLiveRun } from './e2e/support/live'\n\n// Loaded here, first, rather than left to @clerk/testing's own internal dotenv call\n// inside global-setup.ts: that call runs inside globalSetup, which executes AFTER\n// Playwright has already collected every spec file and run their module-level code --\n// so anything reading process.env before then would only ever see a .env file's values\n// as unset. Loading it here, at the top of the config file Playwright reads before\n// anything else, means it's populated for collection, globalSetup, and every test.\nloadDotenv()\n\n// Set E2E_BASE_URL to run against a real deployment (e.g. a PR's pr-deploy WebsiteUrl)\n// instead of a local dev server -- see e2e/support/live.ts and e2e/README.md.\n// \\`|| undefined\\`, not \\`??\\`: an empty string (e.g. an unset GitHub Actions output) is\n// not null/undefined, so ?? would leave baseURL as '' while isLiveRun()'s plain !!\n// check still read the run as non-live -- an invalid, silently-mismatched config.\nconst liveBaseUrl = process.env.E2E_BASE_URL || undefined\n\nexport default defineConfig({\n  testDir: './e2e',\n  fullyParallel: false,\n  forbidOnly: !!process.env.CI,\n  retries: process.env.CI ? 1 : 0,\n  reporter: process.env.CI ? [['html', { open: 'never' }]] : 'list',\n  globalSetup: './e2e/support/global-setup.ts',\n  use: {\n    baseURL: liveBaseUrl ?? 'http://localhost:5173',\n    trace: 'on-first-retry',\n  },\n  projects: [\n    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },\n  ],\n  // No local server to manage when pointed at a live deployment.\n  webServer: isLiveRun() ? undefined : {\n    command: '${runScriptCommand(project.package.packageManager, 'dev')}',\n    url: 'http://localhost:5173',\n    reuseExistingServer: !process.env.CI,\n    timeout: 60_000,\n  },\n})\n`,\n    });\n  }\n}\n\ninterface E2EGlobalSetupFileOptions {\n  readonly publicDir: string;\n}\n\n/**\n * Creates e2e/support/global-setup.ts, which primes @clerk/testing for the sign-in\n * flow in clerk-sign-in.ts. Reads the Clerk publishable key from the scaffolded\n * public/config.json (ConfigJsonFile) rather than hardcoding one -- ViteReactProject's\n * own app fetches that key at runtime the same way (see config.ts), so there's no\n * build-time constant this construct could embed instead.\n */\nclass E2EGlobalSetupFile extends SampleFile {\n  constructor(project: ViteReactProject, options: E2EGlobalSetupFileOptions) {\n    super(project, 'e2e/support/global-setup.ts', {\n      contents: `import { readFileSync } from 'fs'\nimport { clerkSetup } from '@clerk/testing/playwright'\n\n// A no-op (not a throw) when CLERK_SECRET_KEY is missing: every spec that needs a\n// signed-in user already skips itself in that case (see ../smoke.spec.ts), so running\n// the suite without secrets configured yet reports \"skipped\", not a crashed global\n// setup. See e2e/README.md for how to get a secret key.\nexport default async function globalSetup() {\n  if (!process.env.CLERK_SECRET_KEY) {\n    return\n  }\n\n  // import.meta.url, not __dirname: the web package sets \"type\": \"module\" (ViteComponent),\n  // so this file runs as ESM, where __dirname isn't defined. fs.readFileSync accepts a URL\n  // directly, so no need to convert it to a path first.\n  const configPath = new URL('../../${options.publicDir}/config.json', import.meta.url)\n  const { clerkPublishableKey } = JSON.parse(readFileSync(configPath, 'utf-8'))\n\n  await clerkSetup({ publishableKey: clerkPublishableKey })\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/support/clerk-sign-in.ts. Signs in as a specific Clerk user by id via a\n * backend-issued sign-in token (ticket strategy), bypassing the app's actual sign-in\n * UI -- which typically only exposes an OAuth provider button that can't be driven\n * reliably from a test. @clerk/testing/playwright's own `clerk.signIn({ emailAddress })`\n * does the same ticket exchange internally after an extra email->user lookup; going\n * from a user id directly (E2E_CLERK_USER_ID) skips that lookup and its failure mode\n * (an existing user without a verified email attached).\n */\nclass E2EClerkSignInFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/support/clerk-sign-in.ts', {\n      contents: `import { createClerkClient } from '@clerk/backend'\nimport { clerk } from '@clerk/testing/playwright'\nimport type { Page } from '@playwright/test'\n\n/**\n * Signs in as a specific Clerk user by id. Requires CLERK_SECRET_KEY (also used by\n * global-setup.ts) and a prior page.goto() to a page that loads Clerk.\n */\nexport async function signInAsUser(page: Page, userId: string): Promise<void> {\n  const clerkClient = createClerkClient({ secretKey: process.env.CLERK_SECRET_KEY })\n  const { token } = await clerkClient.signInTokens.createSignInToken({\n    userId,\n    expiresInSeconds: 300,\n  })\n  await clerk.signIn({ page, signInParams: { strategy: 'ticket', ticket: token } })\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/support/live.ts.\n */\nclass E2ELiveHelperFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/support/live.ts', {\n      contents: `/**\n * True when this run targets a real deployment (E2E_BASE_URL set -- see\n * playwright.config.ts) rather than a local dev server. Specs read this to decide\n * whether to stub the backend: a live run must hit the real API to prove anything,\n * and stubbing it would just be testing the stub.\n */\nexport function isLiveRun(): boolean {\n  return !!process.env.E2E_BASE_URL\n}\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/smoke.spec.ts -- a generic starter test that only relies on markup\n * ViteReactProject's own scaffolded main.tsx/App.tsx always render (SignedIn/\n * UserButton), so it works before a consumer has written any real pages. Consumers\n * are expected to extend/replace this with real flows, the same way they already\n * customize App.tsx.\n */\nclass E2ESmokeSpecFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    super(project, 'e2e/smoke.spec.ts', {\n      contents: `import { test, expect } from '@playwright/test'\nimport { signInAsUser } from './support/clerk-sign-in'\n\ntest('signs in and shows the authenticated UserButton', async ({ page }) => {\n  // Read from inside the test body, not module scope: Playwright collects (requires)\n  // this file before running globalSetup, so a module-level check would always see a\n  // .env-sourced value as unset. Exporting the var in the shell works either way.\n  const testUserId = process.env.E2E_CLERK_USER_ID\n  test.skip(\n    !testUserId || !process.env.CLERK_SECRET_KEY,\n    'E2E_CLERK_USER_ID and CLERK_SECRET_KEY must both be set -- see e2e/README.md',\n  )\n\n  // signInAsUser requires a prior page.goto() to a page that loads Clerk.\n  await page.goto('/')\n  await signInAsUser(page, testUserId!)\n  await page.goto('/')\n\n  // '.cl-userButtonTrigger' is one of Clerk's own documented, stable \\`cl-\\`-prefixed\n  // class hooks (part of its theming/appearance API), not an incidental DOM detail --\n  // safer to depend on across Clerk versions than app-specific markup this construct\n  // doesn't control.\n  await expect(page.locator('.cl-userButtonTrigger')).toBeVisible()\n})\n`,\n    });\n  }\n}\n\n/**\n * Creates e2e/README.md documenting the one-time setup and env var convention every\n * consumer needs, so it doesn't have to be re-derived by hand per repo.\n */\nclass E2EReadmeFile extends SampleFile {\n  constructor(project: ViteReactProject) {\n    const testE2eCommand = runScriptCommand(project.package.packageManager, 'test:e2e');\n    super(project, 'e2e/README.md', {\n      contents: `# Playwright e2e suite\n\nRuns against a real dev server (or a live deployment, via \\`E2E_BASE_URL\\`) and real\nClerk authentication.\n\n## One-time setup\n\n1. Install Playwright's browser binary (not covered by a plain dependency install):\n\n   \\`\\`\\`bash\n   npx playwright install chromium\n   \\`\\`\\`\n\n2. Get two values from your Clerk dashboard's dev instance:\n\n   - \\`CLERK_SECRET_KEY\\` -- the **secret** key (API Keys). Never commit this; export it\n     in your shell or put it in a local, gitignored \\`.env\\`.\n   - \\`E2E_CLERK_USER_ID\\` -- the id (\\`user_...\\`) of an existing test user (Users -> click\n     a user, the id is shown at the top). The user needs a verified email address, not\n     just an OAuth connection -- a sign-in token has to bind to a verified\n     identification. Creating a dedicated test user with an email set explicitly is the\n     safer default.\n\n   A run with either variable unset **skips** rather than failing, so \\`${testE2eCommand}\\`\n   is always safe to run without them.\n\n3. This construct doesn't manage \\`vitest.config.ts\\` (it's a hand-authored,\n   per-consumer file). Add an \\`exclude\\` entry so vitest's default test glob doesn't\n   also try to pick up these Playwright spec files:\n\n   \\`\\`\\`ts\n   import { defineConfig, configDefaults } from 'vitest/config'\n\n   export default defineConfig({\n     test: {\n       exclude: [...configDefaults.exclude, 'e2e/**'],\n       // ...your existing config\n     },\n   })\n   \\`\\`\\`\n\n## Running\n\n\\`\\`\\`bash\nCLERK_SECRET_KEY=... E2E_CLERK_USER_ID=... ${testE2eCommand}\n\\`\\`\\`\n\n## Running against a live environment\n\nSet \\`E2E_BASE_URL\\` to point the suite at a real deployment (a personal dev stack, or a\nPR's pr-deploy \\`WebsiteUrl\\`, posted as a PR comment) instead of a local dev server:\n\n\\`\\`\\`bash\nE2E_BASE_URL=https://<your-stack>.example.com \\\\\nCLERK_SECRET_KEY=... E2E_CLERK_USER_ID=... \\\\\n${testE2eCommand}\n\\`\\`\\`\n\n## CI\n\nThe generated \\`pr-deploy.yml\\` workflow (see \\`PrDeployWorkflow\\`) already runs this\nsuite against each PR's deployed \\`WebsiteUrl\\` and uploads the HTML report as a build\nartifact on failure. It self-skips exactly like a local run until both secrets exist\nin the repo:\n\n\\`\\`\\`bash\ngh secret set CLERK_SECRET_KEY\ngh secret set E2E_CLERK_USER_ID\n\\`\\`\\`\n`,\n    });\n  }\n}\n"]}

package/lib/WorkflowAutoDiscover.js

@@ -39,7 +39,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const projen_1 = require("projen");
 class WorkflowAutoDiscover extends projen_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.WorkflowAutoDiscover", version: "1.23.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.WorkflowAutoDiscover", version: "1.24.1" };
     constructor(project) {
         super(project);
     }

package/lib/utils.d.ts

@@ -19,4 +19,4 @@ export declare function installCommand(packageManager: NodePackageManager): stri
  */
 export declare function sanitizeBranchNameScript(): string[];
 export declare function serializeTs(value: any, depth?: number): string;
-export declare function readmeContents(projectName: string): string;
+export declare function readmeContents(projectName: string, e2eTesting?: boolean, packageManager?: NodePackageManager): string;