litestar-vite-plugin 0.15.0-beta.5 → 0.15.0-beta.6

package/dist/js/shared/typegen-plugin.js

@@ -0,0 +1,178 @@
+import { exec } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { promisify } from "node:util";
+import colors from "picocolors";
+import { resolveInstallHint, resolvePackageExecutor } from "../install-hint.js";
+import { debounce } from "./debounce.js";
+import { emitPagePropsTypes } from "./emit-page-props-types.js";
+import { formatPath } from "./format-path.js";
+const execAsync = promisify(exec);
+const nodeRequire = createRequire(import.meta.url);
+async function getFileMtime(filePath) {
+  const stat = await fs.promises.stat(filePath);
+  return stat.mtimeMs.toString();
+}
+function createLitestarTypeGenPlugin(typesConfig, options) {
+  const { pluginName, frameworkName, sdkClientPlugin, executor, hasPythonConfig } = options;
+  let lastTypesHash = null;
+  let lastPagePropsHash = null;
+  let server = null;
+  let isGenerating = false;
+  let resolvedConfig = null;
+  let _chosenConfigPath = null;
+  async function runTypeGeneration() {
+    if (isGenerating) {
+      return false;
+    }
+    isGenerating = true;
+    const startTime = Date.now();
+    try {
+      const projectRoot = resolvedConfig?.root ?? process.cwd();
+      const openapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
+      const pagePropsPath = path.resolve(projectRoot, typesConfig.pagePropsPath);
+      let generated = false;
+      const candidates = [path.resolve(projectRoot, "openapi-ts.config.ts"), path.resolve(projectRoot, "hey-api.config.ts"), path.resolve(projectRoot, ".hey-api.config.ts")];
+      const configPath = candidates.find((p) => fs.existsSync(p)) || null;
+      _chosenConfigPath = configPath;
+      const shouldRunOpenApiTs = configPath || typesConfig.generateSdk;
+      if (fs.existsSync(openapiPath) && shouldRunOpenApiTs) {
+        resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Generating TypeScript types...`);
+        if (resolvedConfig && configPath) {
+          const relConfigPath = formatPath(configPath, resolvedConfig.root);
+          resolvedConfig.logger.info(`${colors.cyan("\u2022")} openapi-ts config: ${colors.yellow(relConfigPath)}`);
+        }
+        const sdkOutput = path.join(typesConfig.output, "api");
+        let args;
+        if (configPath) {
+          args = ["@hey-api/openapi-ts", "--file", configPath];
+        } else {
+          args = ["@hey-api/openapi-ts", "-i", typesConfig.openapiPath, "-o", sdkOutput];
+          const plugins = ["@hey-api/typescript", "@hey-api/schemas"];
+          if (typesConfig.generateSdk) {
+            plugins.push("@hey-api/sdk", sdkClientPlugin);
+          }
+          if (typesConfig.generateZod) {
+            plugins.push("zod");
+          }
+          if (plugins.length) {
+            args.push("--plugins", ...plugins);
+          }
+        }
+        if (typesConfig.generateZod) {
+          try {
+            nodeRequire.resolve("zod", { paths: [projectRoot] });
+          } catch {
+            resolvedConfig?.logger.warn(`${colors.yellow("!")} zod not installed - run: ${resolveInstallHint()} zod`);
+          }
+        }
+        await execAsync(resolvePackageExecutor(args.join(" "), executor), { cwd: projectRoot });
+        generated = true;
+      }
+      if (typesConfig.generatePageProps && fs.existsSync(pagePropsPath)) {
+        await emitPagePropsTypes(pagePropsPath, typesConfig.output);
+        generated = true;
+      }
+      if (generated && resolvedConfig) {
+        const duration = Date.now() - startTime;
+        resolvedConfig.logger.info(`${colors.green("\u2713")} TypeScript artifacts updated ${colors.dim(`(${duration}ms)`)}`);
+      }
+      if (generated && server) {
+        server.ws.send({
+          type: "custom",
+          event: "litestar:types-updated",
+          data: {
+            output: typesConfig.output,
+            timestamp: Date.now()
+          }
+        });
+      }
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (resolvedConfig) {
+        if (message.includes("not found") || message.includes("ENOENT")) {
+          const zodHint = typesConfig.generateZod ? " zod" : "";
+          resolvedConfig.logger.warn(
+            `${colors.cyan("litestar-vite")} ${colors.yellow("@hey-api/openapi-ts not installed")} - run: ${resolveInstallHint()} -D @hey-api/openapi-ts${zodHint}`
+          );
+        } else {
+          resolvedConfig.logger.error(`${colors.cyan("litestar-vite")} ${colors.red("type generation failed:")} ${message}`);
+        }
+      }
+      return false;
+    } finally {
+      isGenerating = false;
+    }
+  }
+  const debouncedRunTypeGeneration = debounce(runTypeGeneration, typesConfig.debounce);
+  return {
+    name: pluginName,
+    enforce: "pre",
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    configureServer(devServer) {
+      server = devServer;
+      if (typesConfig.enabled) {
+        const openapiRel = path.basename(typesConfig.openapiPath);
+        resolvedConfig?.logger.info(`${colors.cyan("\u2022")} Watching: ${colors.yellow(openapiRel)}`);
+      }
+    },
+    async buildStart() {
+      if (typesConfig.enabled && hasPythonConfig === false) {
+        const projectRoot = resolvedConfig?.root ?? process.cwd();
+        const openapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
+        if (!fs.existsSync(openapiPath)) {
+          this.warn(
+            `Type generation is enabled but .litestar.json was not found.
+The Litestar backend generates this file on startup.
+
+Solutions:
+  1. Start the backend first: ${colors.cyan("litestar run")}
+  2. Use integrated dev: ${colors.cyan("litestar assets serve")}
+  3. Disable types: ${colors.cyan("litestar({ input: [...], types: false })")}
+`
+          );
+        }
+      }
+      if (typesConfig.enabled) {
+        const projectRoot = resolvedConfig?.root ?? process.cwd();
+        const openapiPath = path.resolve(projectRoot, typesConfig.openapiPath);
+        const pagePropsPath = path.resolve(projectRoot, typesConfig.pagePropsPath);
+        const hasOpenapi = fs.existsSync(openapiPath);
+        const hasPageProps = typesConfig.generatePageProps && fs.existsSync(pagePropsPath);
+        if (hasOpenapi || hasPageProps) {
+          await runTypeGeneration();
+        }
+      }
+    },
+    async handleHotUpdate({ file }) {
+      if (!typesConfig.enabled) {
+        return;
+      }
+      const root = resolvedConfig?.root ?? process.cwd();
+      const relativePath = path.relative(root, file);
+      const openapiPath = typesConfig.openapiPath.replace(/^\.\//, "");
+      const pagePropsPath = typesConfig.pagePropsPath.replace(/^\.\//, "");
+      const isOpenapi = relativePath === openapiPath || file.endsWith(openapiPath);
+      const isPageProps = typesConfig.generatePageProps && (relativePath === pagePropsPath || file.endsWith(pagePropsPath));
+      if (isOpenapi || isPageProps) {
+        resolvedConfig?.logger.info(`${colors.cyan(frameworkName)} ${colors.dim("schema changed:")} ${colors.yellow(relativePath)}`);
+        const newHash = await getFileMtime(file);
+        if (isOpenapi) {
+          if (lastTypesHash === newHash) return;
+          lastTypesHash = newHash;
+        } else if (isPageProps) {
+          if (lastPagePropsHash === newHash) return;
+          lastPagePropsHash = newHash;
+        }
+        debouncedRunTypeGeneration();
+      }
+    }
+  };
+}
+export {
+  createLitestarTypeGenPlugin
+};

package/dist/js/sveltekit.d.ts

@@ -20,7 +20,7 @@
  *       apiProxy: 'http://localhost:8000',
  *       types: {
  *         enabled: true,
- *         output: 'src/lib/api',
+ *         output: 'src/lib/generated',
  *       },
  *     }),
  *     sveltekit(),  // SvelteKit plugin comes after
@@ -43,9 +43,9 @@ export interface SvelteKitTypesConfig {
     enabled?: boolean;
     /**
      * Path to output generated TypeScript types.
-     * Recommended to use SvelteKit's $lib alias path.
+     * Relative to the SvelteKit project root.
      *
-     * @default 'src/lib/api'
+     * @default 'src/lib/generated'
      */
     output?: string;
     /**
@@ -60,6 +60,12 @@ export interface SvelteKitTypesConfig {
      * @default 'routes.json'
      */
     routesPath?: string;
+    /**
+     * Path where Inertia page props metadata is exported by Litestar.
+     *
+     * @default 'inertia-pages.json'
+     */
+    pagePropsPath?: string;
     /**
      * Generate Zod schemas in addition to TypeScript types.
      *
@@ -72,6 +78,24 @@ export interface SvelteKitTypesConfig {
      * @default true
      */
     generateSdk?: boolean;
+    /**
+     * Generate typed routes.ts from routes.json metadata.
+     *
+     * @default true
+     */
+    generateRoutes?: boolean;
+    /**
+     * Generate Inertia page props types from inertia-pages.json metadata.
+     *
+     * @default true
+     */
+    generatePageProps?: boolean;
+    /**
+     * Register route() globally on window object.
+     *
+     * @default false
+     */
+    globalRoute?: boolean;
     /**
      * Debounce time in milliseconds for type regeneration.
      *
@@ -144,7 +168,7 @@ export interface LitestarSvelteKitConfig {
  *       apiPrefix: '/api',
  *       types: {
  *         enabled: true,
- *         output: 'src/lib/api',
+ *         output: 'src/lib/generated',
  *         generateZod: true,
  *       },
  *     }),
@@ -157,8 +181,8 @@ export interface LitestarSvelteKitConfig {
  * ```typescript
  * // src/routes/users/[id]/+page.ts
  * import type { PageLoad } from './$types';
- * import type { User } from '$lib/api/types.gen';
- * import { route } from '$lib/api/routes';
+ * import type { User } from '$lib/generated/api/types.gen';
+ * import { route } from '$lib/generated/routes';
  *
  * export const load: PageLoad = async ({ params, fetch }) => {
  *   const response = await fetch(route('users.show', { id: params.id }));

package/dist/js/sveltekit.js

@@ -1,13 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
 import colors from "picocolors";
-import { createTypeGenerationPlugin } from "./shared/create-type-gen-plugin.js";
+import { readBridgeConfig } from "./shared/bridge-schema.js";
+import { createLitestarTypeGenPlugin } from "./shared/typegen-plugin.js";
 function resolveConfig(config = {}) {
-  const runtimeConfigPath = process.env.LITESTAR_VITE_CONFIG_PATH;
   let hotFile;
   let proxyMode = "vite";
   let port;
   let pythonTypesConfig;
+  let hasPythonConfig = false;
   const envPort = process.env.VITE_PORT;
   if (envPort) {
     port = Number.parseInt(envPort, 10);
@@ -16,53 +17,59 @@ function resolveConfig(config = {}) {
     }
   }
   let pythonExecutor;
-  if (runtimeConfigPath && fs.existsSync(runtimeConfigPath)) {
-    try {
-      const json = JSON.parse(fs.readFileSync(runtimeConfigPath, "utf-8"));
-      const bundleDir = json.bundleDir ?? "public";
-      const hot = json.hotFile ?? "hot";
-      hotFile = path.resolve(process.cwd(), bundleDir, hot);
-      proxyMode = json.proxyMode ?? "vite";
-      if (json.port !== void 0) {
-        port = json.port;
-      }
-      pythonExecutor = json.executor;
-      if (json.types) {
-        pythonTypesConfig = json.types;
-      }
-    } catch {
-      hotFile = void 0;
+  const runtime = readBridgeConfig();
+  if (runtime) {
+    hasPythonConfig = true;
+    const hot = runtime.hotFile;
+    hotFile = path.isAbsolute(hot) ? hot : path.resolve(process.cwd(), runtime.bundleDir, hot);
+    proxyMode = runtime.proxyMode;
+    port = runtime.port;
+    pythonExecutor = runtime.executor;
+    if (runtime.types) {
+      pythonTypesConfig = runtime.types;
     }
   }
   let typesConfig = false;
   if (config.types === true) {
     typesConfig = {
       enabled: true,
-      output: pythonTypesConfig?.output ?? "src/lib/api",
+      output: pythonTypesConfig?.output ?? "src/lib/generated",
       openapiPath: pythonTypesConfig?.openapiPath ?? "openapi.json",
       routesPath: pythonTypesConfig?.routesPath ?? "routes.json",
+      pagePropsPath: pythonTypesConfig?.pagePropsPath ?? "inertia-pages.json",
       generateZod: pythonTypesConfig?.generateZod ?? false,
       generateSdk: pythonTypesConfig?.generateSdk ?? true,
+      generateRoutes: pythonTypesConfig?.generateRoutes ?? true,
+      generatePageProps: pythonTypesConfig?.generatePageProps ?? true,
+      globalRoute: pythonTypesConfig?.globalRoute ?? false,
       debounce: 300
     };
   } else if (typeof config.types === "object" && config.types !== null) {
     typesConfig = {
       enabled: config.types.enabled ?? true,
-      output: config.types.output ?? pythonTypesConfig?.output ?? "src/lib/api",
+      output: config.types.output ?? pythonTypesConfig?.output ?? "src/lib/generated",
       openapiPath: config.types.openapiPath ?? pythonTypesConfig?.openapiPath ?? "openapi.json",
       routesPath: config.types.routesPath ?? pythonTypesConfig?.routesPath ?? "routes.json",
+      pagePropsPath: config.types.pagePropsPath ?? pythonTypesConfig?.pagePropsPath ?? "inertia-pages.json",
       generateZod: config.types.generateZod ?? pythonTypesConfig?.generateZod ?? false,
       generateSdk: config.types.generateSdk ?? pythonTypesConfig?.generateSdk ?? true,
+      generateRoutes: config.types.generateRoutes ?? pythonTypesConfig?.generateRoutes ?? true,
+      generatePageProps: config.types.generatePageProps ?? pythonTypesConfig?.generatePageProps ?? true,
+      globalRoute: config.types.globalRoute ?? pythonTypesConfig?.globalRoute ?? false,
       debounce: config.types.debounce ?? 300
     };
   } else if (config.types !== false && pythonTypesConfig?.enabled) {
     typesConfig = {
       enabled: true,
-      output: pythonTypesConfig.output ?? "src/lib/api",
+      output: pythonTypesConfig.output ?? "src/lib/generated",
       openapiPath: pythonTypesConfig.openapiPath ?? "openapi.json",
       routesPath: pythonTypesConfig.routesPath ?? "routes.json",
+      pagePropsPath: pythonTypesConfig.pagePropsPath ?? "inertia-pages.json",
       generateZod: pythonTypesConfig.generateZod ?? false,
       generateSdk: pythonTypesConfig.generateSdk ?? true,
+      generateRoutes: pythonTypesConfig.generateRoutes ?? true,
+      generatePageProps: pythonTypesConfig.generatePageProps ?? true,
+      globalRoute: pythonTypesConfig.globalRoute ?? false,
       debounce: 300
     };
   }
@@ -74,7 +81,8 @@ function resolveConfig(config = {}) {
     hotFile,
     proxyMode,
     port,
-    executor: config.executor ?? pythonExecutor
+    executor: config.executor ?? pythonExecutor,
+    hasPythonConfig
   };
 }
 function litestarSvelteKit(userConfig = {}) {
@@ -152,11 +160,12 @@ function litestarSvelteKit(userConfig = {}) {
   });
   if (config.types !== false && config.types.enabled) {
     plugins.push(
-      createTypeGenerationPlugin(config.types, {
-        frameworkName: "litestar-sveltekit",
+      createLitestarTypeGenPlugin(config.types, {
         pluginName: "litestar-sveltekit-types",
-        clientPlugin: "@hey-api/client-fetch",
-        executor: config.executor
+        frameworkName: "litestar-sveltekit",
+        sdkClientPlugin: "@hey-api/client-fetch",
+        executor: config.executor,
+        hasPythonConfig: config.hasPythonConfig
       })
     );
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litestar-vite-plugin",
-  "version": "0.15.0-beta.5",
+  "version": "0.15.0-beta.6",
   "type": "module",
   "description": "Litestar plugin for Vite.",
   "keywords": [
@@ -24,8 +24,6 @@
       "types": "./dist/js/helpers/index.d.ts",
       "import": "./dist/js/helpers/index.js"
     },
-    "./install-hint": "./dist/js/install-hint.js",
-    "./litestar-meta": "./dist/js/litestar-meta.js",
     "./inertia-helpers": {
       "types": "./dist/js/inertia-helpers/index.d.ts",
       "import": "./dist/js/inertia-helpers/index.js"
@@ -55,11 +53,11 @@
     "build": "npm run build-plugin && npm run build-helpers && npm run build-inertia-helpers && npm run build-integrations",
     "build-plugin": "rm -rf dist/js && npm run build-plugin-types && npm run build-plugin-esm && cp src/js/src/dev-server-index.html dist/js/",
     "build-plugin-types": "tsc --project src/js/tsconfig.json --emitDeclarationOnly",
-    "build-plugin-esm": "esbuild src/js/src/index.ts --platform=node --format=esm --outfile=dist/js/index.js && esbuild src/js/src/install-hint.ts --platform=node --format=esm --outfile=dist/js/install-hint.js && esbuild src/js/src/litestar-meta.ts --platform=node --format=esm --outfile=dist/js/litestar-meta.js && mkdir -p dist/js/shared && esbuild src/js/src/shared/debounce.ts src/js/src/shared/format-path.ts src/js/src/shared/logger.ts src/js/src/shared/emit-route-types.ts src/js/src/shared/create-type-gen-plugin.ts --platform=node --format=esm --outdir=dist/js/shared",
+    "build-plugin-esm": "esbuild src/js/src/index.ts --platform=node --format=esm --outfile=dist/js/index.js && esbuild src/js/src/install-hint.ts --platform=node --format=esm --outfile=dist/js/install-hint.js && esbuild src/js/src/litestar-meta.ts --platform=node --format=esm --outfile=dist/js/litestar-meta.js && mkdir -p dist/js/shared && esbuild src/js/src/shared/bridge-schema.ts src/js/src/shared/debounce.ts src/js/src/shared/format-path.ts src/js/src/shared/logger.ts src/js/src/shared/emit-page-props-types.ts src/js/src/shared/typegen-plugin.ts --platform=node --format=esm --outdir=dist/js/shared",
     "build-helpers": "rm -rf dist/js/helpers && tsc --project src/js/tsconfig.helpers.json",
     "build-inertia-helpers": "rm -rf dist/js/inertia-helpers && tsc --project src/js/tsconfig.inertia-helpers.json",
     "build-integrations": "esbuild src/js/src/astro.ts src/js/src/sveltekit.ts src/js/src/nuxt.ts --platform=node --format=esm --outdir=dist/js",
-    "lint": "eslint --ext .ts ./src/js/src ./src/js/tests",
+    "lint": "biome check --vcs-enabled=false src/js/src src/js/tests",
     "test": "vitest --config ./src/js/vitest.config.ts run"
   },
   "devDependencies": {

package/dist/js/shared/create-type-gen-plugin.d.ts

@@ -1,99 +0,0 @@
-/**
- * Shared type generation Vite plugin.
- *
- * Creates a Vite plugin that watches for OpenAPI schema and route metadata changes
- * and regenerates TypeScript types using @hey-api/openapi-ts.
- * Used by Astro, Nuxt, and SvelteKit integrations.
- *
- * @module
- */
-import type { Plugin } from "vite";
-/**
- * Base configuration for type generation.
- */
-export interface BaseTypesConfig {
-    /**
-     * Enable type generation.
-     * @default false
-     */
-    enabled?: boolean;
-    /**
-     * Path to output generated TypeScript types.
-     */
-    output?: string;
-    /**
-     * Path where the OpenAPI schema is exported by Litestar.
-     * @default 'openapi.json'
-     */
-    openapiPath?: string;
-    /**
-     * Path where route metadata is exported by Litestar.
-     * @default 'routes.json'
-     */
-    routesPath?: string;
-    /**
-     * Generate Zod schemas in addition to TypeScript types.
-     * @default false
-     */
-    generateZod?: boolean;
-    /**
-     * Generate SDK client functions for API calls.
-     * @default true
-     */
-    generateSdk?: boolean;
-    /**
-     * Debounce time in milliseconds for type regeneration.
-     * @default 300
-     */
-    debounce?: number;
-}
-/**
- * Required version of types config (all fields defined).
- */
-export interface RequiredTypesConfig {
-    enabled: boolean;
-    output: string;
-    openapiPath: string;
-    routesPath: string;
-    generateZod: boolean;
-    generateSdk: boolean;
-    debounce: number;
-}
-/**
- * Options for creating the type generation plugin.
- */
-export interface TypeGenPluginOptions {
-    /**
-     * Framework name for logging (e.g., "litestar-astro", "litestar-nuxt").
-     */
-    frameworkName: string;
-    /**
-     * Vite plugin name.
-     */
-    pluginName: string;
-    /**
-     * The @hey-api client plugin to use when generating SDK.
-     * @default '@hey-api/client-fetch'
-     */
-    clientPlugin?: string;
-    /**
-     * Optional executor for running npx/bunx/pnpm dlx commands.
-     */
-    executor?: string;
-}
-/**
- * Create a Vite plugin for type generation from OpenAPI schemas.
- *
- * @param typesConfig - The type generation configuration
- * @param options - Plugin creation options
- * @returns A Vite plugin that watches for schema changes and regenerates types
- *
- * @example
- * ```typescript
- * const plugin = createTypeGenerationPlugin(
- *   { enabled: true, output: 'src/generated' },
- *   { frameworkName: 'litestar-astro', pluginName: 'litestar-astro-types' }
- * )
- * ```
- */
-export declare function createTypeGenerationPlugin(typesConfig: RequiredTypesConfig, options: TypeGenPluginOptions): Plugin;

package/dist/js/shared/create-type-gen-plugin.js

@@ -1,110 +0,0 @@
-import { exec } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { promisify } from "node:util";
-import colors from "picocolors";
-import { resolveInstallHint, resolvePackageExecutor } from "../install-hint.js";
-import { debounce } from "./debounce.js";
-import { emitRouteTypes } from "./emit-route-types.js";
-const execAsync = promisify(exec);
-function createTypeGenerationPlugin(typesConfig, options) {
-  const { frameworkName, pluginName, clientPlugin = "@hey-api/client-fetch", executor } = options;
-  let server = null;
-  let isGenerating = false;
-  async function runTypeGeneration() {
-    if (isGenerating) {
-      return false;
-    }
-    isGenerating = true;
-    const startTime = Date.now();
-    try {
-      const openapiPath = path.resolve(process.cwd(), typesConfig.openapiPath);
-      if (!fs.existsSync(openapiPath)) {
-        console.log(colors.cyan(`[${frameworkName}]`), colors.yellow("OpenAPI schema not found:"), typesConfig.openapiPath);
-        return false;
-      }
-      console.log(colors.cyan(`[${frameworkName}]`), colors.dim("Generating TypeScript types..."));
-      const projectRoot = process.cwd();
-      const candidates = [path.resolve(projectRoot, "openapi-ts.config.ts"), path.resolve(projectRoot, "hey-api.config.ts"), path.resolve(projectRoot, ".hey-api.config.ts")];
-      const configPath = candidates.find((p) => fs.existsSync(p)) || null;
-      let args;
-      if (configPath) {
-        console.log(colors.cyan(`[${frameworkName}]`), colors.dim("Using config:"), configPath);
-        args = ["@hey-api/openapi-ts", "--file", configPath];
-      } else {
-        args = ["@hey-api/openapi-ts", "-i", typesConfig.openapiPath, "-o", typesConfig.output];
-        const plugins = ["@hey-api/typescript", "@hey-api/schemas"];
-        if (typesConfig.generateSdk) {
-          plugins.push("@hey-api/sdk", clientPlugin);
-        }
-        if (typesConfig.generateZod) {
-          plugins.push("zod");
-        }
-        if (plugins.length) {
-          args.push("--plugins", ...plugins);
-        }
-      }
-      const command = executor ? resolvePackageExecutor(args.join(" "), executor) : `npx ${args.join(" ")}`;
-      await execAsync(command, { cwd: projectRoot });
-      const routesPath = path.resolve(process.cwd(), typesConfig.routesPath);
-      if (fs.existsSync(routesPath)) {
-        await emitRouteTypes(routesPath, typesConfig.output, { declareGlobalVars: true });
-      }
-      const duration = Date.now() - startTime;
-      console.log(colors.cyan(`[${frameworkName}]`), colors.green("Types generated"), colors.dim(`in ${duration}ms`));
-      if (server) {
-        server.ws.send({
-          type: "custom",
-          event: "litestar:types-updated",
-          data: {
-            output: typesConfig.output,
-            timestamp: Date.now()
-          }
-        });
-      }
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("not found") || message.includes("ENOENT")) {
-        console.log(colors.cyan(`[${frameworkName}]`), colors.yellow("@hey-api/openapi-ts not installed"), "- run:", resolveInstallHint());
-      } else {
-        console.error(colors.cyan(`[${frameworkName}]`), colors.red("Type generation failed:"), message);
-      }
-      return false;
-    } finally {
-      isGenerating = false;
-    }
-  }
-  const debouncedRunTypeGeneration = debounce(runTypeGeneration, typesConfig.debounce);
-  return {
-    name: pluginName,
-    enforce: "pre",
-    configureServer(devServer) {
-      server = devServer;
-      console.log(colors.cyan(`[${frameworkName}]`), colors.dim("Watching for schema changes:"), colors.yellow(typesConfig.openapiPath));
-    },
-    async buildStart() {
-      if (typesConfig.enabled) {
-        const openapiPath = path.resolve(process.cwd(), typesConfig.openapiPath);
-        if (fs.existsSync(openapiPath)) {
-          await runTypeGeneration();
-        }
-      }
-    },
-    handleHotUpdate({ file }) {
-      if (!typesConfig.enabled) {
-        return;
-      }
-      const relativePath = path.relative(process.cwd(), file);
-      const openapiPath = typesConfig.openapiPath.replace(/^\.\//, "");
-      const routesPath = typesConfig.routesPath.replace(/^\.\//, "");
-      if (relativePath === openapiPath || relativePath === routesPath || file.endsWith(openapiPath) || file.endsWith(routesPath)) {
-        console.log(colors.cyan(`[${frameworkName}]`), colors.dim("Schema changed:"), colors.yellow(relativePath));
-        debouncedRunTypeGeneration();
-      }
-    }
-  };
-}
-export {
-  createTypeGenerationPlugin
-};

package/dist/js/shared/emit-route-types.d.ts

@@ -1,41 +0,0 @@
-/**
- * Shared route type generation utility.
- *
- * Generates TypeScript types from routes.json metadata for type-safe routing.
- * Used by the main litestar plugin and framework integrations (Astro, Nuxt, SvelteKit).
- *
- * @module
- */
-/**
- * Options for emitRouteTypes.
- */
-export interface EmitRouteTypesOptions {
-    /**
-     * Whether to register route() on window for global access.
-     * Only used by the main plugin.
-     * @default false
-     */
-    globalRoute?: boolean;
-    /**
-     * Whether to declare global `var routes` and `var serverRoutes`.
-     * Used by framework integrations for SSR compatibility.
-     * @default false
-     */
-    declareGlobalVars?: boolean;
-}
-/**
- * Generate TypeScript route types from routes.json metadata.
- *
- * Creates a routes.ts file with:
- * - routesMeta: full route metadata
- * - routes: name -> uri map
- * - serverRoutes: alias of routes
- * - route(): type-safe URL generator
- * - hasRoute(): type guard
- * - CSRF helpers re-exported from litestar-vite-plugin/helpers
- *
- * @param routesPath - Path to routes.json file
- * @param outputDir - Output directory for routes.ts
- * @param options - Generation options
- */
-export declare function emitRouteTypes(routesPath: string, outputDir: string, options?: EmitRouteTypesOptions): Promise<void>;