@kasperrt/smolter 0.2.0 → 0.3.0

package/dist/react/resources/components.js

@@ -0,0 +1,239 @@
+import { Component, createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region .generated/react/resources/components.tsx
+var RouterContext = createContext(null);
+var RouteContext = createContext(null);
+var FormContext = createContext(null);
+function RouterProvider({ children, initialMatches = EMPTY_MATCHES, router }) {
+	useEffect(() => {
+		for (const match of initialMatches) router.load(match.routeId, match.params ?? {});
+		return () => router.dispose();
+	}, [initialMatches, router]);
+	return /* @__PURE__ */ jsx(RouterContext.Provider, {
+		value: router,
+		children
+	});
+}
+function Route({ children, params = {}, persistent = false, routeId }) {
+	const router = useRouter();
+	const stableParams = useStableParams(params);
+	const state = useRouteState(routeId, stableParams, true);
+	const route = router.getRoute(routeId);
+	const retry = useCallback(() => void router.retry(routeId, stableParams), [
+		routeId,
+		router,
+		stableParams
+	]);
+	const contextValue = useMemo(() => ({
+		params: stableParams,
+		routeId
+	}), [routeId, stableParams]);
+	useEffect(() => {
+		if (persistent) router.persist(routeId, stableParams);
+	}, [
+		persistent,
+		routeId,
+		router,
+		stableParams
+	]);
+	let content = children;
+	if (children === void 0 && route?.default) {
+		const RouteComponent = route.default;
+		content = /* @__PURE__ */ jsx(RouteComponent, {});
+	}
+	if (state.unexpectedError && route?.ErrorBoundary) {
+		const ErrorBoundary = route.ErrorBoundary;
+		content = /* @__PURE__ */ jsx(ErrorBoundary, { retry });
+	}
+	if (!state.unexpectedError && !state.loaderInitialized && route?.HydrateFallback) {
+		const HydrateFallback = route.HydrateFallback;
+		content = /* @__PURE__ */ jsx(HydrateFallback, {});
+	}
+	return /* @__PURE__ */ jsx(RouteContext.Provider, {
+		value: contextValue,
+		children: /* @__PURE__ */ jsx(RenderErrorBoundary, {
+			onRetry: retry,
+			resetKey: `${routeId}:${JSON.stringify(stableParams)}`,
+			...route?.ErrorBoundary ? { fallback: route.ErrorBoundary } : {},
+			children: content
+		})
+	});
+}
+function useLoaderData() {
+	const route = useCurrentRoute();
+	return useRouteLoaderData(route.routeId, route.params);
+}
+function useRouteLoaderData(routeId, params = {}) {
+	return useRouteState(routeId, useStableParams(params), true).loaderData;
+}
+function useActionData() {
+	const route = useCurrentRoute();
+	return useRouteState(route.routeId, route.params, false).actionData;
+}
+function useNavigation() {
+	const route = useCurrentRoute();
+	return { state: useRouteState(route.routeId, route.params, false).navigationState };
+}
+function useRevalidator() {
+	const route = useCurrentRoute();
+	const router = useRouter();
+	const state = useRouteState(route.routeId, route.params, false);
+	return useMemo(() => ({
+		revalidate: () => router.load(route.routeId, route.params, true),
+		state: state.navigationState === "loading" ? "loading" : "idle"
+	}), [
+		route,
+		router,
+		state.navigationState
+	]);
+}
+function Form({ action, children, input, params }) {
+	const currentRoute = useContext(RouteContext);
+	const router = useRouter();
+	const routeId = action ?? currentRoute?.routeId ?? "";
+	const routeParams = useStableParams(params ?? currentRoute?.params ?? {});
+	const submit = useCallback((override) => router.submit(routeId, override === void 0 ? input : override, routeParams), [
+		input,
+		routeId,
+		routeParams,
+		router
+	]);
+	if (!routeId) throw new Error("Form requires an action or a parent Route.");
+	return /* @__PURE__ */ jsx(FormContext.Provider, {
+		value: submit,
+		children
+	});
+}
+function useSubmit() {
+	const submit = useContext(FormContext);
+	if (!submit) throw new Error("useSubmit must be used inside Form.");
+	return submit;
+}
+function useFetcher(options = {}) {
+	const currentRoute = useContext(RouteContext);
+	const router = useRouter();
+	const routeId = options.routeId ?? currentRoute?.routeId ?? "";
+	const params = useStableParams(options.params ?? currentRoute?.params ?? {});
+	const [data, setData] = useState(null);
+	const [error, setError] = useState("");
+	const [state, setState] = useState("idle");
+	const controller = useRef(null);
+	useEffect(() => () => {
+		controller.current?.abort();
+	}, []);
+	const run = useCallback(async (mutating, input, target) => {
+		controller.current?.abort();
+		const nextController = new AbortController();
+		const { signal } = nextController;
+		const targetId = target.routeId ?? routeId;
+		const targetParams = target.params ?? params;
+		controller.current = nextController;
+		setError("");
+		setState(mutating ? "submitting" : "loading");
+		const result = await (mutating ? router.fetchAction(targetId, input, targetParams, signal) : router.fetchLoader(targetId, targetParams, signal));
+		if (signal.aborted) return result;
+		controller.current = null;
+		setData(result.data);
+		setError(result.error);
+		setState("idle");
+		if (result.unexpected && currentRoute) router.reportUnexpected(currentRoute.routeId, currentRoute.params);
+		return result;
+	}, [
+		currentRoute,
+		params,
+		routeId,
+		router
+	]);
+	const submit = useCallback((input, target = {}) => run(true, input, target), [run]);
+	const load = useCallback((target = {}) => run(false, void 0, target), [run]);
+	const BoundForm = useCallback(({ children, input }) => /* @__PURE__ */ jsx(FormContext.Provider, {
+		value: (override) => submit(override === void 0 ? input : override),
+		children
+	}), [submit]);
+	if (!routeId) throw new Error("useFetcher requires a routeId or a parent Route.");
+	return [useMemo(() => ({
+		data,
+		error,
+		state
+	}), [
+		data,
+		error,
+		state
+	]), useMemo(() => ({
+		Form: BoundForm,
+		load,
+		submit
+	}), [
+		BoundForm,
+		load,
+		submit
+	])];
+}
+function useRouter() {
+	const router = useContext(RouterContext);
+	if (!router) throw new Error("RouterProvider is missing.");
+	return router;
+}
+function useCurrentRoute() {
+	const route = useContext(RouteContext);
+	if (!route) throw new Error("This hook requires a parent Route.");
+	return route;
+}
+function useRouteState(routeId, params, loadOnMount) {
+	const router = useRouter();
+	const subscribe = useCallback((listener) => router.subscribe(routeId, params, listener), [
+		params,
+		routeId,
+		router
+	]);
+	const getSnapshot = useCallback(() => router.getSnapshot(routeId, params), [
+		params,
+		routeId,
+		router
+	]);
+	const state = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+	useEffect(() => {
+		if (loadOnMount) router.load(routeId, params);
+	}, [
+		loadOnMount,
+		params,
+		routeId,
+		router
+	]);
+	return state;
+}
+function useStableParams(params) {
+	const key = JSON.stringify(Object.entries(params).sort(([left], [right]) => left.localeCompare(right)));
+	const ref = useRef({
+		key,
+		value: params
+	});
+	if (ref.current.key !== key) ref.current = {
+		key,
+		value: params
+	};
+	return ref.current.value;
+}
+var RenderErrorBoundary = class extends Component {
+	state = { error: null };
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	componentDidUpdate(previousProps) {
+		if (this.state.error && previousProps.resetKey !== this.props.resetKey) this.setState({ error: null });
+	}
+	render() {
+		if (this.state.error && this.props.fallback) {
+			const ErrorBoundary = this.props.fallback;
+			return /* @__PURE__ */ jsx(ErrorBoundary, { retry: () => {
+				this.setState({ error: null });
+				this.props.onRetry();
+			} });
+		}
+		if (this.state.error) throw this.state.error;
+		return this.props.children;
+	}
+};
+var EMPTY_MATCHES = [];
+//#endregion
+export { Form, Route, RouterProvider, useActionData, useFetcher, useLoaderData, useNavigation, useRevalidator, useRouteLoaderData, useRouter, useSubmit };

package/dist/{internal/react → react}/routes.d.ts

@@ -3,7 +3,7 @@
  * @module
  */
 import type { RouteModule } from "../core/index.ts";
-import type { ComponentType, ReactNode } from "./runtime.ts";
+import { type ComponentType, type ReactNode } from "./runtime.ts";
 /** Renderable route module with optional loading and error components. */
 export interface ViewModule extends RouteModule {
     default?: ComponentType;

package/dist/react/routes.js

@@ -0,0 +1,12 @@
+import { createElement, useMemo } from "./runtime.js";
+import { useRouter, useSnapshot } from "./context.js";
+//#region .generated/react/routes.ts
+/** Renders the first matching registered module. */
+function Routes({ fallback }) {
+	const router = useRouter();
+	const state = useSnapshot();
+	const component = router.routes.find((route) => route.path === state.path)?.[state.error ? "ErrorBoundary" : state.state === "loading" && !state.loaded ? "HydrateFallback" : "default"];
+	return useMemo(() => component && createElement(component, { error: state.error }), [component, state.error]) ?? state.error?.message ?? fallback;
+}
+//#endregion
+export { Routes };

package/dist/react/runtime.js

@@ -0,0 +1 @@
+export { createContext, createElement, useContext, useEffect, useMemo, useSyncExternalStore } from "react";

package/dist/server/application.d.ts

@@ -0,0 +1,4 @@
+/** @jsxImportSource preact */
+import type { AppRoute, RootModule } from "../preact/route-types.ts";
+export declare function renderApplication(request: Request, routes: AppRoute[], rootModule: RootModule, entry: string): Promise<Response>;
+export declare function dispatchRoute(request: Request, routes: AppRoute[], document?: boolean): Promise<Response>;

package/dist/server/application.js

@@ -0,0 +1,119 @@
+import { matchRoutes } from "../core/match.js";
+import { createDataRouter } from "../core/router.js";
+import { normalizeResult, resolveData } from "../core/responses.js";
+import { RouterApplication, prepareRoutes } from "../preact/router.js";
+import { loadRouter } from "./index.js";
+import { jsx } from "preact/jsx-runtime";
+import { renderToStringAsync } from "preact-render-to-string";
+//#region .generated/server/application.tsx
+/** @jsxImportSource preact */
+async function renderApplication(request, routes, rootModule, entry) {
+	routes = routes.map((route) => ({
+		...route,
+		path: route.routePath ?? route.path
+	}));
+	const match = matchRoutes(routes, new URL(request.url).pathname);
+	if (match && !match.route.default) return dispatchRoute(request, routes, true);
+	let actionResponse;
+	let actionData;
+	if (request.method !== "GET" && request.method !== "HEAD") {
+		actionResponse = await dispatchRoute(request, routes, true);
+		if (actionResponse.headers.has("Location") || !actionResponse.headers.get("Content-Type")?.includes("application/json")) return actionResponse;
+		actionData = await normalizeResult(await actionResponse.json());
+	}
+	const root = await resolveData(await rootModule.loader?.({
+		request,
+		params: {},
+		signal: request.signal
+	}));
+	let redirectResponse;
+	const prepared = prepareRoutes(routes.map((route) => ({
+		...route,
+		ErrorBoundary: route.ErrorBoundary ?? rootModule.ErrorBoundary
+	}))).map((route) => {
+		if (!route.loader) return route;
+		const loader = route.loader;
+		return {
+			...route,
+			loader: async (args) => {
+				const value = await loader(args);
+				if (value instanceof Response && value.headers.has("Location")) redirectResponse = value;
+				return value;
+			}
+		};
+	});
+	let router = await loadRouter(prepared, request);
+	if (redirectResponse) {
+		router.dispose();
+		return redirectResponse;
+	}
+	if (actionResponse) {
+		const hydrationData = {
+			...router.getSnapshot(),
+			actionData: actionData instanceof Error ? void 0 : actionData,
+			...actionData instanceof Error && { error: actionData }
+		};
+		router.dispose();
+		router = createDataRouter(router.routes, { hydrationData });
+	}
+	const snapshot = router.getSnapshot();
+	const html = await renderToStringAsync(/* @__PURE__ */ jsx(RouterApplication, {
+		router,
+		routes,
+		root,
+		rootModule,
+		entry,
+		document: true
+	}));
+	router.dispose();
+	const headers = new Headers(actionResponse?.headers);
+	headers.delete("Content-Length");
+	headers.delete("Content-Encoding");
+	headers.set("Content-Type", "text/html; charset=utf-8");
+	headers.set("Cache-Control", "no-store");
+	return new Response(`<!doctype html>${html}`, {
+		status: snapshot.error ? Number("status" in snapshot.error ? snapshot.error.status : 500) : actionResponse?.status ?? 200,
+		headers
+	});
+}
+async function dispatchRoute(request, routes, document = false) {
+	const match = matchRoutes(routes.map((route) => ({
+		...route,
+		path: route.routePath ?? route.path
+	})), new URL(request.url).pathname);
+	if (!match) return Response.json({ error: "No route" }, { status: 404 });
+	const handler = request.method === "GET" || request.method === "HEAD" ? match.route.loader : match.route.action;
+	if (!handler) return Response.json({ error: "No handler" }, { status: 405 });
+	const value = await Promise.resolve().then(() => handler({
+		request,
+		params: match.params,
+		signal: request.signal
+	})).then((result) => result, (error) => error);
+	if (value instanceof Response) {
+		const location = value.headers.get("Location");
+		if (document) return value;
+		if (!location) {
+			if (value.ok) return value;
+			return Response.json({ __routeError: {
+				message: await value.text(),
+				status: value.status,
+				statusText: value.statusText
+			} });
+		}
+		const headers = new Headers(value.headers);
+		headers.delete("Location");
+		headers.set("X-Smolter-Redirect", location);
+		return new Response(null, { headers });
+	}
+	if (value instanceof Error) return Response.json({ __routeError: {
+		...value,
+		message: value.message
+	} });
+	if (value && typeof value === "object" && "__routeData" in value) {
+		const result = value;
+		return Response.json(await resolveData(result.value), document ? result.init : { headers: result.init.headers });
+	}
+	return Response.json(await normalizeResult(value) ?? null);
+}
+//#endregion
+export { dispatchRoute, renderApplication };

package/dist/server/assets.d.ts

@@ -0,0 +1,5 @@
+export interface RouteAssets {
+    path: string;
+    files: string[];
+}
+export declare function routePreloads(routes: RouteAssets[], pathname: string, base: string): string;

package/dist/server/assets.js

@@ -0,0 +1,7 @@
+import { matchRoutes } from "../core/match.js";
+//#region .generated/server/assets.ts
+function routePreloads(routes, pathname, base) {
+	return ((matchRoutes(routes, pathname)?.route)?.files ?? []).map((file) => `<${base.replace(/\/$/, "")}/${file}>; rel=modulepreload`).join(", ");
+}
+//#endregion
+export { routePreloads };

package/dist/server/handler.d.ts

@@ -0,0 +1,19 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/** Server module produced by an application's SSR entrypoint. */
+export interface ServerBuild {
+    default: (request: Request, entry: string) => Response | Promise<Response>;
+    handleDataRequest: (request: Request) => Response | Promise<Response>;
+}
+export interface RequestHandlerOptions {
+    build: ServerBuild;
+    /** Browser entry URL resolved from Vite's production manifest. */
+    entry: string;
+}
+export interface ServerIncomingMessage extends IncomingMessage {
+    /** Express supplies this using the application's trust proxy policy. */
+    protocol?: string;
+    originalUrl?: string;
+}
+export type NextHandler = (error?: unknown) => void;
+/** Node/Express middleware; mount after metrics, tracing and static assets. */
+export declare function createRequestHandler({ build, entry, }: RequestHandlerOptions): (incoming: ServerIncomingMessage, outgoing: ServerResponse, next: NextHandler) => Promise<void>;

package/dist/server/handler.js

@@ -0,0 +1,22 @@
+import { send, webRequest } from "./http.js";
+//#region .generated/server/handler.ts
+/** Node/Express middleware; mount after metrics, tracing and static assets. */
+function createRequestHandler({ build, entry }) {
+	return (incoming, outgoing, next) => {
+		const handle = async () => {
+			const url = new URL(incoming.originalUrl ?? incoming.url ?? "/", "http://local");
+			const dataRequest = url.pathname === "/_smolter";
+			const target = dataRequest ? url.searchParams.get("url") : void 0;
+			if (dataRequest && (!target?.startsWith("/") || new URL(target, "http://local").origin !== "http://local")) {
+				await send(new Response("Invalid route URL", { status: 400 }), outgoing);
+				return;
+			}
+			const request = await webRequest(incoming, outgoing, target ?? void 0);
+			const response = dataRequest ? await build.handleDataRequest(request) : await build.default(request, entry);
+			await send(response, outgoing);
+		};
+		return handle().catch(next);
+	};
+}
+//#endregion
+export { createRequestHandler };

package/dist/server/http.d.ts

@@ -0,0 +1,4 @@
+import type { ServerResponse } from "node:http";
+import type { ServerIncomingMessage } from "./handler.ts";
+export declare function webRequest(incoming: ServerIncomingMessage, outgoing: ServerResponse, target?: string): Promise<Request>;
+export declare function send(response: Response, outgoing: ServerResponse): Promise<void>;

package/dist/server/http.js

@@ -0,0 +1,27 @@
+//#region .generated/server/http.ts
+async function webRequest(incoming, outgoing, target) {
+	const origin = `${incoming.protocol ?? "http"}://${incoming.headers.host}`;
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(incoming.headers)) if (value) headers.set(name, Array.isArray(value) ? value.join(", ") : value);
+	const controller = new AbortController();
+	outgoing.once("close", () => controller.abort());
+	const chunks = [];
+	for await (const chunk of incoming) chunks.push(chunk);
+	return new Request(new URL(target ?? incoming.originalUrl ?? incoming.url ?? "/", origin), {
+		method: incoming.method,
+		headers,
+		signal: controller.signal,
+		...incoming.method !== "GET" && incoming.method !== "HEAD" && { body: new Uint8Array(Buffer.concat(chunks)) }
+	});
+}
+async function send(response, outgoing) {
+	outgoing.statusCode = response.status;
+	response.headers.forEach((value, name) => {
+		if (name !== "set-cookie") outgoing.setHeader(name, value);
+	});
+	const cookies = response.headers.getSetCookie();
+	if (cookies.length) outgoing.setHeader("set-cookie", cookies.map((cookie) => process.env.NODE_ENV === "production" ? cookie : cookie.replace(/; Secure/gi, "")));
+	outgoing.end(new Uint8Array(await response.arrayBuffer()));
+}
+//#endregion
+export { send, webRequest };

package/dist/server/index.js

@@ -0,0 +1,76 @@
+import { safeWrapAsync } from "../core/errors.js";
+import { matchRoutes } from "../core/match.js";
+import { createDataRouter } from "../core/router.js";
+import { serialize } from "../core/serialize.js";
+//#region .generated/server/index.ts
+/**
+* Request-scoped server rendering and HTTP data dispatch.
+* @module
+*/
+/** Create one router per server request, await this, then render the provider. */
+async function loadRouter(routes, input) {
+	const url = typeof input === "string" ? input : input.url;
+	const wrap = (handler) => {
+		if (!handler || typeof input === "string") return handler;
+		return (args) => {
+			const signal = AbortSignal.any([input.signal, args.signal]);
+			const request = new Request(args.request, { signal });
+			input.headers.forEach((value, name) => {
+				if (!request.headers.has(name)) request.headers.set(name, value);
+			});
+			return handler({
+				...args,
+				request,
+				signal
+			});
+		};
+	};
+	const serverRoutes = routes.map((route) => ({
+		...route,
+		clientLoader: void 0,
+		clientAction: void 0,
+		loader: wrap(route.loader),
+		action: wrap(route.action)
+	}));
+	const router = createDataRouter(serverRoutes, { url });
+	await router.navigate(url);
+	const snapshot = router.getSnapshot();
+	if (!snapshot.error && snapshot.data === void 0 && routes.some((route) => route.path === snapshot.path && route.clientLoader && !route.loader)) return createDataRouter(serverRoutes, {
+		url,
+		hydrationData: {
+			...snapshot,
+			loaded: false,
+			state: "loading"
+		}
+	});
+	return router;
+}
+/** Dispatch an HTTP data request to a registered server loader or action. */
+async function handleRequest(routes, request) {
+	const match = matchRoutes(routes, new URL(request.url).pathname);
+	const reading = request.method === "GET";
+	if (!match) return Response.json({ error: "No route" }, { status: 404 });
+	if (!reading && ![
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	].includes(request.method)) return Response.json({ error: "Method not allowed" }, { status: 405 });
+	const handler = reading ? match.route.loader : match.route.action;
+	if (!handler) return Response.json({ error: `No ${reading ? "loader" : "action"}` }, { status: 405 });
+	const result = await safeWrapAsync(() => handler({
+		request,
+		params: match.params,
+		signal: request.signal
+	}));
+	const error = result.error ?? (result.data instanceof Error && result.data);
+	if (error) return Response.json({ error: error.message }, { status: 500 });
+	if (result.data instanceof Response) {
+		const location = result.data.headers.get("Location");
+		if (location) return new Response(null, { headers: { "X-Smolter-Redirect": location } });
+		return result.data;
+	}
+	return Response.json(result.data ?? null, { headers: { "Cache-Control": "no-store" } });
+}
+//#endregion
+export { handleRequest, loadRouter, serialize };

package/dist/server/node.d.ts

@@ -0,0 +1,3 @@
+/** Optional application integration. @module */
+export * from "./handler.ts";
+export * from "./http.ts";

package/dist/server/node.js

@@ -0,0 +1,3 @@
+import { send, webRequest } from "./http.js";
+import { createRequestHandler } from "./handler.js";
+export { createRequestHandler, send, webRequest };

package/dist/server/preact.d.ts

@@ -0,0 +1,3 @@
+/** Preact server rendering and HTTP data dispatch. @module */
+export { dispatchRoute, renderApplication, } from "./application.tsx";
+export * from "./index.ts";

package/dist/server/preact.js

@@ -0,0 +1,4 @@
+import { serialize } from "../core/serialize.js";
+import { handleRequest, loadRouter } from "./index.js";
+import { dispatchRoute, renderApplication } from "./application.js";
+export { dispatchRoute, handleRequest, loadRouter, renderApplication, serialize };

package/dist/vite/application/browser-boundary.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "vite";
+/** Check emitted modules, after tree shaking, rather than import strings. */
+export declare function browserBoundary(): Plugin;

package/dist/vite/application/browser-boundary.js

@@ -0,0 +1,35 @@
+import { builtinModules } from "node:module";
+//#region .generated/vite/application/browser-boundary.ts
+var builtins = new Set(builtinModules.flatMap((id) => [id, `node:${id}`]));
+var forbiddenModules = [
+	/(?:vite-browser-external|__vite-browser-external)/,
+	/\/node_modules\/(?:react|react-dom|react-router|react-router-dom)\//,
+	/\/smolter\/dist\/(?:internal\/)?(?:server|vite|files)\//,
+	/\/smolter\/packages\/(?:server|vite)\/src\//,
+	/\/vite\/dist\/node\//,
+	/\/src\/[^?]*\.server\.[cm]?[jt]sx?(?:\?|$)/
+];
+/** Check emitted modules, after tree shaking, rather than import strings. */
+function browserBoundary() {
+	return {
+		name: "smolter-browser-boundary",
+		apply: "build",
+		applyToEnvironment: (environment) => environment.name === "client",
+		generateBundle(_options, bundle) {
+			for (const output of Object.values(bundle)) {
+				if (output.type !== "chunk") continue;
+				for (const id of [...output.imports, ...output.dynamicImports]) {
+					if (!builtins.has(id)) continue;
+					this.error(`Node builtin in browser chunk ${output.fileName}: ${id}`);
+				}
+				for (const id of Object.keys(output.modules)) {
+					const normalized = id.replaceAll("\\", "/");
+					if (!forbiddenModules.some((pattern) => pattern.test(normalized))) continue;
+					this.error(`Unexpected browser module in ${output.fileName}: ${id}`);
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { browserBoundary };

package/dist/vite/application/lazy-files.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from "vite";
+export declare function lazyFiles(directory: string): Plugin;