npm - @ivogt/rsc-router - Versions diffs - 0.0.0-experimental.1 - Mend

@ivogt/rsc-router 0.0.0-experimental.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (123) hide show

package/README.md +19 -0
package/package.json +131 -0
package/src/__mocks__/version.ts +6 -0
package/src/__tests__/route-definition.test.ts +63 -0
package/src/browser/event-controller.ts +876 -0
package/src/browser/index.ts +18 -0
package/src/browser/link-interceptor.ts +121 -0
package/src/browser/lru-cache.ts +69 -0
package/src/browser/merge-segment-loaders.ts +126 -0
package/src/browser/navigation-bridge.ts +891 -0
package/src/browser/navigation-client.ts +155 -0
package/src/browser/navigation-store.ts +823 -0
package/src/browser/partial-update.ts +545 -0
package/src/browser/react/Link.tsx +248 -0
package/src/browser/react/NavigationProvider.tsx +228 -0
package/src/browser/react/ScrollRestoration.tsx +94 -0
package/src/browser/react/context.ts +53 -0
package/src/browser/react/index.ts +52 -0
package/src/browser/react/location-state-shared.ts +120 -0
package/src/browser/react/location-state.ts +62 -0
package/src/browser/react/use-action.ts +240 -0
package/src/browser/react/use-client-cache.ts +56 -0
package/src/browser/react/use-handle.ts +178 -0
package/src/browser/react/use-link-status.ts +134 -0
package/src/browser/react/use-navigation.ts +150 -0
package/src/browser/react/use-segments.ts +188 -0
package/src/browser/request-controller.ts +149 -0
package/src/browser/rsc-router.tsx +310 -0
package/src/browser/scroll-restoration.ts +324 -0
package/src/browser/server-action-bridge.ts +747 -0
package/src/browser/shallow.ts +35 -0
package/src/browser/types.ts +443 -0
package/src/cache/__tests__/memory-segment-store.test.ts +487 -0
package/src/cache/__tests__/memory-store.test.ts +484 -0
package/src/cache/cache-scope.ts +565 -0
package/src/cache/cf/__tests__/cf-cache-store.test.ts +361 -0
package/src/cache/cf/cf-cache-store.ts +274 -0
package/src/cache/cf/index.ts +19 -0
package/src/cache/index.ts +52 -0
package/src/cache/memory-segment-store.ts +150 -0
package/src/cache/memory-store.ts +253 -0
package/src/cache/types.ts +366 -0
package/src/client.rsc.tsx +88 -0
package/src/client.tsx +609 -0
package/src/components/DefaultDocument.tsx +20 -0
package/src/default-error-boundary.tsx +88 -0
package/src/deps/browser.ts +8 -0
package/src/deps/html-stream-client.ts +2 -0
package/src/deps/html-stream-server.ts +2 -0
package/src/deps/rsc.ts +10 -0
package/src/deps/ssr.ts +2 -0
package/src/errors.ts +259 -0
package/src/handle.ts +120 -0
package/src/handles/MetaTags.tsx +178 -0
package/src/handles/index.ts +6 -0
package/src/handles/meta.ts +247 -0
package/src/href-client.ts +128 -0
package/src/href.ts +139 -0
package/src/index.rsc.ts +69 -0
package/src/index.ts +84 -0
package/src/loader.rsc.ts +204 -0
package/src/loader.ts +47 -0
package/src/network-error-thrower.tsx +21 -0
package/src/outlet-context.ts +15 -0
package/src/root-error-boundary.tsx +277 -0
package/src/route-content-wrapper.tsx +198 -0
package/src/route-definition.ts +1333 -0
package/src/route-map-builder.ts +140 -0
package/src/route-types.ts +148 -0
package/src/route-utils.ts +89 -0
package/src/router/__tests__/match-context.test.ts +104 -0
package/src/router/__tests__/match-pipelines.test.ts +537 -0
package/src/router/__tests__/match-result.test.ts +566 -0
package/src/router/__tests__/on-error.test.ts +935 -0
package/src/router/__tests__/pattern-matching.test.ts +577 -0
package/src/router/error-handling.ts +287 -0
package/src/router/handler-context.ts +60 -0
package/src/router/loader-resolution.ts +326 -0
package/src/router/manifest.ts +116 -0
package/src/router/match-context.ts +261 -0
package/src/router/match-middleware/background-revalidation.ts +236 -0
package/src/router/match-middleware/cache-lookup.ts +261 -0
package/src/router/match-middleware/cache-store.ts +250 -0
package/src/router/match-middleware/index.ts +81 -0
package/src/router/match-middleware/intercept-resolution.ts +268 -0
package/src/router/match-middleware/segment-resolution.ts +174 -0
package/src/router/match-pipelines.ts +214 -0
package/src/router/match-result.ts +212 -0
package/src/router/metrics.ts +62 -0
package/src/router/middleware.test.ts +1355 -0
package/src/router/middleware.ts +748 -0
package/src/router/pattern-matching.ts +271 -0
package/src/router/revalidation.ts +190 -0
package/src/router/router-context.ts +299 -0
package/src/router/types.ts +96 -0
package/src/router.ts +3484 -0
package/src/rsc/__tests__/helpers.test.ts +175 -0
package/src/rsc/handler.ts +942 -0
package/src/rsc/helpers.ts +64 -0
package/src/rsc/index.ts +56 -0
package/src/rsc/nonce.ts +18 -0
package/src/rsc/types.ts +225 -0
package/src/segment-system.tsx +405 -0
package/src/server/__tests__/request-context.test.ts +171 -0
package/src/server/context.ts +340 -0
package/src/server/handle-store.ts +230 -0
package/src/server/loader-registry.ts +174 -0
package/src/server/request-context.ts +470 -0
package/src/server/root-layout.tsx +10 -0
package/src/server/tsconfig.json +14 -0
package/src/server.ts +126 -0
package/src/ssr/__tests__/ssr-handler.test.tsx +188 -0
package/src/ssr/index.tsx +215 -0
package/src/types.ts +1473 -0
package/src/use-loader.tsx +346 -0
package/src/vite/__tests__/expose-loader-id.test.ts +117 -0
package/src/vite/expose-action-id.ts +344 -0
package/src/vite/expose-handle-id.ts +209 -0
package/src/vite/expose-loader-id.ts +357 -0
package/src/vite/expose-location-state-id.ts +177 -0
package/src/vite/index.ts +608 -0
package/src/vite/version.d.ts +12 -0
package/src/vite/virtual-entries.ts +109 -0

package/src/handles/meta.ts ADDED Viewed

@@ -0,0 +1,247 @@
+/**
+ * Built-in Meta handle for managing document metadata across route segments.
+ *
+ * Provides automatic deduplication: later routes override earlier ones
+ * for the same meta key (title, name, property, etc.)
+ *
+ * @example
+ * ```tsx
+ * // In route handler
+ * route("product/:id", (ctx) => {
+ *   const meta = ctx.use(Meta);
+ *   meta({ title: "Product Details" });
+ *   meta({ name: "description", content: "..." });
+ *   meta({ property: "og:title", content: "..." });
+ * });
+ *
+ * // In layout (renders the collected meta tags)
+ * function RootLayout() {
+ *   return (
+ *     <html>
+ *       <head>
+ *         <MetaTags />
+ *       </head>
+ *       ...
+ *     </html>
+ *   );
+ * }
+ * ```
+ */
+import { createHandle, type Handle } from "../handle.ts";
+import type {
+  MetaDescriptor,
+  TitleDescriptor,
+  UnsetDescriptor,
+} from "../router/types.ts";
+/**
+ * Type guard for unset descriptor
+ */
+function isUnsetDescriptor(
+  descriptor: MetaDescriptor
+): descriptor is UnsetDescriptor {
+  return (
+    typeof descriptor === "object" &&
+    descriptor !== null &&
+    "unset" in descriptor &&
+    typeof (descriptor as UnsetDescriptor).unset === "string"
+  );
+}
+/**
+ * Type guard for title descriptor (any form)
+ */
+function isTitleDescriptor(
+  descriptor: MetaDescriptor
+): descriptor is { title: TitleDescriptor } {
+  return (
+    typeof descriptor === "object" &&
+    descriptor !== null &&
+    "title" in descriptor
+  );
+}
+/**
+ * Type guard for title template descriptor
+ */
+function isTitleTemplate(
+  title: TitleDescriptor
+): title is { template: string; default: string } {
+  return (
+    typeof title === "object" &&
+    title !== null &&
+    "template" in title &&
+    "default" in title
+  );
+}
+/**
+ * Type guard for absolute title descriptor
+ */
+function isAbsoluteTitle(title: TitleDescriptor): title is { absolute: string } {
+  return typeof title === "object" && title !== null && "absolute" in title;
+}
+/**
+ * Get a unique key for a meta descriptor for deduplication.
+ * Returns undefined for descriptors that shouldn't be deduplicated.
+ */
+function getMetaKey(descriptor: MetaDescriptor): string | undefined {
+  // Skip unset descriptors - they are processed separately
+  if (isUnsetDescriptor(descriptor)) {
+    return undefined;
+  }
+  if ("charSet" in descriptor) {
+    return "charSet";
+  }
+  if ("title" in descriptor) {
+    return "title";
+  }
+  if ("name" in descriptor && "content" in descriptor) {
+    return `name:${descriptor.name}`;
+  }
+  if ("property" in descriptor && "content" in descriptor) {
+    return `property:${descriptor.property}`;
+  }
+  if ("httpEquiv" in descriptor && "content" in descriptor) {
+    return `httpEquiv:${descriptor.httpEquiv}`;
+  }
+  if ("script:ld+json" in descriptor) {
+    // JSON-LD scripts can have multiple, don't dedupe by default
+    return undefined;
+  }
+  if ("tagName" in descriptor) {
+    // For link tags, dedupe by rel if present
+    if (descriptor.tagName === "link" && "rel" in descriptor) {
+      // Some link rels should be unique (canonical), others not (stylesheet)
+      const uniqueRels = ["canonical", "icon", "apple-touch-icon"];
+      if (uniqueRels.includes(descriptor.rel as string)) {
+        return `link:${descriptor.rel}`;
+      }
+    }
+    return undefined;
+  }
+  return undefined;
+}
+/**
+ * Default meta descriptors included automatically.
+ * These can be overridden by route handlers.
+ */
+const defaultMetaDescriptors: MetaDescriptor[] = [
+  { charSet: "utf-8" },
+  { name: "viewport", content: "width=device-width, initial-scale=1" },
+];
+/**
+ * Helper to add or replace a descriptor in the result array
+ */
+function addOrReplace(
+  result: MetaDescriptor[],
+  keyToIndex: Map<string, number>,
+  descriptor: MetaDescriptor,
+  key: string | undefined
+): void {
+  if (key !== undefined && keyToIndex.has(key)) {
+    result[keyToIndex.get(key)!] = descriptor;
+  } else {
+    if (key !== undefined) {
+      keyToIndex.set(key, result.length);
+    }
+    result.push(descriptor);
+  }
+}
+/**
+ * Helper to update indices after removing an element
+ */
+function updateIndicesAfterRemoval(
+  keyToIndex: Map<string, number>,
+  removedIndex: number
+): void {
+  for (const [key, index] of keyToIndex) {
+    if (index > removedIndex) {
+      keyToIndex.set(key, index - 1);
+    }
+  }
+}
+/**
+ * Collect function for Meta handle.
+ * Includes default meta descriptors, then deduplicates by key with later routes overriding earlier ones.
+ * Supports title templates, absolute titles, and unset descriptors.
+ */
+function collectMeta(segments: MetaDescriptor[][]): MetaDescriptor[] {
+  const result: MetaDescriptor[] = [];
+  const keyToIndex = new Map<string, number>();
+  let titleTemplate: string | undefined;
+  // Add defaults first so they can be overridden
+  for (const descriptor of defaultMetaDescriptors) {
+    const key = getMetaKey(descriptor);
+    if (key !== undefined) {
+      keyToIndex.set(key, result.length);
+    }
+    result.push(descriptor);
+  }
+  for (const descriptors of segments) {
+    for (const descriptor of descriptors) {
+      // Handle unset descriptors
+      if (isUnsetDescriptor(descriptor)) {
+        const keyToRemove = descriptor.unset;
+        if (keyToIndex.has(keyToRemove)) {
+          const idx = keyToIndex.get(keyToRemove)!;
+          result.splice(idx, 1);
+          keyToIndex.delete(keyToRemove);
+          updateIndicesAfterRemoval(keyToIndex, idx);
+        }
+        continue;
+      }
+      // Handle title descriptors with template/absolute support
+      if (isTitleDescriptor(descriptor)) {
+        const titleValue = descriptor.title;
+        if (isTitleTemplate(titleValue)) {
+          // Store template for subsequent title descriptors in child segments
+          titleTemplate = titleValue.template;
+          // Set the default title
+          addOrReplace(result, keyToIndex, { title: titleValue.default }, "title");
+          continue;
+        }
+        if (isAbsoluteTitle(titleValue)) {
+          // Absolute title bypasses any template
+          addOrReplace(result, keyToIndex, { title: titleValue.absolute }, "title");
+          continue;
+        }
+        // String title - apply template if one exists
+        const finalTitle = titleTemplate
+          ? titleTemplate.replace("%s", titleValue as string)
+          : titleValue;
+        addOrReplace(result, keyToIndex, { title: finalTitle as string }, "title");
+        continue;
+      }
+      // Handle all other descriptors
+      const key = getMetaKey(descriptor);
+      addOrReplace(result, keyToIndex, descriptor, key);
+    }
+  }
+  return result;
+}
+/**
+ * Built-in handle for managing document metadata.
+ *
+ * Use `ctx.use(Meta)` in route handlers to push meta descriptors.
+ * Use `<MetaTags />` component to render them in the document head.
+ */
+export const Meta: Handle<MetaDescriptor, MetaDescriptor[]> = createHandle<MetaDescriptor, MetaDescriptor[]>(
+  collectMeta,
+  "__rsc_router_meta__"
+);

package/src/href-client.ts ADDED Viewed

@@ -0,0 +1,128 @@
+/**
+ * Client-safe type-safe href function
+ *
+ * This is a compile-time only href that validates paths against registered routes.
+ * No runtime route map lookup - just an identity function with TypeScript validation.
+ *
+ * @example
+ * ```typescript
+ * import { href } from "rsc-router/client";
+ *
+ * href("/blog/my-post");           // ✓ matches /blog/:slug
+ * href("/shop/product/widget");    // ✓ matches /shop/product/:slug
+ * href("/invalid");                // ✗ TypeScript error
+ * ```
+ */
+import type { GetRegisteredRoutes } from "./types.js";
+/**
+ * Parse constraint values into a union type for paths
+ * "a|b|c" → "a" | "b" | "c"
+ */
+type ParseConstraintPath<T extends string> =
+  T extends `${infer First}|${infer Rest}`
+    ? First | ParseConstraintPath<Rest>
+    : T;
+/**
+ * Convert a route pattern to a template literal type
+ *
+ * Supports:
+ * - Static: /about → "/about"
+ * - Dynamic: /blog/:slug → `/blog/${string}`
+ * - Optional: /:locale?/blog → "/blog" | `/${string}/blog`
+ * - Constrained: /:locale(en|gb)/blog → "/en/blog" | "/gb/blog"
+ * - Optional + Constrained: /:locale(en|gb)?/blog → "/blog" | "/en/blog" | "/gb/blog"
+ *
+ * @example
+ * PatternToPath<"/blog/:slug"> = `/blog/${string}`
+ * PatternToPath<"/:locale?/blog"> = "/blog" | `/${string}/blog`
+ * PatternToPath<"/:locale(en|gb)/blog"> = "/en/blog" | "/gb/blog"
+ * PatternToPath<"/:locale(en|gb)?/blog"> = "/blog" | "/en/blog" | "/gb/blog"
+ */
+export type PatternToPath<T extends string> =
+  // Optional + constrained param in middle: /:param(a|b)?/rest
+  T extends `${infer Before}:${infer _Name}(${infer Constraint})?/${infer After}`
+    ? PatternToPath<`${Before}${After}`> | `${Before}${ParseConstraintPath<Constraint>}/${PatternToPath<After>}`
+  // Optional + constrained param at end: /path/:param(a|b)?
+  : T extends `${infer Before}:${infer _Name}(${infer Constraint})?`
+    ? Before | `${Before}${ParseConstraintPath<Constraint>}`
+  // Constrained param in middle: /:param(a|b)/rest
+  : T extends `${infer Before}:${infer _Name}(${infer Constraint})/${infer After}`
+    ? `${Before}${ParseConstraintPath<Constraint>}/${PatternToPath<After>}`
+  // Constrained param at end: /path/:param(a|b)
+  : T extends `${infer Before}:${infer _Name}(${infer Constraint})`
+    ? `${Before}${ParseConstraintPath<Constraint>}`
+  // Optional param in middle: /:param?/rest
+  : T extends `${infer Before}:${infer _Param}?/${infer After}`
+    ? PatternToPath<`${Before}${After}`> | `${Before}${string}/${PatternToPath<After>}`
+  // Optional param at end: /path/:param?
+  : T extends `${infer Before}:${infer _Param}?`
+    ? Before | `${Before}${string}`
+  // Required param in middle: /:param/rest
+  : T extends `${infer Before}:${infer _Param}/${infer After}`
+    ? `${Before}${string}/${PatternToPath<After>}`
+  // Required param at end: /path/:param
+  : T extends `${infer Before}:${infer _Param}`
+    ? `${Before}${string}`
+  // Static path
+  : T;
+/**
+ * Allow optional query string (?...) and/or hash fragment (#...) suffix
+ *
+ * @example
+ * WithSuffix<"/about"> = "/about" | "/about?..." | "/about#..." | "/about?...#..."
+ */
+type WithSuffix<T extends string> =
+  | T
+  | `${T}?${string}`
+  | `${T}#${string}`
+  | `${T}?${string}#${string}`;
+/**
+ * Union of all valid paths from registered routes
+ *
+ * Generated from RSCRouter.RegisteredRoutes via module augmentation.
+ * Allows optional query strings and hash fragments.
+ */
+export type ValidPaths<TRoutes extends Record<string, string> = GetRegisteredRoutes> =
+  WithSuffix<PatternToPath<TRoutes[keyof TRoutes]>>;
+/**
+ * Type-safe href function for client-side use
+ *
+ * This is an identity function - it returns the path unchanged.
+ * The value is in TypeScript validation: invalid paths cause compile errors.
+ *
+ * Works with:
+ * - Static paths: href("/about")
+ * - Dynamic segments: href("/blog/my-post")
+ * - Multiple segments: href("/shop/product/widget/reviews/123")
+ *
+ * Does NOT validate:
+ * - Query strings (passed through as-is)
+ * - Hash fragments (passed through as-is)
+ *
+ * @param path - A valid path matching one of the registered route patterns
+ * @returns The path unchanged
+ *
+ * @example
+ * ```typescript
+ * // Valid paths (compile)
+ * href("/blog/hello");                    // matches /blog/:slug
+ * href("/shop/product/widget");           // matches /shop/product/:slug
+ * href("/shop/product/widget/reviews");   // matches /shop/product/:slug/reviews
+ *
+ * // Query strings and hashes pass through (not validated)
+ * href("/blog/hello?page=1");
+ * href("/about#contact");
+ *
+ * // Invalid paths (TypeScript error)
+ * href("/nonexistent");  // Error: not assignable to ValidPaths
+ * ```
+ */
+export function href<T extends ValidPaths>(path: T): T {
+  return path;
+}

package/src/href.ts ADDED Viewed

@@ -0,0 +1,139 @@
+import type { ExtractParams } from "./types.js";
+/**
+ * Sanitize prefix string by removing leading slash
+ * "/shop" -> "shop", "blog" -> "blog", "" -> ""
+ */
+export type SanitizePrefix<T extends string> = T extends `/${infer P}` ? P : T;
+/**
+ * Helper type to merge multiple route definitions into a single accumulated type.
+ * Use this to define your app's complete route map for type-safe router.href().
+ *
+ * @example
+ * ```typescript
+ * import { homeRoutes, blogRoutes, shopRoutes } from "./routes";
+ *
+ * type AppRoutes = MergeRoutes<[
+ *   typeof homeRoutes,
+ *   PrefixedRoutes<typeof blogRoutes, "blog">,
+ *   PrefixedRoutes<typeof shopRoutes, "shop">,
+ * ]>;
+ *
+ * export const router = createRSCRouter<AppEnv>() as RSCRouter<AppEnv, AppRoutes>;
+ * ```
+ */
+export type MergeRoutes<T extends Record<string, string>[]> = T extends [
+  infer First extends Record<string, string>,
+  ...infer Rest extends Record<string, string>[]
+]
+  ? First & MergeRoutes<Rest>
+  : {};
+/**
+ * Add key prefix to all entries in a route map
+ * { "cart": "/cart" } with prefix "shop" -> { "shop.cart": "/shop/cart" }
+ */
+export type PrefixRouteKeys<
+  T extends Record<string, string>,
+  Prefix extends string
+> = Prefix extends ""
+  ? T
+  : { [K in keyof T as `${Prefix}.${K & string}`]: T[K] };
+/**
+ * Add path prefix to all patterns in a route map
+ * { "cart": "/cart" } with prefix "/shop" -> { "cart": "/shop/cart" }
+ */
+export type PrefixRoutePatterns<
+  T extends Record<string, string>,
+  PathPrefix extends string
+> = {
+  [K in keyof T]: PathPrefix extends "" | "/"
+    ? T[K]
+    : T[K] extends "/"
+      ? PathPrefix
+      : `${PathPrefix}${T[K]}`;
+};
+/**
+ * Combined: prefix both keys and patterns
+ * Used for module augmentation registration
+ *
+ * @example
+ * ```typescript
+ * // Given shopRoutes = { "index": "/", "cart": "/cart", "products.detail": "/product/:slug" }
+ * // PrefixedRoutes<typeof shopRoutes, "shop"> produces:
+ * // { "shop.index": "/shop", "shop.cart": "/shop/cart", "shop.products.detail": "/shop/product/:slug" }
+ * ```
+ */
+export type PrefixedRoutes<
+  T extends Record<string, string>,
+  KeyPrefix extends string,
+  PathPrefix extends string = KeyPrefix extends "" ? "" : `/${KeyPrefix}`
+> = PrefixRouteKeys<PrefixRoutePatterns<T, PathPrefix>, KeyPrefix>;
+/**
+ * Extract params type for a route
+ */
+export type ParamsFor<
+  TRoutes extends Record<string, string>,
+  TName extends keyof TRoutes
+> = TRoutes[TName] extends string ? ExtractParams<TRoutes[TName]> : never;
+/**
+ * Check if an object type has any keys
+ */
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+/**
+ * Type-safe href function signature
+ * Provides overloads for routes with and without params
+ */
+export type HrefFunction<TRoutes extends Record<string, string>> = {
+  // Overload 1: Routes without params - second arg optional
+  <TName extends keyof TRoutes & string>(
+    name: IsEmptyObject<ParamsFor<TRoutes, TName>> extends true ? TName : never
+  ): string;
+  // Overload 2: Routes with params - params required
+  <TName extends keyof TRoutes & string>(
+    name: TName,
+    params: ParamsFor<TRoutes, TName>
+  ): string;
+};
+/**
+ * Create a type-safe href function for URL generation
+ *
+ * @param routeMap - Flattened route map with all registered routes
+ * @returns Type-safe href function
+ *
+ * @example
+ * ```typescript
+ * const href = createHref(mergedRouteMap);
+ * href("shop.cart"); // "/shop/cart"
+ * href("shop.products.detail", { slug: "my-product" }); // "/shop/product/my-product"
+ * ```
+ */
+export function createHref<TRoutes extends Record<string, string>>(
+  routeMap: TRoutes
+): HrefFunction<TRoutes> {
+  return ((name: string, params?: Record<string, string>) => {
+    const pattern = routeMap[name];
+    if (!pattern) {
+      throw new Error(`Unknown route: ${name}`);
+    }
+    if (!params) return pattern;
+    // Replace :param placeholders with actual values
+    return pattern.replace(/:([^/]+)/g, (_, key) => {
+      const value = params[key];
+      if (value === undefined) {
+        throw new Error(`Missing param "${key}" for route "${name}"`);
+      }
+      return encodeURIComponent(value);
+    });
+  }) as HrefFunction<TRoutes>;
+}

package/src/index.rsc.ts ADDED Viewed

@@ -0,0 +1,69 @@
+/**
+ * rsc-router (react-server environment)
+ *
+ * This file is used when importing "rsc-router" from RSC (server components).
+ * It re-exports everything from the universal index.ts plus adds server-side
+ * createLoader that includes the actual loader function.
+ *
+ * The bundler uses the "react-server" export condition to select this file
+ * in RSC context, while the regular index.ts is used in client components.
+ */
+// Re-export all universal exports from index.ts
+export {
+  // Universal rendering utilities
+  renderSegments,
+  // Error classes
+  RouteNotFoundError,
+  DataNotFoundError,
+  notFound,
+  MiddlewareError,
+  HandlerError,
+  BuildError,
+  InvalidHandlerError,
+  NetworkError,
+  isNetworkError,
+  sanitizeError,
+  // Route pattern definition
+  route,
+} from "./index.js";
+// Re-export all types from index.ts
+export type {
+  RouterEnv,
+  DefaultEnv,
+  RouteDefinition,
+  ResolvedRouteMap,
+  Handler,
+  HandlerContext,
+  HandlersForRouteMap,
+  ResolvedSegment,
+  SegmentMetadata,
+  MatchResult,
+  ExtractParams,
+  GenericParams,
+  RevalidateParams,
+  ShouldRevalidateFn,
+  MiddlewareFn,
+  RouteKeys,
+  RouteHandler,
+  RouteRevalidateFn,
+  RouteMiddlewareFn,
+  LoaderDefinition,
+  LoaderFn,
+  LoaderContext,
+  ErrorInfo,
+  ErrorBoundaryFallbackProps,
+  ErrorBoundaryHandler,
+  ClientErrorBoundaryFallbackProps,
+  NotFoundInfo,
+  NotFoundBoundaryFallbackProps,
+  NotFoundBoundaryHandler,
+  RSCRouterOptions,
+  PerformanceMetric,
+  MetricsStore,
+} from "./index.js";
+// Server-side createLoader - includes the actual loader function
+// This is the key addition for RSC context
+export { createLoader } from "./route-definition.js";

package/src/index.ts ADDED Viewed

@@ -0,0 +1,84 @@
+/**
+ * rsc-router
+ *
+ * Universal exports - types and utilities safe for both server and client
+ *
+ * For server-only exports (route, map, createRSCRouter, etc.):
+ *   import from "rsc-router/server"
+ *
+ * For client-only exports (Outlet, useOutlet, etc.):
+ *   import from "rsc-router/client"
+ */
+// Universal rendering utilities (work on both server and client)
+export { renderSegments } from "./segment-system.js";
+// Error classes (can be used on both server and client)
+export {
+  RouteNotFoundError,
+  DataNotFoundError,
+  notFound,
+  MiddlewareError,
+  HandlerError,
+  BuildError,
+  InvalidHandlerError,
+  NetworkError,
+  isNetworkError,
+  sanitizeError,
+} from "./errors.js";
+// Types (safe to import anywhere - no runtime code)
+export type {
+  DocumentProps,
+  RouterEnv,
+  DefaultEnv,
+  RouteDefinition,
+  ResolvedRouteMap,
+  Handler,
+  HandlerContext,
+  HandlersForRouteMap,
+  ResolvedSegment,
+  SegmentMetadata,
+  MatchResult,
+  ExtractParams,
+  GenericParams,
+  RevalidateParams,
+  ShouldRevalidateFn,
+  MiddlewareFn,
+  RouteKeys,
+  RouteHandler,
+  RouteRevalidateFn,
+  RouteMiddlewareFn,
+  LoaderDefinition,
+  LoaderFn,
+  LoaderContext,
+  // Fetchable loader types
+  FetchableLoaderOptions,
+  LoadOptions,
+  LoaderActionContext,
+  LoaderAction,
+  LoaderMiddlewareFn,
+  // Error boundary types
+  ErrorInfo,
+  ErrorBoundaryFallbackProps,
+  ErrorBoundaryHandler,
+  ClientErrorBoundaryFallbackProps,
+  // NotFound boundary types
+  NotFoundInfo,
+  NotFoundBoundaryFallbackProps,
+  NotFoundBoundaryHandler,
+} from "./types.js";
+// Router options type
+export type { RSCRouterOptions } from "./router.js";
+// Metrics types
+export type { PerformanceMetric, MetricsStore } from "./server/context.js";
+// Client-safe createLoader - only stores the $$id, function is not included
+// Use this when defining loaders that will be imported by client components
+export { createLoader } from "./loader.js";
+// Route pattern definition helper
+// Used to define route patterns in a shared routes.ts file
+export { route } from "./route-utils.js";