litestar-vite-plugin 0.15.0-beta.5 → 0.15.0-rc.1

package/dist/js/nuxt.js

@@ -1,7 +1,8 @@
 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 normalizeHost(host) {
   if (host === "::" || host === "::1" || host === "0.0.0.0") {
     return "localhost";
@@ -12,10 +13,11 @@ function normalizeHost(host) {
   return host;
 }
 function resolveConfig(config = {}) {
-  const runtimeConfigPath = process.env.LITESTAR_VITE_CONFIG_PATH;
   let hotFile;
   let proxyMode = "vite";
   let devPort;
+  let pythonTypesConfig;
+  let hasPythonConfig = false;
   const envPort = process.env.VITE_PORT;
   if (envPort) {
     devPort = Number.parseInt(envPort, 10);
@@ -24,42 +26,61 @@ 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) {
-        devPort = json.port;
-      }
-      pythonExecutor = json.executor;
-    } 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;
+    devPort = runtime.port;
+    pythonExecutor = runtime.executor;
+    if (runtime.types) {
+      pythonTypesConfig = runtime.types;
     }
   }
   let typesConfig = false;
   if (config.types === true) {
     typesConfig = {
       enabled: true,
-      output: "types/api",
-      openapiPath: "openapi.json",
-      routesPath: "routes.json",
-      generateZod: false,
-      generateSdk: true,
+      output: pythonTypesConfig?.output ?? "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 ?? "types/api",
-      openapiPath: config.types.openapiPath ?? "openapi.json",
-      routesPath: config.types.routesPath ?? "routes.json",
-      generateZod: config.types.generateZod ?? false,
-      generateSdk: config.types.generateSdk ?? true,
+      output: config.types.output ?? pythonTypesConfig?.output ?? "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 ?? "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
+    };
   }
   return {
     apiProxy: config.apiProxy ?? "http://localhost:8000",
@@ -69,7 +90,8 @@ function resolveConfig(config = {}) {
     hotFile,
     proxyMode,
     devPort,
-    executor: config.executor ?? pythonExecutor
+    executor: config.executor ?? pythonExecutor,
+    hasPythonConfig
   };
 }
 async function getPort() {
@@ -147,26 +169,29 @@ function createProxyPlugin(config) {
     }
   };
 }
-function litestarPlugins(userConfig = {}) {
-  const config = resolveConfig(userConfig);
+function litestarPluginsFromResolved(config) {
   const plugins = [createProxyPlugin(config)];
   if (config.types !== false && config.types.enabled) {
     plugins.push(
-      createTypeGenerationPlugin(config.types, {
-        frameworkName: "litestar-nuxt",
+      createLitestarTypeGenPlugin(config.types, {
         pluginName: "litestar-nuxt-types",
-        clientPlugin: "@hey-api/client-nuxt",
-        executor: config.executor
+        frameworkName: "litestar-nuxt",
+        sdkClientPlugin: "@hey-api/client-nuxt",
+        executor: config.executor,
+        hasPythonConfig: config.hasPythonConfig
       })
     );
   }
   return plugins;
 }
+function _litestarPlugins(userConfig = {}) {
+  return litestarPluginsFromResolved(resolveConfig(userConfig));
+}
 function litestarNuxtModule(userOptions, nuxt) {
   const nuxtConfigOptions = nuxt.options.litestar;
   const mergedOptions = { ...nuxtConfigOptions, ...userOptions };
   const config = resolveConfig(mergedOptions);
-  const plugins = litestarPlugins(config);
+  const plugins = litestarPluginsFromResolved(config);
   nuxt.options.vite = nuxt.options.vite || {};
   nuxt.options.vite.plugins = nuxt.options.vite.plugins || [];
   nuxt.options.vite.plugins.push(...plugins);
@@ -231,6 +256,5 @@ const litestarModule = litestarNuxtModule;
 var nuxt_default = litestarModule;
 export {
   nuxt_default as default,
-  litestarModule,
-  litestarPlugins
+  litestarModule
 };

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

@@ -0,0 +1,51 @@
+/**
+ * Canonical bridge schema for `.litestar.json`.
+ *
+ * This is the single source of truth on the TypeScript side for the config
+ * contract emitted by the Python VitePlugin.
+ *
+ * The project is pre-1.0: no legacy keys, no fallbacks, fail-fast on mismatch.
+ *
+ * @module
+ */
+export type BridgeMode = "spa" | "template" | "htmx" | "hybrid" | "inertia" | "ssr" | "ssg" | "external";
+export type BridgeProxyMode = "vite" | "direct" | "proxy" | null;
+export type BridgeExecutor = "node" | "bun" | "deno" | "yarn" | "pnpm";
+export interface BridgeTypesConfig {
+    enabled: boolean;
+    output: string;
+    openapiPath: string;
+    routesPath: string;
+    pagePropsPath: string;
+    generateZod: boolean;
+    generateSdk: boolean;
+    generateRoutes: boolean;
+    generatePageProps: boolean;
+    globalRoute: boolean;
+}
+export interface BridgeSchema {
+    assetUrl: string;
+    bundleDir: string;
+    resourceDir: string;
+    staticDir: string;
+    hotFile: string;
+    manifest: string;
+    mode: BridgeMode;
+    proxyMode: BridgeProxyMode;
+    host: string;
+    port: number;
+    ssrEnabled: boolean;
+    ssrOutDir: string | null;
+    types: BridgeTypesConfig | null;
+    executor: BridgeExecutor;
+    logging: {
+        level: "quiet" | "normal" | "verbose";
+        showPathsAbsolute: boolean;
+        suppressNpmOutput: boolean;
+        suppressViteBanner: boolean;
+        timestamps: boolean;
+    } | null;
+    litestarVersion: string;
+}
+export declare function parseBridgeSchema(value: unknown): BridgeSchema;
+export declare function readBridgeConfig(explicitPath?: string): BridgeSchema | null;

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

@@ -0,0 +1,178 @@
+import fs from "node:fs";
+import path from "node:path";
+const allowedTopLevelKeys = /* @__PURE__ */ new Set([
+  "assetUrl",
+  "bundleDir",
+  "resourceDir",
+  "staticDir",
+  "hotFile",
+  "manifest",
+  "mode",
+  "proxyMode",
+  "host",
+  "port",
+  "ssrEnabled",
+  "ssrOutDir",
+  "types",
+  "executor",
+  "logging",
+  "litestarVersion"
+]);
+const allowedModes = /* @__PURE__ */ new Set(["spa", "template", "htmx", "hybrid", "inertia", "ssr", "ssg", "external"]);
+const allowedProxyModes = /* @__PURE__ */ new Set(["vite", "direct", "proxy"]);
+const allowedExecutors = /* @__PURE__ */ new Set(["node", "bun", "deno", "yarn", "pnpm"]);
+const allowedLogLevels = /* @__PURE__ */ new Set(["quiet", "normal", "verbose"]);
+function fail(message) {
+  throw new Error(`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`);
+  }
+  return value;
+}
+function assertString(obj, key) {
+  const value = obj[key];
+  if (typeof value !== "string" || value.length === 0) {
+    fail(`"${key}" must be a non-empty string`);
+  }
+  return value;
+}
+function assertBoolean(obj, key) {
+  const value = obj[key];
+  if (typeof value !== "boolean") {
+    fail(`"${key}" must be a boolean`);
+  }
+  return value;
+}
+function assertNumber(obj, key) {
+  const value = obj[key];
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    fail(`"${key}" must be a number`);
+  }
+  return value;
+}
+function assertNullableString(obj, key) {
+  const value = obj[key];
+  if (value === null) return null;
+  if (typeof value !== "string") {
+    fail(`"${key}" must be a string or null`);
+  }
+  return value;
+}
+function assertEnum(value, key, allowed) {
+  if (typeof value !== "string" || !allowed.has(value)) {
+    fail(`"${key}" must be one of: ${Array.from(allowed).join(", ")}`);
+  }
+  return value;
+}
+function assertProxyMode(value) {
+  if (value === null) return null;
+  return assertEnum(value, "proxyMode", allowedProxyModes);
+}
+function parseTypesConfig(value) {
+  if (value === null) return null;
+  const obj = assertObject(value, "types");
+  const enabled = assertBoolean(obj, "enabled");
+  const output = assertString(obj, "output");
+  const openapiPath = assertString(obj, "openapiPath");
+  const routesPath = assertString(obj, "routesPath");
+  const pagePropsPath = assertString(obj, "pagePropsPath");
+  const generateZod = assertBoolean(obj, "generateZod");
+  const generateSdk = assertBoolean(obj, "generateSdk");
+  const generateRoutes = assertBoolean(obj, "generateRoutes");
+  const generatePageProps = assertBoolean(obj, "generatePageProps");
+  const globalRoute = assertBoolean(obj, "globalRoute");
+  return {
+    enabled,
+    output,
+    openapiPath,
+    routesPath,
+    pagePropsPath,
+    generateZod,
+    generateSdk,
+    generateRoutes,
+    generatePageProps,
+    globalRoute
+  };
+}
+function parseLogging(value) {
+  if (value === null) return null;
+  const obj = assertObject(value, "logging");
+  const level = assertEnum(obj.level, "logging.level", allowedLogLevels);
+  const showPathsAbsolute = assertBoolean(obj, "showPathsAbsolute");
+  const suppressNpmOutput = assertBoolean(obj, "suppressNpmOutput");
+  const suppressViteBanner = assertBoolean(obj, "suppressViteBanner");
+  const timestamps = assertBoolean(obj, "timestamps");
+  return { level, showPathsAbsolute, suppressNpmOutput, suppressViteBanner, timestamps };
+}
+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}"`);
+    }
+  }
+  const assetUrl = assertString(obj, "assetUrl");
+  const bundleDir = assertString(obj, "bundleDir");
+  const resourceDir = assertString(obj, "resourceDir");
+  const staticDir = assertString(obj, "staticDir");
+  const hotFile = assertString(obj, "hotFile");
+  const manifest = assertString(obj, "manifest");
+  const mode = assertEnum(obj.mode, "mode", allowedModes);
+  const proxyMode = assertProxyMode(obj.proxyMode);
+  const host = assertString(obj, "host");
+  const port = assertNumber(obj, "port");
+  const ssrEnabled = assertBoolean(obj, "ssrEnabled");
+  const ssrOutDir = assertNullableString(obj, "ssrOutDir");
+  const types = parseTypesConfig(obj.types);
+  const executor = assertEnum(obj.executor, "executor", allowedExecutors);
+  const logging = parseLogging(obj.logging);
+  const litestarVersion = assertString(obj, "litestarVersion");
+  return {
+    assetUrl,
+    bundleDir,
+    resourceDir,
+    staticDir,
+    hotFile,
+    manifest,
+    mode,
+    proxyMode,
+    host,
+    port,
+    ssrEnabled,
+    ssrOutDir,
+    types,
+    executor,
+    logging,
+    litestarVersion
+  };
+}
+function readBridgeConfig(explicitPath) {
+  const envPath = explicitPath ?? process.env.LITESTAR_VITE_CONFIG_PATH;
+  if (envPath) {
+    if (!fs.existsSync(envPath)) {
+      return null;
+    }
+    return readBridgeConfigFile(envPath);
+  }
+  const defaultPath = path.join(process.cwd(), ".litestar.json");
+  if (fs.existsSync(defaultPath)) {
+    return readBridgeConfigFile(defaultPath);
+  }
+  return null;
+}
+function readBridgeConfigFile(filePath) {
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    fail(`failed to parse JSON (${msg})`);
+  }
+  return parseBridgeSchema(raw);
+}
+export {
+  parseBridgeSchema,
+  readBridgeConfig
+};

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

@@ -0,0 +1,4 @@
+/**
+ * Generate `page-props.ts` from `inertia-pages.json` metadata.
+ */
+export declare function emitPagePropsTypes(pagesPath: string, outputDir: string): Promise<void>;

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

@@ -0,0 +1,268 @@
+import fs from "node:fs";
+import path from "node:path";
+async function emitPagePropsTypes(pagesPath, outputDir) {
+  const contents = await fs.promises.readFile(pagesPath, "utf-8");
+  const json = JSON.parse(contents);
+  const outDir = path.resolve(process.cwd(), outputDir);
+  await fs.promises.mkdir(outDir, { recursive: true });
+  const outFile = path.join(outDir, "page-props.ts");
+  const { includeDefaultAuth, includeDefaultFlash } = json.typeGenConfig;
+  const typeImportPaths = json.typeImportPaths ?? {};
+  const fallbackType = json.fallbackType ?? "unknown";
+  const defaultFallback = fallbackType === "any" ? "Record<string, any>" : "Record<string, unknown>";
+  let userTypes = "";
+  let authTypes = "";
+  let flashTypes = "";
+  if (includeDefaultAuth) {
+    userTypes = `/**
+ * Default User interface - minimal baseline for common auth patterns.
+ * Users extend this via module augmentation with their full user model.
+ *
+ * @example
+ * declare module 'litestar-vite-plugin/inertia' {
+ *   interface User {
+ *     avatarUrl?: string | null
+ *     roles: Role[]
+ *     teams: Team[]
+ *   }
+ * }
+ */
+export interface User {
+  id: string
+  email: string
+  name?: string | null
+}
+
+`;
+    authTypes = `/**
+ * Default AuthData interface - mirrors Laravel Jetstream pattern.
+ * isAuthenticated + optional user is the universal pattern.
+ */
+export interface AuthData {
+  isAuthenticated: boolean
+  user?: User
+}
+
+`;
+  } else {
+    userTypes = `/**
+ * User interface - define via module augmentation.
+ * Default auth types are disabled.
+ *
+ * @example
+ * declare module 'litestar-vite-plugin/inertia' {
+ *   interface User {
+ *     uuid: string
+ *     username: string
+ *   }
+ * }
+ */
+export interface User {}
+
+`;
+    authTypes = `/**
+ * AuthData interface - define via module augmentation.
+ * Default auth types are disabled.
+ */
+export interface AuthData {}
+
+`;
+  }
+  if (includeDefaultFlash) {
+    flashTypes = `/**
+ * Default FlashMessages interface - category to messages mapping.
+ * Standard categories: success, error, info, warning.
+ */
+export interface FlashMessages {
+  [category: string]: string[]
+}
+
+`;
+  } else {
+    flashTypes = `/**
+ * FlashMessages interface - define via module augmentation.
+ * Default flash types are disabled.
+ */
+export interface FlashMessages {}
+
+`;
+  }
+  const defaultGeneratedSharedProps = {
+    errors: { type: "Record<string, string[]>", optional: true },
+    csrf_token: { type: "string", optional: true },
+    ...includeDefaultAuth || includeDefaultFlash ? {
+      auth: { type: "AuthData", optional: true },
+      flash: { type: "FlashMessages", optional: true }
+    } : {}
+  };
+  const generatedSharedProps = Object.keys(json.sharedProps ?? {}).length > 0 ? json.sharedProps : defaultGeneratedSharedProps;
+  const generatedSharedPropLines = Object.entries(generatedSharedProps).sort(([a], [b]) => a.localeCompare(b)).map(([key, def]) => {
+    const optional = def.optional ? "?" : "";
+    const safeKey = /^[$A-Z_][0-9A-Z_$]*$/i.test(key) ? key : JSON.stringify(key);
+    return `  ${safeKey}${optional}: ${def.type}`;
+  });
+  const allCustomTypes = /* @__PURE__ */ new Set();
+  for (const data of Object.values(json.pages)) {
+    if (data.tsType) {
+      allCustomTypes.add(data.tsType);
+    }
+    for (const t of data.customTypes ?? []) {
+      allCustomTypes.add(t);
+    }
+  }
+  const builtinTypes = /* @__PURE__ */ new Set([
+    "any",
+    "unknown",
+    "never",
+    "void",
+    "undefined",
+    "null",
+    "boolean",
+    "string",
+    "number",
+    "bigint",
+    "symbol",
+    "object",
+    "Record",
+    "Partial",
+    "Required",
+    "Readonly",
+    "Pick",
+    "Omit",
+    "Exclude",
+    "Extract",
+    "NonNullable",
+    "Parameters",
+    "ReturnType",
+    "InstanceType",
+    "Uppercase",
+    "Lowercase",
+    "Capitalize",
+    "Uncapitalize",
+    "Promise",
+    "Array",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "Date",
+    "RegExp",
+    "User",
+    "AuthData",
+    "FlashMessages"
+  ]);
+  for (const def of Object.values(generatedSharedProps)) {
+    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)) {
+        allCustomTypes.add(name);
+      }
+    }
+  }
+  const apiTypesPath = path.join(outDir, "api", "types.gen.ts");
+  const availableApiTypes = /* @__PURE__ */ new Set();
+  if (fs.existsSync(apiTypesPath)) {
+    const content = await fs.promises.readFile(apiTypesPath, "utf-8");
+    for (const match of content.matchAll(/export (?:type|interface|enum|class) (\\w+)/g)) {
+      if (match[1]) {
+        availableApiTypes.add(match[1]);
+      }
+    }
+  }
+  const apiImports = [...allCustomTypes].filter((t) => availableApiTypes.has(t)).sort();
+  const remainingTypes = [...allCustomTypes].filter((t) => !availableApiTypes.has(t)).sort();
+  const importsByPath = /* @__PURE__ */ new Map();
+  const unresolvedTypes = [];
+  for (const t of remainingTypes) {
+    const importPath = typeImportPaths[t];
+    if (importPath) {
+      const list = importsByPath.get(importPath) ?? [];
+      list.push(t);
+      importsByPath.set(importPath, list);
+    } else {
+      unresolvedTypes.push(t);
+    }
+  }
+  if (unresolvedTypes.length > 0) {
+    console.warn(`litestar-vite: unresolved Inertia props types: ${unresolvedTypes.join(", ")}. Add them to TypeGenConfig.type_import_paths or include them in OpenAPI.`);
+  }
+  let importStatement = "";
+  if (apiImports.length > 0) {
+    importStatement += `import type { ${apiImports.join(", ")} } from "./api/types.gen"
+`;
+  }
+  const sortedImportPaths = [...importsByPath.keys()].sort();
+  for (const p of sortedImportPaths) {
+    const names = (importsByPath.get(p) ?? []).sort();
+    if (names.length > 0) {
+      importStatement += `import type { ${names.join(", ")} } from "${p}"
+`;
+    }
+  }
+  if (importStatement) {
+    importStatement += "\n";
+  }
+  const pageEntries = [];
+  for (const [component, data] of Object.entries(json.pages)) {
+    const rawType = data.tsType || data.propsType || defaultFallback;
+    const propsType = rawType.includes("|") ? `(${rawType})` : rawType;
+    pageEntries.push(`  "${component}": ${propsType} & FullSharedProps`);
+  }
+  const body = `// AUTO-GENERATED by litestar-vite. Do not edit.
+/* eslint-disable */
+
+${importStatement}${userTypes}${authTypes}${flashTypes}/**
+ * Generated shared props (always present).
+ * Includes built-in props + static config props.
+ */
+export interface GeneratedSharedProps {
+${generatedSharedPropLines.join("\n")}
+}
+
+/**
+ * User-defined shared props for dynamic share() calls in guards/middleware.
+ * Extend this interface via module augmentation.
+ *
+ * @example
+ * declare module 'litestar-vite-plugin/inertia' {
+ *   interface User {
+ *     avatarUrl?: string | null
+ *     roles: Role[]
+ *     teams: Team[]
+ *   }
+ *   interface SharedProps {
+ *     locale?: string
+ *     currentTeam?: CurrentTeam
+ *   }
+ * }
+ */
+export interface SharedProps {
+}
+
+/** Full shared props = generated + user-defined */
+export type FullSharedProps = GeneratedSharedProps & SharedProps
+
+/** Page props mapped by component name */
+export interface PageProps {
+${pageEntries.join("\n")}
+}
+
+/** Component name union type */
+export type ComponentName = keyof PageProps
+
+/** Type-safe props for a specific component */
+export type InertiaPageProps<C extends ComponentName> = PageProps[C]
+
+/** Get props type for a specific page component */
+export type PagePropsFor<C extends ComponentName> = PageProps[C]
+
+// Re-export for module augmentation
+declare module "litestar-vite-plugin/inertia" {
+  export { User, AuthData, FlashMessages, SharedProps, GeneratedSharedProps, FullSharedProps, PageProps, ComponentName, InertiaPageProps, PagePropsFor }
+}
+`;
+  await fs.promises.writeFile(outFile, body, "utf-8");
+}
+export {
+  emitPagePropsTypes
+};

package/dist/js/shared/format-path.d.ts

@@ -11,12 +11,3 @@
  * @returns The path relative to root, or the original path if already relative or on different drive
  */
 export declare function formatPath(absolutePath: string, root?: string): string;
-/**
- * Format multiple paths, joining them with a separator.
- *
- * @param paths - Array of absolute paths to format
- * @param root - The project root directory (defaults to process.cwd())
- * @param separator - Separator between paths (defaults to ", ")
- * @returns Formatted paths joined by separator
- */
-export declare function formatPaths(paths: string[], root?: string, separator?: string): string;

package/dist/js/shared/format-path.js

@@ -15,10 +15,6 @@ function formatPath(absolutePath, root) {
     return absolutePath;
   }
 }
-function formatPaths(paths, root, separator = ", ") {
-  return paths.map((p) => formatPath(p, root)).join(separator);
-}
 export {
-  formatPath,
-  formatPaths
+  formatPath
 };