litestar-vite-plugin 0.27.0 → 0.29.0

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

@@ -13,10 +13,6 @@ export interface LoggingConfig {
     suppressViteBanner: boolean;
     timestamps: boolean;
 }
-/**
- * Default logging configuration.
- */
-export declare const defaultLoggingConfig: LoggingConfig;
 /**
  * Logger instance with configurable behavior.
  */

package/dist/js/shared/logger.js

@@ -54,6 +54,5 @@ function createLogger(config) {
   };
 }
 export {
-  createLogger,
-  defaultLoggingConfig
+  createLogger
 };

package/dist/js/shared/managed-shutdown.d.ts

@@ -0,0 +1,8 @@
+import type { ViteDevServer } from "vite";
+/**
+ * Close a Python-managed Vite sidecar when its stdin pipe reaches EOF.
+ *
+ * @param server - Vite server owned by the Python parent process.
+ * @param markShuttingDown - Optional callback for integration-specific shutdown state.
+ */
+export declare function installManagedShutdown(server: ViteDevServer, markShuttingDown?: () => void): void;

package/dist/js/shared/managed-shutdown.js

@@ -0,0 +1,26 @@
+const installedServers = /* @__PURE__ */ new WeakSet();
+function installManagedShutdown(server, markShuttingDown) {
+  if (process.env.LITESTAR_VITE_MANAGED !== "1" || installedServers.has(server)) {
+    return;
+  }
+  installedServers.add(server);
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    markShuttingDown?.();
+    try {
+      await server.close();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.stdin.on("end", shutdown);
+  process.stdin.on("close", shutdown);
+  process.stdin.resume();
+}
+export {
+  installManagedShutdown
+};

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

@@ -25,9 +25,10 @@ export declare function normalizeHost(host: string): string;
  * Resolve the Litestar dev server port for HMR routing.
  *
  * Framework integrations (Astro/Nuxt/SvelteKit) need this port to set
- * `vite.server.hmr.clientPort` so the browser opens the HMR WebSocket against
- * Litestar — NOT the framework dev server's port — preserving the
- * single-port-via-ASGI contract.
+ * `vite.server.ws.clientPort` on Vite 8.1+ (`vite.server.hmr.clientPort` on
+ * Vite 7 / 8.0) so the browser opens the HMR WebSocket against Litestar — NOT
+ * the framework dev server's port — preserving the single-port-via-ASGI
+ * contract.
  *
  * Resolution order:
  *   1. `bridge.litestarPort` (preferred; written by Python ≥0.23.0).

package/dist/js/shared/typegen-core.d.ts

@@ -53,7 +53,7 @@ export interface TypeGenLogger {
     warn(message: string): void;
     error(message: string): void;
 }
-export interface TypeGenCacheHooks {
+interface TypeGenCacheHooks {
     shouldRunOpenApiTs(openapiPath: string, configPath: string | null, options: {
         generateSdk: boolean;
         generateZod: boolean;
@@ -89,14 +89,6 @@ export declare function resolveDefaultSdkClientPlugin(options: {
  * Find user's openapi-ts config file.
  */
 export declare function findOpenApiTsConfig(projectRoot: string): string | null;
-/**
- * Build the list of plugins for @hey-api/openapi-ts.
- */
-export declare function buildHeyApiPlugins(config: {
-    generateSdk: boolean;
-    generateZod: boolean;
-    sdkClientPlugin: string;
-}): string[];
 /**
  * Resolve the locally installed @hey-api/openapi-ts executable.
  */
@@ -125,3 +117,4 @@ export declare function runHeyApiGeneration(config: TypeGenCoreConfig, configPat
  * @returns Result with generated files and timing info
  */
 export declare function runTypeGeneration(config: TypeGenCoreConfig, options?: RunTypeGenOptions): Promise<TypeGenResult>;
+export {};

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

@@ -201,7 +201,6 @@ async function runTypeGeneration(config, options = {}) {
   return result;
 }
 export {
-  buildHeyApiPlugins,
   findOpenApiTsConfig,
   resolveDefaultSdkClientPlugin,
   resolveHeyApiBin,

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

@@ -28,20 +28,104 @@ export interface TypeGenPluginOptions {
     /** Whether .litestar.json was present (used for buildStart warnings) */
     hasPythonConfig?: boolean;
 }
+/**
+ * Configuration for TypeScript type generation.
+ *
+ * This is the single source of truth for the `types` option across the core Vite plugin and
+ * every framework integration (Astro, Nuxt, SvelteKit), which re-export it under their own
+ * names. Paths default relative to `output`, whose default is framework-specific.
+ *
+ * Type generation works as follows:
+ * 1. Python's Litestar exports openapi.json and routes.json on startup (and reload)
+ * 2. The Vite plugin watches these files for changes
+ * 3. When they change, it runs @hey-api/openapi-ts to generate TypeScript types
+ * 4. An HMR event is sent to notify the client
+ */
 export interface TypesConfigShape {
+    /**
+     * Enable type generation.
+     *
+     * @default false
+     */
     enabled?: boolean;
+    /** Directory for generated TypeScript output. Framework-specific default. */
     output?: string;
+    /**
+     * Path where the OpenAPI schema is exported by Litestar. The plugin watches this file
+     * and runs @hey-api/openapi-ts when it changes.
+     *
+     * @default `${output}/openapi.json`
+     */
     openapiPath?: string;
+    /**
+     * Path where route metadata is exported by Litestar. Watched for route helper generation.
+     *
+     * @default `${output}/routes.json`
+     */
     routesPath?: string;
+    /**
+     * Path where Inertia page props metadata is exported by Litestar.
+     *
+     * @default `${output}/inertia-pages.json`
+     */
     pagePropsPath?: string;
+    /**
+     * Path for the generated `schemas.ts` helper file.
+     *
+     * @default `${output}/schemas.ts`
+     */
     schemasTsPath?: string;
+    /**
+     * Generate Zod schemas in addition to TypeScript types.
+     *
+     * @default false
+     */
     generateZod?: boolean;
+    /**
+     * Generate a typed SDK client in addition to types.
+     *
+     * @default true
+     */
     generateSdk?: boolean;
+    /**
+     * Generate typed `routes.ts` from routes.json metadata. Mirrors Python
+     * `TypeGenConfig.generate_routes`.
+     *
+     * @default true
+     */
     generateRoutes?: boolean;
+    /**
+     * Generate Inertia page props types from inertia-pages.json metadata. Mirrors Python
+     * `TypeGenConfig.generate_page_props`.
+     *
+     * @default true
+     */
     generatePageProps?: boolean;
+    /**
+     * Generate `schemas.ts` with ergonomic form/response type helpers, such as
+     * `FormInput<'api:login'>` and `FormResponse<'api:login', 201>`.
+     *
+     * @default true
+     */
     generateSchemas?: boolean;
+    /**
+     * Register the generated `route()` function on `window`, similar to Laravel's Ziggy,
+     * so it can be used without an import.
+     *
+     * @default false
+     */
     globalRoute?: boolean;
+    /**
+     * Fail Vite when type generation fails. Defaults to `true` during `vite build` and
+     * `false` during `vite serve`.
+     */
     failOnError?: boolean;
+    /**
+     * Debounce window in milliseconds for regeneration, so a burst of file writes triggers
+     * a single run.
+     *
+     * @default 300
+     */
     debounce?: number;
 }
 export interface ResolveTypesConfigOptions {

package/dist/js/shared/vite-compat.d.ts

@@ -1,7 +1,3 @@
-/** Parsed major version of the running Vite instance. */
-export declare const viteMajor: number;
-/** Parsed minor version of the running Vite instance. */
-export declare const viteMinor: number;
 /**
  * Whether the running Vite version is 8+, which uses Rolldown and exposes
  * `build.rolldownOptions` in place of Vite 7's `build.rollupOptions`.

package/dist/js/shared/vite-compat.js

@@ -26,7 +26,5 @@ export {
   hmrServerConfig,
   isVite81Plus,
   isVite8Plus,
-  resolveUserBuildInput,
-  viteMajor,
-  viteMinor
+  resolveUserBuildInput
 };

package/dist/js/svelte/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Svelte stores for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { type EventStreamOptions, type QueueEventStreamOptions, type StreamGap } from "litestar-vite-plugin/helpers";
+import { type Readable } from "svelte/store";
+export interface EventStreamStoreState<TFrame> {
+    healthy: boolean;
+    lastEvent: TFrame | null;
+    lastGap: StreamGap | null;
+    events: TFrame[];
+}
+export type SvelteEventStreamOptions<TFrame> = EventStreamOptions<TFrame> & {
+    bufferSize?: number;
+};
+export type SvelteQueueEventStreamOptions<TFrame> = QueueEventStreamOptions<TFrame> & {
+    bufferSize?: number;
+};
+/**
+ * Create a readable store backed by a generic event stream.
+ */
+export declare function createEventStreamStore<TFrame = unknown>(options: SvelteEventStreamOptions<TFrame>): Readable<EventStreamStoreState<TFrame>>;
+/**
+ * Create a readable store backed by a Litestar Queues event stream.
+ */
+export declare function createQueueEventStreamStore<TFrame = unknown>(options: SvelteQueueEventStreamOptions<TFrame>): Readable<EventStreamStoreState<TFrame>>;

package/dist/js/svelte/index.js

@@ -0,0 +1,51 @@
+/**
+ * Svelte stores for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { createEventStream, createQueueEventStream } from "litestar-vite-plugin/helpers";
+import { readable } from "svelte/store";
+function initialState() {
+    return { events: [], healthy: false, lastEvent: null, lastGap: null };
+}
+function createStreamStore(factory, options) {
+    return readable(initialState(), (set) => {
+        let state = initialState();
+        const update = (next) => {
+            state = { ...state, ...next };
+            set(state);
+        };
+        const { bufferSize: _bufferSize, ...streamOptions } = options;
+        const stream = factory({
+            ...streamOptions,
+            onEvent: (frame) => {
+                options.onEvent(frame);
+                const bufferSize = Math.max(0, options.bufferSize ?? 100);
+                const events = bufferSize === 0 ? [] : [...state.events, frame].slice(-bufferSize);
+                update({ events, lastEvent: frame });
+            },
+            onGap: (gap) => {
+                options.onGap?.(gap);
+                update({ lastGap: gap });
+            },
+            onHealthChange: (healthy) => {
+                options.onHealthChange?.(healthy);
+                update({ healthy });
+            },
+        });
+        stream.connect();
+        return () => stream.dispose();
+    });
+}
+/**
+ * Create a readable store backed by a generic event stream.
+ */
+export function createEventStreamStore(options) {
+    return createStreamStore(createEventStream, options);
+}
+/**
+ * Create a readable store backed by a Litestar Queues event stream.
+ */
+export function createQueueEventStreamStore(options) {
+    return createStreamStore(createQueueEventStream, options);
+}

package/dist/js/sveltekit.d.ts

@@ -27,138 +27,22 @@
  *
  * @module
  */
+import { type LitestarIntegrationConfig } from "./shared/integration-config.js";
+import { type TypesConfigShape } from "./shared/typegen-plugin.js";
 /**
- * Configuration for TypeScript type generation in SvelteKit.
+ * Configuration for TypeScript type generation.
+ *
+ * Alias of the shared {@link TypesConfigShape} so every integration accepts an identical
+ * `types` option. Retained as a named export for backwards compatibility.
  */
-export interface SvelteKitTypesConfig {
-    /**
-     * Enable type generation.
-     *
-     * @default false
-     */
-    enabled?: boolean;
-    /**
-     * Path to output generated TypeScript types.
-     * Relative to the SvelteKit project root.
-     *
-     * @default 'src/lib/generated'
-     */
-    output?: string;
-    /**
-     * Path where the OpenAPI schema is exported by Litestar.
-     *
-     * @default `${output}/openapi.json`
-     */
-    openapiPath?: string;
-    /**
-     * Path where route metadata is exported by Litestar.
-     *
-     * @default `${output}/routes.json`
-     */
-    routesPath?: string;
-    /**
-     * Optional path for the generated schemas.ts helper file.
-     *
-     * @default `${output}/schemas.ts`
-     */
-    schemasTsPath?: string;
-    /**
-     * Path where Inertia page props metadata is exported by Litestar.
-     *
-     * @default `${output}/inertia-pages.json`
-     */
-    pagePropsPath?: string;
-    /**
-     * Generate Zod schemas in addition to TypeScript types.
-     *
-     * @default false
-     */
-    generateZod?: boolean;
-    /**
-     * Generate SDK client functions for API calls.
-     *
-     * @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;
-    /**
-     * Generate schemas.ts with ergonomic form/response type helpers.
-     *
-     * @default true
-     */
-    generateSchemas?: boolean;
-    /**
-     * Register route() globally on window object.
-     *
-     * @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.
-     *
-     * @default 300
-     */
-    debounce?: number;
-}
+export type SvelteKitTypesConfig = TypesConfigShape;
 /**
- * Configuration options for the Litestar SvelteKit integration.
+ * Configuration options for the Litestar integration.
+ *
+ * Alias of the shared {@link LitestarIntegrationConfig}. Retained as a named export for
+ * backwards compatibility.
  */
-export interface LitestarSvelteKitConfig {
-    /**
-     * URL of the Litestar API backend for proxying requests during development.
-     *
-     * @example 'http://localhost:8000'
-     * @default 'http://localhost:8000'
-     */
-    apiProxy?: string;
-    /**
-     * API route prefix to proxy to the Litestar backend.
-     * Requests matching this prefix will be forwarded to the apiProxy URL.
-     *
-     * @example '/api'
-     * @default '/api'
-     */
-    apiPrefix?: string;
-    /**
-     * Enable and configure TypeScript type generation.
-     *
-     * When set to `true`, enables type generation with default settings.
-     * When set to a SvelteKitTypesConfig object, enables type generation with custom settings.
-     *
-     * @default false
-     */
-    types?: boolean | SvelteKitTypesConfig;
-    /**
-     * Enable verbose logging for debugging.
-     *
-     * @default false
-     */
-    verbose?: boolean;
-    /**
-     * JavaScript runtime executor for package commands.
-     * Used when running tools like @hey-api/openapi-ts.
-     *
-     * @default undefined (uses LITESTAR_VITE_RUNTIME env or 'node')
-     */
-    executor?: "node" | "bun" | "deno" | "yarn" | "pnpm";
-}
+export type LitestarSvelteKitConfig = LitestarIntegrationConfig;
 /**
  * Litestar integration plugin for SvelteKit.
  *

package/dist/js/sveltekit.js

@@ -1,63 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import colors from "picocolors";
-import { readBridgeConfig } from "./shared/bridge-schema.js";
-import { normalizeHost, resolveHotFilePath, resolveLitestarPort } from "./shared/network.js";
-import { createLitestarTypeGenPlugin, resolveTypesConfig } from "./shared/typegen-plugin.js";
+import { resolveIntegrationConfig } from "./shared/integration-config.js";
+import { installManagedShutdown } from "./shared/managed-shutdown.js";
+import { normalizeHost } from "./shared/network.js";
+import { createLitestarTypeGenPlugin } from "./shared/typegen-plugin.js";
 import { hmrServerConfig } from "./shared/vite-compat.js";
 function resolveConfig(config = {}) {
-  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);
-    if (Number.isNaN(port)) {
-      port = void 0;
-    }
-  }
-  let pythonExecutor;
-  let assetUrl;
-  let litestarPort;
-  const runtime = readBridgeConfig();
-  if (runtime) {
-    hasPythonConfig = true;
-    const hot = runtime.hotFile;
-    hotFile = resolveHotFilePath(runtime.bundleDir, hot);
-    proxyMode = runtime.proxyMode;
-    port = runtime.port;
-    pythonExecutor = runtime.executor;
-    assetUrl = runtime.assetUrl;
-    if (runtime.types) {
-      pythonTypesConfig = runtime.types;
-    }
-  }
-  const resolvedLitestarPort = resolveLitestarPort(runtime?.litestarPort, runtime?.appUrl);
-  if (resolvedLitestarPort !== null) {
-    litestarPort = resolvedLitestarPort;
-  }
-  const typesConfig = resolveTypesConfig({
-    requested: config.types,
-    pythonConfig: pythonTypesConfig ?? void 0,
-    defaultOutput: "src/lib/generated",
-    mergePythonWhenTrue: true,
-    mergePythonForObject: true
-  });
-  return {
-    apiProxy: config.apiProxy ?? "http://localhost:8000",
-    apiPrefix: config.apiPrefix ?? "/api",
-    types: typesConfig,
-    verbose: config.verbose ?? false,
-    hotFile,
-    proxyMode,
-    port,
-    litestarPort,
-    assetUrl,
-    executor: config.executor ?? pythonExecutor,
-    hasPythonConfig
-  };
+  return resolveIntegrationConfig(config, "src/lib/generated");
 }
 function litestarSvelteKit(userConfig = {}) {
   const config = resolveConfig(userConfig);
@@ -97,6 +47,7 @@ function litestarSvelteKit(userConfig = {}) {
       };
     },
     configureServer(server) {
+      installManagedShutdown(server);
       if (config.verbose) {
         server.middlewares.use((req, _res, next) => {
           if (req.url?.startsWith(config.apiPrefix)) {

package/dist/js/vue/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Vue bindings for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { type EventStreamOptions, type QueueEventStreamOptions, type StreamGap } from "litestar-vite-plugin/helpers";
+import { type MaybeRefOrGetter, type Ref, type ShallowRef } from "vue";
+export interface VueEventStreamState<TFrame> {
+    healthy: Ref<boolean>;
+    lastEvent: ShallowRef<TFrame | null>;
+    lastGap: ShallowRef<StreamGap | null>;
+    events: ShallowRef<TFrame[]>;
+}
+export type VueEventStreamOptions<TFrame> = EventStreamOptions<TFrame> & {
+    key: MaybeRefOrGetter<string>;
+    bufferSize?: number;
+};
+export type VueQueueEventStreamOptions<TFrame> = QueueEventStreamOptions<TFrame> & {
+    key: MaybeRefOrGetter<string>;
+    bufferSize?: number;
+};
+/**
+ * Subscribe a Vue scope to a generic event stream.
+ */
+export declare function useEventStream<TFrame = unknown>(options: VueEventStreamOptions<TFrame>): VueEventStreamState<TFrame>;
+/**
+ * Subscribe a Vue scope to a Litestar Queues event stream.
+ */
+export declare function useQueueEventStream<TFrame = unknown>(options: VueQueueEventStreamOptions<TFrame>): VueEventStreamState<TFrame>;

package/dist/js/vue/index.js

@@ -0,0 +1,57 @@
+/**
+ * Vue bindings for generic and Litestar Queues event streams.
+ *
+ * @module
+ */
+import { createEventStream, createQueueEventStream } from "litestar-vite-plugin/helpers";
+import { onMounted, onScopeDispose, ref, shallowRef, toValue, watch } from "vue";
+function useStream(factory, options) {
+    const healthy = ref(false);
+    const lastEvent = shallowRef(null);
+    const lastGap = shallowRef(null);
+    const events = shallowRef([]);
+    let stream = null;
+    const stop = () => {
+        stream?.dispose();
+        stream = null;
+    };
+    const start = () => {
+        stop();
+        healthy.value = false;
+        const { bufferSize: _bufferSize, key: _key, ...streamOptions } = options;
+        stream = factory({
+            ...streamOptions,
+            onEvent: (frame) => {
+                options.onEvent(frame);
+                lastEvent.value = frame;
+                const bufferSize = Math.max(0, options.bufferSize ?? 100);
+                events.value = bufferSize === 0 ? [] : [...events.value, frame].slice(-bufferSize);
+            },
+            onGap: (gap) => {
+                options.onGap?.(gap);
+                lastGap.value = gap;
+            },
+            onHealthChange: (value) => {
+                options.onHealthChange?.(value);
+                healthy.value = value;
+            },
+        });
+        stream.connect();
+    };
+    onMounted(start);
+    watch(() => [toValue(options.key), options.transport ?? "websocket"], () => start());
+    onScopeDispose(stop);
+    return { events, healthy, lastEvent, lastGap };
+}
+/**
+ * Subscribe a Vue scope to a generic event stream.
+ */
+export function useEventStream(options) {
+    return useStream(createEventStream, options);
+}
+/**
+ * Subscribe a Vue scope to a Litestar Queues event stream.
+ */
+export function useQueueEventStream(options) {
+    return useStream(createQueueEventStream, options);
+}