@rangojs/router 0.15.1 → 0.17.0

package/dist/types/types/loader-types.d.ts

@@ -23,9 +23,10 @@ import type { RequestScope } from "./request-scope.js";
  *   return await db.cart.get(user.id);
  * });
  *
- * // With typed params:
- * const ProductLoader = createLoader<Product, { slug: string }>(async (ctx) => {
- *   const { slug } = ctx.params;  // slug is typed as string
+ * // createLoader's one type parameter is the data type; params are
+ * // Record<string, string | undefined>:
+ * const ProductLoader = createLoader<Product>(async (ctx) => {
+ *   const { slug } = ctx.params;  // string | undefined
  *   return await db.products.findBySlug(slug);
  * });
  * ```
@@ -213,9 +214,10 @@ export type LoadOptions = {
  *   return await db.cart.get(ctx.get("user").id);
  * });
  *
- * // With typed params:
- * export const ProductLoader = createLoader<Product, { slug: string }>(async (ctx) => {
- *   const { slug } = ctx.params;  // slug is typed as string
+ * // createLoader's one type parameter is the data type; params are
+ * // Record<string, string | undefined>:
+ * export const ProductLoader = createLoader<Product>(async (ctx) => {
+ *   const { slug } = ctx.params;  // string | undefined
  *   return await db.products.findBySlug(slug);
  * });
  *

package/dist/types/urls/response-types.d.ts

@@ -1,18 +1,8 @@
 import type { ContextVar } from "../context-var.js";
-import type { ReverseFunction } from "../reverse.js";
+import type { GlobalReverseFunction } from "../reverse.js";
 import type { DefaultReverseRouteMap, DefaultVars } from "../types/global-namespace.js";
 import type { UseItems, ResponseRouteUseItem } from "../route-types.js";
 import type { RequestScope } from "../types/request-scope.js";
-/**
- * Reverse function for response handler contexts.
- * Global names get autocomplete and param validation from the generated route map.
- * Local `.name` calls are accepted but not validated (scope unknown at type level).
- */
-type ResponseReverseFunction = [DefaultReverseRouteMap] extends [
-    Record<string, string>
-] ? (name: string, params?: Record<string, string>, search?: Record<string, unknown>) => string : ReverseFunction<DefaultReverseRouteMap> & {
-    (name: `.${string}`, params?: Record<string, string>, search?: Record<string, unknown>): string;
-};
 /**
  * Symbol marking a route as a response route (non-RSC).
  * Stored on PathOptions and UrlPatterns to signal the trie to short-circuit.
@@ -56,7 +46,8 @@ export interface ResponseHandlerContext<TParams = Record<string, string>, TEnv =
     params: TParams;
     /** @internal Phantom property for params type invariance. Prevents mounting handlers on wrong routes. */
     readonly _paramCheck?: (params: TParams) => TParams;
-    reverse: ResponseReverseFunction;
+    /** Global route names only; see {@link GlobalReverseFunction}. */
+    reverse: GlobalReverseFunction<DefaultReverseRouteMap>;
     /** Read a variable set by middleware via ctx.set(key, value) or ctx.set(ContextVar, value). */
     get: {
         <T>(contextVar: ContextVar<T>): T | undefined;

package/dist/types/use-loader.d.ts

@@ -2,6 +2,14 @@ import type { LoaderDefinition, LoadOptions } from "./types.js";
 export type LoadFunction<T> = (options?: LoadOptions) => Promise<T>;
 export interface UseLoaderResult<T> {
     data: T;
+    /**
+     * True while this loader family (`loader.$$id`) is in flight: a `load()` /
+     * group refresh, or a held navigation still streaming a re-run of this
+     * loader. Family-keyed, not segment-keyed: a layout `useLoader` of the same
+     * `createLoader` the child route is re-running also reports true, even if
+     * the layout copy is not replaced. Not used for the initial streamed read
+     * (that suspends).
+     */
     isLoading: boolean;
     error: Error | null;
     load: LoadFunction<T>;
@@ -9,6 +17,7 @@ export interface UseLoaderResult<T> {
 }
 export interface UseFetchLoaderResult<T> {
     data: T | undefined;
+    /** Same family-keyed contract as {@link UseLoaderResult.isLoading}. */
     isLoading: boolean;
     error: Error | null;
     load: LoadFunction<T>;
@@ -36,7 +45,7 @@ export interface UseLoaderOptions {
  * @example Basic usage - accessing route loader data
  * ```tsx
  * "use client";
- * import { useLoader } from "rsc-router/client";
+ * import { useLoader } from "@rangojs/router/client";
  * import { CartLoader } from "../loaders/cart";
  *
  * // In route definition: loader(CartLoader)
@@ -67,7 +76,7 @@ export declare function useLoader<T>(loader: LoaderDefinition<T>, options?: UseL
  * @example On-demand fetching
  * ```tsx
  * "use client";
- * import { useFetchLoader } from "rsc-router/client";
+ * import { useFetchLoader } from "@rangojs/router/client";
  * import { SearchLoader } from "../loaders/search";
  *
  * export function SearchResults() {
@@ -121,7 +130,7 @@ export declare function useFetchLoader<T>(loader: LoaderDefinition<T>, options?:
  * @example
  * ```tsx
  * "use client";
- * import { useLoader, useRefreshLoaders } from "rsc-router/client";
+ * import { useLoader, useRefreshLoaders } from "@rangojs/router/client";
  *
  * function Profile() {
  *   const { data } = useLoader(ProfileLoader, { key: userId, refreshGroup: "account" });

package/dist/types/vite/plugins/use-cache-transform.d.ts

@@ -15,6 +15,37 @@
  * - transformWrapExport() for file-level wrapping
  * - transformHoistInlineDirective() for function-level hoisting
  */
-import type { Plugin } from "vite";
+import type { Plugin, Rollup } from "vite";
+import type { Counter } from "../debug.js";
 export declare const USE_CACHE_DIRECTIVE_RE: RegExp;
-export declare function useCacheTransform(): Plugin;
+/**
+ * @param counter `rango:transform` timing counter, created by `rango()`
+ *   (`createCounter` in ../debug.js); omitted when debugging is off.
+ */
+export declare function useCacheTransform(counter?: Counter): Plugin;
+/** Options for {@link transformUseCache}. */
+export interface UseCacheTransformOptions {
+    /** Root the ids are relative to (Vite's `config.root`). */
+    root: string;
+    /** Build ids hash the path (`hashId`); dev ids are `<path>#<export>`. */
+    isBuild: boolean;
+    /** Sink for the near-miss directive warning. */
+    warn: (message: string) => void;
+    /**
+     * Called when `@vitejs/plugin-rsc/transforms` fails to load; the module is
+     * then left unwrapped. The rango plugin omits it (skip silently).
+     */
+    onTransformsError?: (error: unknown) => void;
+}
+/** Whether a module may carry a `"use cache"` directive the transform wraps. */
+export declare function isUseCacheCandidate(code: string, id: string): boolean;
+/**
+ * Wrap a module's `"use cache"` functions with `registerCachedFunction`. The
+ * rango plugin runs it in the rsc environment; `rangoUseCacheTransform()`
+ * (testing/vitest.ts) runs it in a Vitest project, whose environment is `ssr`.
+ * Call it only for an {@link isUseCacheCandidate} module.
+ */
+export declare function transformUseCache(code: string, id: string, options: UseCacheTransformOptions): Promise<{
+    code: string;
+    map: Rollup.ExistingRawSourceMap;
+} | undefined>;

package/dist/types/vite/rango.d.ts

@@ -21,7 +21,7 @@ export { hasUseClientDirective };
  *   plugins: [
  *     react(),
  *     rango({ preset: 'cloudflare' }),
- *     cloudflare({ viteEnvironment: { name: 'rsc' } }),
+ *     cloudflare({ viteEnvironment: { name: 'rsc', childEnvironments: ['ssr'] } }),
  *   ],
  * });
  * ```