@troyio/vite-file-router 0.3.2 → 0.4.1

package/dist/declarations.d.ts

@@ -0,0 +1,9 @@
+import { type Node } from "./scanner";
+export declare const PACKAGE_NAME = "@troyio/vite-file-router";
+/**
+ * Builds a declaration file that registers the discovered page patterns and
+ * loader modules with the package's `Register` interface. The package's
+ * public types read from that interface, so `routePath()` and the typed hooks
+ * only accept routes that exist.
+ */
+export declare function createRouteDeclarations(tree: Node, projectRoot: string, declarationFile: string): string;

package/dist/devtools-app.d.ts

@@ -0,0 +1,59 @@
+import { type RouteMatchResult } from "./devtools";
+import type { RouteManifestNode } from "./scanner";
+/** HMR events the dev-only client in `virtual:routes` sends to the server. */
+export declare const APP_LOCATION_EVENT = "vite-file-router:location";
+export declare const APP_DATA_EVENT = "vite-file-router:data";
+/** An open browser tab running the app, and the route it's on. */
+export type AppTab = {
+    id: string;
+    url: string;
+    title: string;
+    connectedAt: number;
+    updatedAt: number;
+    match: RouteMatchResult;
+};
+export type RouteDataOutcome = "data" | "response" | "redirect" | "error";
+/** One loader, action, or `shouldRevalidate` call reported by the app. */
+export type RouteDataEvent = {
+    /** Increasing number, unique for this dev-server session. */
+    id: number;
+    tabId: string;
+    type: "loader" | "action" | "revalidate";
+    /** React Router route ID, `file-route:` plus the route directory. */
+    routeId: string;
+    url?: string;
+    method?: string;
+    startedAt: number;
+    duration?: number;
+    outcome?: RouteDataOutcome;
+    status?: number;
+    location?: string;
+    message?: string;
+    /** A short JSON preview of returned data. */
+    preview?: string;
+    /** For `revalidate` events: whether the loader runs. */
+    decision?: boolean;
+    defaultShouldRevalidate?: boolean;
+};
+/**
+ * Validates an event from the browser. Anything a page sends over the HMR
+ * channel is untrusted, so only known fields of the expected types are kept.
+ */
+export declare function sanitizeDataEvent(input: unknown, id: number): RouteDataEvent | undefined;
+/**
+ * Tracks the app tabs connected to the dev server and their recent loader
+ * and action calls, and tells the panel when either changes.
+ */
+export declare function createAppTracker(options: {
+    getManifest: () => RouteManifestNode;
+    onTabsChange: (tabs: AppTab[]) => void;
+    onActivity: (event: RouteDataEvent) => void;
+}): {
+    tabs: () => AppTab[];
+    activity: () => RouteDataEvent[];
+    updateLocation(client: object, input: unknown): Promise<void>;
+    disconnect(client: object): void;
+    /** Re-matches every tab, for example after route files change. */
+    rematch(): Promise<void>;
+    record(input: unknown): void;
+};

package/dist/devtools.d.ts

@@ -0,0 +1,50 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteConflict } from "./generator";
+import type { RouteFileKind, RouteManifestNode } from "./scanner";
+export declare const ROUTE_INSPECTOR_PATH = "/__vite-file-router/";
+export declare const ROUTE_INSPECTOR_DATA_PATH = "/__vite-file-router-data";
+export declare const ROUTE_INSPECTOR_EVENTS_PATH = "/__vite-file-router-events";
+export declare const ROUTE_INSPECTOR_MATCH_PATH = "/__vite-file-router-match";
+export type RouteInspectorState = {
+    /** Absolute Vite project root, so the panel can open files in an editor. */
+    projectRoot: string;
+    /** The routes directory, relative to the project root with `/` separators. */
+    directory: string;
+    manifest: RouteManifestNode;
+    conflicts: RouteConflict[];
+};
+export type RouteMatchSegment = {
+    fullPath: string;
+    segment: string | null;
+    routeGroup: boolean;
+    files: Partial<Record<RouteFileKind, string>>;
+};
+export type RouteMatchResult = {
+    matched: false;
+    pathname: string;
+} | {
+    matched: true;
+    pathname: string;
+    params: Record<string, string | undefined>;
+    /** Directory routes from the root down to the matched route. */
+    chain: RouteMatchSegment[];
+    page?: string;
+    notFound?: string;
+    layouts: string[];
+    loaders: string[];
+    loading?: string;
+    error?: string;
+};
+export declare function matchRouteManifest(manifest: RouteManifestNode, url: string): Promise<RouteMatchResult>;
+/** Pushes route state to open DevTools panels over Server-Sent Events. */
+export declare function createRouteEventStream(getState: () => RouteInspectorState, 
+/** Extra events sent to each panel when it connects. */
+getSnapshot?: () => [event: string, data: unknown][]): {
+    clients: Set<ServerResponse<IncomingMessage>>;
+    connect(request: IncomingMessage, response: ServerResponse): void;
+    /** Coalesces bursts of file events (such as a folder rename) into one push. */
+    notify(): void;
+    /** Sends a named event to every connected panel right away. */
+    broadcast(event: string, data: unknown): void;
+    close(): void;
+};

package/dist/generator.d.ts

@@ -1,8 +1,20 @@
 import { type Node } from "./scanner";
+export type GenerateOptions = {
+    /**
+     * Add a client that reports the app's location and its loader and action
+     * calls to the DevTools panel over Vite's HMR channel. Dev server only.
+     */
+    devClient?: boolean;
+};
 export type GeneratedRoutes = {
     imports: string[];
     helpers: string[];
     routes: string;
+    /**
+     * A tree that mirrors `routes`: each node lists the modules a matched route
+     * needs to render, so `preloadRoute()` can import them ahead of navigation.
+     */
+    preloads: string;
 };
 export type RouteConflict = {
     routePath: string;
@@ -13,4 +25,5 @@ export declare class RouteConflictError extends Error {
     constructor(conflicts: RouteConflict[]);
 }
 export declare function findPageRouteConflicts(node: Node, pages?: Map<string, string[]>, segments?: string[], root?: boolean): RouteConflict[];
-export declare function generate(node: Node, root?: boolean, projectRoot?: string): GeneratedRoutes;
+export declare function getRouteId(directory: string, projectRoot: string): string;
+export declare function generate(node: Node, root?: boolean, projectRoot?: string, options?: GenerateOptions): GeneratedRoutes;

package/dist/index.d.ts

@@ -3,6 +3,18 @@ import { type RouteConventions } from "./scanner";
 export type RoutesOptions = {
     directory?: string;
     conventions?: RouteConventions;
+    /**
+     * Where to write the generated route type declarations, relative to the Vite
+     * project root.
+     *
+     * - `"auto"` writes `src/route-types.d.ts`, but only when the project root
+     *   has a `tsconfig.json` or `jsconfig.json`, so JavaScript projects without
+     *   one get no extra file.
+     * - A path ending in `.d.ts` always writes to that path.
+     * - `false` never writes the file.
+     * @default "auto"
+     */
+    dts?: "auto" | string | false;
 };
 export type { RouteConventions, RouteFileKind, RouteManifestNode, } from "./scanner";
 export declare function routes(input?: string | RoutesOptions): Plugin;