litestar-vite-plugin 0.25.0 → 0.26.1

package/dist/js/inertia-helpers/index.d.ts

@@ -64,12 +64,16 @@ export declare function resolvePageComponent<T>(path: string | string[], pages:
  * Offset-based pagination props.
  *
  * Returned when a route returns Litestar's `OffsetPagination` type.
- * Contains items plus metadata for offset/limit pagination.
+ * Litestar-Vite flattens pagination metadata as top-level sibling props:
+ * the route prop contains the item array, and `total`, `limit`, and `offset`
+ * are emitted beside it.
  *
  * @example
  * ```ts
  * interface User { id: string; name: string }
- * const { items, total, limit, offset } = props.users as OffsetPaginationProps<User>
+ * type UsersPageProps = { users: User[] } & Omit<OffsetPaginationProps<User>, 'items'>
+ *
+ * const { users, total, limit, offset } = props as UsersPageProps
  * ```
  */
 export interface OffsetPaginationProps<T> {
@@ -86,12 +90,16 @@ export interface OffsetPaginationProps<T> {
  * Classic page-based pagination props.
  *
  * Returned when a route returns Litestar's `ClassicPagination` type.
- * Contains items plus metadata for page number pagination.
+ * Litestar-Vite flattens pagination metadata as top-level sibling props:
+ * the route prop contains the item array, and `currentPage`, `totalPages`,
+ * and `pageSize` are emitted beside it.
  *
  * @example
  * ```ts
  * interface Post { id: string; title: string }
- * const { items, currentPage, totalPages, pageSize } = props.posts as ClassicPaginationProps<Post>
+ * type PostsPageProps = { posts: Post[] } & Omit<ClassicPaginationProps<Post>, 'items'>
+ *
+ * const { posts, currentPage, totalPages, pageSize } = props as PostsPageProps
  * ```
  */
 export interface ClassicPaginationProps<T> {
@@ -108,12 +116,16 @@ export interface ClassicPaginationProps<T> {
  * Cursor-based pagination props.
  *
  * Used for cursor/keyset pagination, commonly with infinite scroll.
- * Contains items plus cursor tokens for navigation.
+ * Litestar-Vite flattens pagination metadata as top-level sibling props:
+ * the route prop contains the item array, and cursor metadata is emitted
+ * beside it.
  *
  * @example
  * ```ts
  * interface Message { id: string; content: string }
- * const { items, hasMore, nextCursor } = props.messages as CursorPaginationProps<Message>
+ * type MessagesPageProps = { messages: Message[] } & Omit<CursorPaginationProps<Message>, 'items'>
+ *
+ * const { messages, hasMore, nextCursor } = props as MessagesPageProps
  * if (hasMore && nextCursor) {
  *   // Fetch more with cursor
  * }
@@ -139,6 +151,11 @@ export interface CursorPaginationProps<T> {
  * Union type for any pagination props.
  *
  * Use when you need to handle multiple pagination styles.
+ * Because pagination metadata is flattened as sibling keys, two paginators in
+ * one response can collide on keys such as `total`, `limit`, `offset`,
+ * `currentPage`, or `pageSize`. Return one flattened paginator per response,
+ * or wrap additional paginators in explicit prop containers with distinct
+ * metadata.
  *
  * @example
  * ```ts
@@ -166,11 +183,12 @@ export type PaginationProps<T> = OffsetPaginationProps<T> | ClassicPaginationPro
  * import { usePage } from '@inertiajs/vue3'
  *
  * const page = usePage()
- * const scrollProps = page.props.scrollProps as ScrollProps
+ * const scrollProps = page.props.scrollProps as Record<string, ScrollProps> | undefined
+ * const postsScroll = scrollProps?.posts
  *
  * function loadMore() {
- *   if (scrollProps.nextPage) {
- *     router.get(url, { [scrollProps.pageName]: scrollProps.nextPage })
+ *   if (postsScroll?.nextPage) {
+ *     router.get(url, { [postsScroll.pageName]: postsScroll.nextPage })
  *   }
  * }
  * ```

package/dist/js/install-hint.d.ts

@@ -13,3 +13,20 @@ export declare function resolveInstallHint(pkg?: string): string;
  * @returns The full command string (e.g., "npx @hey-api/openapi-ts ..." or "bunx @hey-api/openapi-ts ...")
  */
 export declare function resolvePackageExecutor(pkg: string, executor?: string): string;
+/**
+ * Resolves the package executor command as argv.
+ *
+ * This is used for actual process execution so package arguments are never
+ * shell-joined. The string-returning ``resolvePackageExecutor`` remains the
+ * display/back-compat helper.
+ */
+export interface PackageExecutorArgvOptions {
+    /**
+     * Package spec to install for executors that support an explicit package
+     * separate from the command binary, e.g. npm exec --package.
+     */
+    packageSpec?: string;
+    /** Binary command exposed by packageSpec. */
+    binName?: string;
+}
+export declare function resolvePackageExecutorArgv(args: string[], executor?: string, options?: PackageExecutorArgvOptions): string[];

package/dist/js/install-hint.js

@@ -63,8 +63,42 @@ function resolvePackageExecutor(pkg, executor) {
       return `npx ${pkg}`;
   }
 }
+function getPackageNameFromSpec(packageSpec) {
+  if (packageSpec.startsWith("@")) {
+    const versionIndex2 = packageSpec.indexOf("@", packageSpec.indexOf("/") + 1);
+    return versionIndex2 === -1 ? packageSpec : packageSpec.slice(0, versionIndex2);
+  }
+  const versionIndex = packageSpec.indexOf("@");
+  return versionIndex === -1 ? packageSpec : packageSpec.slice(0, versionIndex);
+}
+function resolveDenoPackageSpec(packageSpec, binName) {
+  if (!binName) return packageSpec;
+  const packageName = getPackageNameFromSpec(packageSpec);
+  const defaultBinName = packageName.split("/").pop();
+  return defaultBinName === binName ? packageSpec : `${packageSpec}/${binName}`;
+}
+function resolvePackageExecutorArgv(args, executor, options = {}) {
+  const runtime = executor || detectExecutor();
+  const { packageSpec, binName } = options;
+  switch (runtime) {
+    case "bun":
+      return ["bunx", ...packageSpec ? [packageSpec, ...args] : args];
+    case "deno":
+      return ["deno", "run", "-A", ...packageSpec ? [`npm:${resolveDenoPackageSpec(packageSpec, binName)}`, ...args] : args];
+    case "pnpm":
+      return ["pnpm", "dlx", ...packageSpec ? [packageSpec, ...args] : args];
+    case "yarn":
+      return ["yarn", "dlx", ...packageSpec ? [packageSpec, ...args] : args];
+    default:
+      if (packageSpec && binName) {
+        return ["npm", "exec", "--yes", "--package", packageSpec, "--", binName, ...args];
+      }
+      return ["npx", ...args];
+  }
+}
 export {
   detectExecutor,
   resolveInstallHint,
-  resolvePackageExecutor
+  resolvePackageExecutor,
+  resolvePackageExecutorArgv
 };

package/dist/js/nuxt.d.ts

@@ -100,6 +100,12 @@ export interface NuxtTypesConfig {
      * @default false
      */
     globalRoute?: boolean;
+    /**
+     * Fail Vite when type generation fails.
+     *
+     * Defaults to true during build and false during dev.
+     */
+    failOnError?: boolean;
     /**
      * Debounce time in milliseconds for type regeneration.
      *

package/dist/js/nuxt.js

@@ -2,9 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import colors from "picocolors";
 import { readBridgeConfig } from "./shared/bridge-schema.js";
-import { DEBOUNCE_MS } from "./shared/constants.js";
 import { normalizeHost, resolveHotFilePath, resolveLitestarPort } from "./shared/network.js";
-import { createLitestarTypeGenPlugin } from "./shared/typegen-plugin.js";
+import { createLitestarTypeGenPlugin, resolveTypesConfig } from "./shared/typegen-plugin.js";
 import { hmrServerConfig } from "./shared/vite-compat.js";
 function resolveConfig(config = {}) {
   let hotFile;
@@ -39,74 +38,13 @@ function resolveConfig(config = {}) {
   if (resolvedLitestarPort !== null) {
     litestarPort = resolvedLitestarPort;
   }
-  let typesConfig = false;
-  const defaultTypesOutput = "generated";
-  const buildTypeDefaults = (output) => ({
-    openapiPath: path.join(output, "openapi.json"),
-    routesPath: path.join(output, "routes.json"),
-    pagePropsPath: path.join(output, "inertia-pages.json"),
-    schemasTsPath: path.join(output, "schemas.ts")
+  const typesConfig = resolveTypesConfig({
+    requested: config.types,
+    pythonConfig: pythonTypesConfig ?? void 0,
+    defaultOutput: "generated",
+    mergePythonWhenTrue: true,
+    mergePythonForObject: true
   });
-  if (config.types === true) {
-    const output = pythonTypesConfig?.output ?? defaultTypesOutput;
-    const defaults = buildTypeDefaults(output);
-    typesConfig = {
-      enabled: true,
-      output,
-      openapiPath: pythonTypesConfig?.openapiPath ?? defaults.openapiPath,
-      routesPath: pythonTypesConfig?.routesPath ?? defaults.routesPath,
-      pagePropsPath: pythonTypesConfig?.pagePropsPath ?? defaults.pagePropsPath,
-      schemasTsPath: pythonTypesConfig?.schemasTsPath ?? defaults.schemasTsPath,
-      generateZod: pythonTypesConfig?.generateZod ?? false,
-      generateSdk: pythonTypesConfig?.generateSdk ?? true,
-      generateRoutes: pythonTypesConfig?.generateRoutes ?? true,
-      generatePageProps: pythonTypesConfig?.generatePageProps ?? true,
-      generateSchemas: pythonTypesConfig?.generateSchemas ?? true,
-      globalRoute: pythonTypesConfig?.globalRoute ?? false,
-      debounce: DEBOUNCE_MS
-    };
-  } else if (typeof config.types === "object" && config.types !== null) {
-    const userProvidedOutput = Object.hasOwn(config.types, "output");
-    const output = config.types.output ?? pythonTypesConfig?.output ?? defaultTypesOutput;
-    const defaults = buildTypeDefaults(output);
-    const openapiFallback = userProvidedOutput ? defaults.openapiPath : pythonTypesConfig?.openapiPath ?? defaults.openapiPath;
-    const routesFallback = userProvidedOutput ? defaults.routesPath : pythonTypesConfig?.routesPath ?? defaults.routesPath;
-    const pagePropsFallback = userProvidedOutput ? defaults.pagePropsPath : pythonTypesConfig?.pagePropsPath ?? defaults.pagePropsPath;
-    const schemasFallback = userProvidedOutput ? defaults.schemasTsPath : pythonTypesConfig?.schemasTsPath ?? defaults.schemasTsPath;
-    typesConfig = {
-      enabled: config.types.enabled ?? true,
-      output,
-      openapiPath: config.types.openapiPath ?? openapiFallback,
-      routesPath: config.types.routesPath ?? routesFallback,
-      pagePropsPath: config.types.pagePropsPath ?? pagePropsFallback,
-      schemasTsPath: config.types.schemasTsPath ?? schemasFallback,
-      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,
-      generateSchemas: config.types.generateSchemas ?? pythonTypesConfig?.generateSchemas ?? true,
-      globalRoute: config.types.globalRoute ?? pythonTypesConfig?.globalRoute ?? false,
-      debounce: config.types.debounce ?? DEBOUNCE_MS
-    };
-  } else if (config.types !== false && pythonTypesConfig?.enabled) {
-    const output = pythonTypesConfig.output ?? defaultTypesOutput;
-    const defaults = buildTypeDefaults(output);
-    typesConfig = {
-      enabled: true,
-      output,
-      openapiPath: pythonTypesConfig.openapiPath ?? defaults.openapiPath,
-      routesPath: pythonTypesConfig.routesPath ?? defaults.routesPath,
-      pagePropsPath: pythonTypesConfig.pagePropsPath ?? defaults.pagePropsPath,
-      schemasTsPath: pythonTypesConfig.schemasTsPath ?? defaults.schemasTsPath,
-      generateZod: pythonTypesConfig.generateZod ?? false,
-      generateSdk: pythonTypesConfig.generateSdk ?? true,
-      generateRoutes: pythonTypesConfig.generateRoutes ?? true,
-      generatePageProps: pythonTypesConfig.generatePageProps ?? true,
-      generateSchemas: pythonTypesConfig.generateSchemas ?? true,
-      globalRoute: pythonTypesConfig.globalRoute ?? false,
-      debounce: DEBOUNCE_MS
-    };
-  }
   return {
     apiProxy: config.apiProxy ?? "http://localhost:8000",
     apiPrefix: config.apiPrefix ?? "/api",

package/dist/js/shared/bridge-schema.d.ts

@@ -25,6 +25,7 @@ export interface BridgeTypesConfig {
     generatePageProps: boolean;
     generateSchemas: boolean;
     globalRoute: boolean;
+    failOnError?: boolean;
 }
 export interface BridgeSpaConfig {
     /** Use script element instead of data-page attribute for Inertia page data */

package/dist/js/shared/bridge-schema.js

@@ -29,6 +29,9 @@ const allowedLogLevels = /* @__PURE__ */ new Set(["quiet", "normal", "verbose"])
 function fail(message) {
   throw new Error(`litestar-vite-plugin: invalid .litestar.json - ${message}`);
 }
+function warn(message) {
+  console.warn(`litestar-vite-plugin: invalid .litestar.json - ${message}`);
+}
 function assertObject(value, label) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     fail(`${label} must be an object`);
@@ -122,6 +125,8 @@ function parseTypesConfig(value) {
   const generatePageProps = assertBoolean(obj, "generatePageProps");
   const generateSchemas = assertOptionalBoolean(obj, "generateSchemas", true);
   const globalRoute = assertBoolean(obj, "globalRoute");
+  const rawFailOnError = obj.failOnError;
+  const failOnError = rawFailOnError === void 0 || rawFailOnError === null ? void 0 : assertBoolean(obj, "failOnError");
   return {
     enabled,
     output,
@@ -135,7 +140,8 @@ function parseTypesConfig(value) {
     generateRoutes,
     generatePageProps,
     generateSchemas,
-    globalRoute
+    globalRoute,
+    failOnError
   };
 }
 function parseLogging(value) {
@@ -162,7 +168,7 @@ function parseBridgeSchema(value) {
   const obj = assertObject(value, "root");
   for (const key of Object.keys(obj)) {
     if (!allowedTopLevelKeys.has(key)) {
-      fail(`unknown top-level key "${key}"`);
+      warn(`unknown top-level key "${key}" ignored`);
     }
   }
   const assetUrl = assertString(obj, "assetUrl");
@@ -211,16 +217,42 @@ function parseBridgeSchema(value) {
 function readBridgeConfig(explicitPath) {
   const envPath = explicitPath ?? process.env.LITESTAR_VITE_CONFIG_PATH;
   if (envPath) {
-    if (!fs.existsSync(envPath)) {
-      return null;
-    }
-    return readBridgeConfigFile(envPath);
+    return readBridgeConfigFileCached(envPath);
   }
   const defaultPath = path.join(process.cwd(), ".litestar.json");
-  if (fs.existsSync(defaultPath)) {
-    return readBridgeConfigFile(defaultPath);
+  return readBridgeConfigFileCached(defaultPath);
+}
+const bridgeConfigCache = /* @__PURE__ */ new Map();
+function readBridgeConfigFileCached(filePath) {
+  const resolvedPath = path.resolve(filePath);
+  if (!fs.existsSync(resolvedPath)) {
+    return null;
+  }
+  let mtimeMs = null;
+  try {
+    mtimeMs = fs.statSync(resolvedPath).mtimeMs;
+  } catch {
+    mtimeMs = null;
+  }
+  if (mtimeMs !== null) {
+    const cached = bridgeConfigCache.get(resolvedPath);
+    if (cached?.mtimeMs === mtimeMs) {
+      return cached.config;
+    }
+  }
+  try {
+    const config = readBridgeConfigFile(resolvedPath);
+    if (mtimeMs !== null) {
+      bridgeConfigCache.set(resolvedPath, { mtimeMs, config });
+    }
+    return config;
+  } catch (error) {
+    warn(error instanceof Error ? error.message : String(error));
+    if (mtimeMs !== null) {
+      bridgeConfigCache.set(resolvedPath, { mtimeMs, config: null });
+    }
+    return null;
   }
-  return null;
 }
 function readBridgeConfigFile(filePath) {
   let raw;

package/dist/js/shared/constants.d.ts

@@ -11,23 +11,9 @@
  */
 export declare const DEBOUNCE_MS = 300;
 /**
- * Timeout in milliseconds for backend health checks.
+ * Pinned fallback package spec for @hey-api/openapi-ts.
  *
- * Used when checking if the Litestar backend is available
- * before attempting to fetch OpenAPI schema.
+ * Keep this in sync with CURRENT_NPM_VERSION_RANGES in the Python scaffold
+ * registry and the optional peer dependency range in package.json.
  */
-export declare const BACKEND_CHECK_TIMEOUT_MS = 2000;
-/**
- * Default asset URL path.
- *
- * Used as fallback when no explicit assetUrl is configured.
- * Should match the default in Python ViteConfig.
- */
-export declare const DEFAULT_ASSET_URL = "/static/";
-/**
- * Default output directory for generated TypeScript types.
- *
- * Used by framework integrations as fallback when no output
- * is specified in Python bridge config or plugin options.
- */
-export declare const DEFAULT_TYPES_OUTPUT = "src/generated";
+export declare const HEY_API_PINNED_SPEC = "@hey-api/openapi-ts@0.98.2";

package/dist/js/shared/constants.js

@@ -1,10 +1,6 @@
 const DEBOUNCE_MS = 300;
-const BACKEND_CHECK_TIMEOUT_MS = 2e3;
-const DEFAULT_ASSET_URL = "/static/";
-const DEFAULT_TYPES_OUTPUT = "src/generated";
+const HEY_API_PINNED_SPEC = "@hey-api/openapi-ts@0.98.2";
 export {
-  BACKEND_CHECK_TIMEOUT_MS,
   DEBOUNCE_MS,
-  DEFAULT_ASSET_URL,
-  DEFAULT_TYPES_OUTPUT
+  HEY_API_PINNED_SPEC
 };

package/dist/js/shared/emit-page-props-types.d.ts

@@ -3,4 +3,4 @@
  *
  * @returns true if file was changed, false if unchanged
  */
-export declare function emitPagePropsTypes(pagesPath: string, outputDir: string): Promise<boolean>;
+export declare function emitPagePropsTypes(pagesPath: string, outputDir: string, projectRoot?: string): Promise<boolean>;

package/dist/js/shared/emit-page-props-types.js

@@ -1,10 +1,44 @@
 import fs from "node:fs";
 import path from "node:path";
 import { writeIfChanged } from "./write-if-changed.js";
-async function emitPagePropsTypes(pagesPath, outputDir) {
+const semanticAliases = {
+  UUID: { description: "UUID v4 string", base: "string" },
+  DateTime: { description: "RFC 3339 date-time string", base: "string" },
+  DateOnly: { description: "ISO 8601 date string (YYYY-MM-DD)", base: "string" },
+  TimeOnly: { description: "ISO 8601 time string", base: "string" },
+  Duration: { description: "ISO 8601 duration string", base: "string" },
+  Email: { description: "Email address string", base: "string" },
+  URI: { description: "URI/URL string", base: "string" },
+  IPv4: { description: "IPv4 address string", base: "string" },
+  IPv6: { description: "IPv6 address string", base: "string" }
+};
+function collectSemanticAliases(typeExpr) {
+  const aliases = /* @__PURE__ */ new Set();
+  for (const match of typeExpr.matchAll(/\b[A-Za-z_][A-Za-z0-9_]*\b/g)) {
+    const name = match[0];
+    if (name in semanticAliases) {
+      aliases.add(name);
+    }
+  }
+  return [...aliases].toSorted();
+}
+function renderSemanticAliases(aliases) {
+  if (aliases.size === 0) {
+    return "";
+  }
+  const lines = ["/** Semantic string aliases derived from OpenAPI `format`. */"];
+  for (const alias of [...aliases].toSorted()) {
+    const { description, base } = semanticAliases[alias];
+    lines.push(`/** ${description} */`, `export type ${alias} = ${base}`, "");
+  }
+  return `${lines.join("\n").trimEnd()}
+
+`;
+}
+async function emitPagePropsTypes(pagesPath, outputDir, projectRoot = process.cwd()) {
   const contents = await fs.promises.readFile(pagesPath, "utf-8");
   const json = JSON.parse(contents);
-  const outDir = path.resolve(process.cwd(), outputDir);
+  const outDir = path.resolve(projectRoot, outputDir);
   await fs.promises.mkdir(outDir, { recursive: true });
   const outFile = path.join(outDir, "page-props.ts");
   const { includeDefaultAuth, includeDefaultFlash } = json.typeGenConfig;
@@ -84,8 +118,15 @@ export interface FlashMessages {}
     return `  ${safeKey}${optional}: ${def.type}`;
   });
   const allCustomTypes = /* @__PURE__ */ new Set();
+  const usedSemanticAliases = /* @__PURE__ */ new Set();
   for (const data of Object.values(json.pages)) {
-    if (data.tsType) {
+    const typeExpr = data.tsType ?? data.propsType;
+    if (typeExpr) {
+      for (const alias of collectSemanticAliases(typeExpr)) {
+        usedSemanticAliases.add(alias);
+      }
+    }
+    if (data.tsType && /^[A-Za-z_][A-Za-z0-9_]*$/.test(data.tsType)) {
       allCustomTypes.add(data.tsType);
     }
     for (const t of data.customTypes ?? []) {
@@ -131,9 +172,13 @@ export interface FlashMessages {}
     "RegExp",
     "User",
     "AuthData",
-    "FlashMessages"
+    "FlashMessages",
+    ...Object.keys(semanticAliases)
   ]);
   for (const def of Object.values(generatedSharedProps)) {
+    for (const alias of collectSemanticAliases(def.type)) {
+      usedSemanticAliases.add(alias);
+    }
     for (const match of def.type.matchAll(/\b[A-Za-z_][A-Za-z0-9_]*\b/g)) {
       const name = match[0];
       if (!builtinTypes.has(name)) {
@@ -190,6 +235,7 @@ export interface FlashMessages {}
   if (importStatement) {
     importStatement += "\n";
   }
+  const semanticAliasTypes = renderSemanticAliases(usedSemanticAliases);
   const pageEntries = [];
   for (const [component, data] of Object.entries(json.pages)) {
     const rawType = data.tsType || data.propsType || defaultFallback;
@@ -206,7 +252,7 @@ export interface FlashMessages {}
 // Import user-defined type extensions (edit page-props.user.ts to customize)
 import type { UserExtensions, SharedPropsExtensions } from "./page-props.user"
 
-${importStatement}${userTypes}${authTypes}${flashTypes}/**
+${importStatement}${semanticAliasTypes}${userTypes}${authTypes}${flashTypes}/**
  * Generated shared props (always present).
  * Includes built-in props + static config props.
  */

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

@@ -5,4 +5,4 @@
  * @param outputDir - Output directory (contains api/types.gen.ts)
  * @returns true if file was changed, false if unchanged
  */
-export declare function emitSchemasTypes(routesJsonPath: string, outputDir: string, schemasOutputPath?: string): Promise<boolean>;
+export declare function emitSchemasTypes(routesJsonPath: string, outputDir: string, schemasOutputPath?: string, projectRoot?: string): Promise<boolean>;

package/dist/js/shared/emit-schemas-types.js

@@ -10,21 +10,12 @@ function toImportPath(fromDir, targetFile) {
   return `./${withoutExtension}`;
 }
 function parseHeyApiTypes(content) {
-  const dataTypes = /* @__PURE__ */ new Map();
   const responsesTypes = /* @__PURE__ */ new Set();
   const errorsTypes = /* @__PURE__ */ new Set();
   const urlToDataType = /* @__PURE__ */ new Map();
-  const typeBlockRegex = /export\s+type\s+(\w+Data)\s*=\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gs;
-  for (const match of content.matchAll(typeBlockRegex)) {
-    const typeName = match[1];
-    const typeBody = match[2];
-    const urlMatch = typeBody.match(/url:\s*['"]([^'"]+)['"]/);
+  for (const { typeName, body } of findExportedDataTypeBlocks(content)) {
+    const urlMatch = body.match(/url:\s*['"]([^'"]+)['"]/);
     const url = urlMatch ? urlMatch[1] : null;
-    const hasBody = /\bbody\s*:/.test(typeBody) && !/\bbody\s*\?\s*:\s*never/.test(typeBody);
-    const hasPath = /\bpath\s*:/.test(typeBody) && !/\bpath\s*\?\s*:\s*never/.test(typeBody);
-    const hasQuery = /\bquery\s*:/.test(typeBody) && !/\bquery\s*\?\s*:\s*never/.test(typeBody);
-    const info = { typeName, url, hasBody, hasPath, hasQuery };
-    dataTypes.set(typeName, info);
     if (url) {
       urlToDataType.set(url, typeName);
     }
@@ -37,7 +28,87 @@ function parseHeyApiTypes(content) {
   for (const match of content.matchAll(errorsRegex)) {
     errorsTypes.add(match[1]);
   }
-  return { dataTypes, responsesTypes, errorsTypes, urlToDataType };
+  return { responsesTypes, errorsTypes, urlToDataType };
+}
+function findExportedDataTypeBlocks(content) {
+  const blocks = [];
+  const declarationRegex = /export\s+type\s+(\w+Data)\s*=\s*/g;
+  for (const match of content.matchAll(declarationRegex)) {
+    const typeName = match[1];
+    const bodyStart = match.index + match[0].length;
+    const openIndex = content.indexOf("{", bodyStart);
+    const nextToken = content.slice(bodyStart, openIndex === -1 ? content.length : openIndex).trim();
+    if (openIndex === -1 || nextToken.length > 0) {
+      console.warn(`litestar-vite: Unable to parse hey-api Data type ${typeName}; expected object type`);
+      continue;
+    }
+    const closeIndex = findMatchingBrace(content, openIndex);
+    if (closeIndex === -1) {
+      console.warn(`litestar-vite: Unable to parse hey-api Data type ${typeName}; unbalanced braces`);
+      continue;
+    }
+    blocks.push({ typeName, body: content.slice(openIndex + 1, closeIndex) });
+  }
+  return blocks;
+}
+function findMatchingBrace(content, openIndex) {
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let i = openIndex; i < content.length; i += 1) {
+    const char = content[i];
+    const next = content[i + 1];
+    if (lineComment) {
+      if (char === "\n") {
+        lineComment = false;
+      }
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      i += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      i += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
 }
 function normalizePath(routePath) {
   return routePath.replace(/\{([^:}]+):[^}]+\}/g, "{$1}");
@@ -312,9 +383,9 @@ export type HasPathParams<T extends OperationName> = PathParams<T> extends never
 export type HasQueryParams<T extends OperationName> = QueryParams<T> extends never ? false : true
 `;
 }
-async function emitSchemasTypes(routesJsonPath, outputDir, schemasOutputPath) {
-  const outDir = path.resolve(process.cwd(), outputDir);
-  const outFile = schemasOutputPath ? path.resolve(process.cwd(), schemasOutputPath) : path.join(outDir, "schemas.ts");
+async function emitSchemasTypes(routesJsonPath, outputDir, schemasOutputPath, projectRoot = process.cwd()) {
+  const outDir = path.resolve(projectRoot, outputDir);
+  const outFile = schemasOutputPath ? path.resolve(projectRoot, schemasOutputPath) : path.join(outDir, "schemas.ts");
   const schemasDir = path.dirname(outFile);
   const apiTypesPath = path.join(outDir, "api", "types.gen.ts");
   const apiTypesImportPath = toImportPath(schemasDir, apiTypesPath);

package/dist/js/shared/emit-static-props-types.d.ts

@@ -8,4 +8,4 @@
  *
  * @returns true if file was changed, false if unchanged
  */
-export declare function emitStaticPropsTypes(outputDir: string): Promise<boolean>;
+export declare function emitStaticPropsTypes(outputDir: string, projectRoot?: string): Promise<boolean>;

package/dist/js/shared/emit-static-props-types.js

@@ -53,10 +53,10 @@ function toInterfaceName(key) {
   const pascal = key.replace(/[^a-zA-Z0-9_$]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").replace(/(^|_)([a-z])/g, (_, __, c) => c.toUpperCase());
   return pascal || "StaticProp";
 }
-async function emitStaticPropsTypes(outputDir) {
+async function emitStaticPropsTypes(outputDir, projectRoot = process.cwd()) {
   const bridgeConfig = readBridgeConfig();
   const staticProps = bridgeConfig?.staticProps ?? {};
-  const outDir = path.resolve(process.cwd(), outputDir);
+  const outDir = path.resolve(projectRoot, outputDir);
   await fs.promises.mkdir(outDir, { recursive: true });
   const outFile = path.join(outDir, "static-props.ts");
   if (Object.keys(staticProps).length === 0) {