@rsc-kit/core 0.18.1 → 0.20.0

package/dist/vite.d.ts

@@ -1,5 +1,6 @@
+import type { PrerenderResult } from "./prerender.js";
 import type { WebManifestOptions } from "./webManifest.js";
-import type { PluginOption } from "vite";
+import type { Plugin, PluginOption } from "vite";
 export interface RscKitOptions {
     /** Project root. Defaults to RSC_PROJECT_ROOT, then cwd. */
     projectRoot?: string;
@@ -17,6 +18,38 @@ export interface RscKitOptions {
      * sent: it names no product, and a CDN rule or a check can key on it.
      */
     identify?: boolean;
+    /**
+     * An OpenAPI document from the route tree, at `/openapi.json`.
+     *
+     * One path per route.ts, one operation per method export, parameters and
+     * request bodies from the route's `params`, `searchParams` and `body`
+     * schemas - a Standard Schema that describes itself as JSON Schema (Zod 4,
+     * ArkType). A route under a middleware.ts gets a security requirement. A
+     * route says the rest about itself with `export const openapi = { summary,
+     * tags, responses }`; the document says its own with `info`, `servers`,
+     * `security`. An api route the build stores, without middleware.
+     *
+     * The page that reads it is Scalar's: `export const GET = ApiReference({
+     * url: '/openapi.json' })` from @scalar/nextjs-api-reference in a route.ts.
+     */
+    openapi?: boolean | {
+        path?: string;
+        info?: {
+            title?: string;
+            version?: string;
+            description?: string;
+        };
+        servers?: {
+            url: string;
+            description?: string;
+        }[];
+        security?: Record<string, string[]>[];
+        components?: Record<string, unknown>;
+        tags?: {
+            name: string;
+            description?: string;
+        }[];
+    };
     /**
      * Unroll named imports from a barrel package on the server, in development.
      *
@@ -290,6 +323,28 @@ export declare const SERVICE_WORKER: (version: string, precache: string[], froze
  * it. The file is a literal object by contract, which is all that has to parse.
  */
 export declare function declaredManifest(appDir: string): WebManifestOptions | null;
+/**
+ * The url a navigation falls back to when nothing else can answer it.
+ *
+ * An ordinary route at /offline, and it has to be one the build STORED — a
+ * page that renders per request cannot be served when there is no request to
+ * be made. So a dynamic /offline is refused as a fallback rather than
+ * precached and found wanting at the one moment it matters, and the build says
+ * which read did it.
+ */
+export declare function offlineFallback(frozen: string[], results: PrerenderResult[]): string | null;
+/**
+ * Whether a public file is worth fetching before it is asked for.
+ *
+ * The precache is what lets the app boot with no network: the scripts, the
+ * stylesheets, the fonts, the manifest and its icons. Everything else in
+ * public/ - an image, a wasm module, the share card - is cached the first
+ * time it is used, which is what the fetch handler does for any hashed
+ * asset. Precaching all of it made an install cost a megabyte before the
+ * visitor had seen a page: 765 kB of it a webp encoder, the rest a png no
+ * browser ever renders.
+ */
+export declare function bootsTheApp(file: string): boolean;
 export declare function smallStylesheetReader(assetsDir: string, setting: "auto" | true | number): (href: string) => string | null;
 /** A server action the bundle registered: where it is and what it is called. */
 export interface KnownAction {
@@ -297,12 +352,25 @@ export interface KnownAction {
     name: string;
     file: string;
 }
+/**
+ * The identifier a route file is imported as in the generated entries.
+ *
+ * One-to-one with the path, which the obvious "replace everything odd with an
+ * underscore" is not: app/agent-account/page and app/agent/account/page
+ * both came out as _c_app_agent_account_page, and the entry declared the
+ * same import twice. A slash is an underscore, because that is what every
+ * alias reads like; anything else that is not a letter or digit - a hyphen,
+ * a dot, the brackets of a param, the parens of a group, an underscore of
+ * its own - is its character code, so no two paths share an alias.
+ */
+export declare function toAlias(name: string): string;
 /**
  * The worker the dev server serves at /sw.js: it removes the one a production
  * run left on this origin, and the caches with it, then reloads each page it
  * was controlling so they load uncontrolled. Nothing else runs in development.
  */
 export declare const DEV_WORKER = "self.addEventListener('install', () => self.skipWaiting())\nself.addEventListener('activate', (event) => {\n  event.waitUntil((async () => {\n    const keys = await caches.keys()\n    await Promise.all(keys.filter((k) => k.startsWith('rsc-kit-')).map((k) => caches.delete(k)))\n    await self.clients.claim()\n    const pages = await self.clients.matchAll({ type: 'window' })\n    await self.registration.unregister()\n    for (const page of pages) page.navigate(page.url).catch(() => {})\n  })())\n})\n";
+export declare function serverRendererInRsc(): Plugin;
 /**
  * The project's typecheck, as part of the build.
  *