@rangojs/router 0.0.0-experimental.2 → 0.0.0-experimental.20dbba0c

package/src/href.ts

@@ -1,177 +0,0 @@
-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.
- * Note: When using createRSCRouter, types accumulate automatically through the
- * builder chain, so this type is typically not needed.
- *
- * @example
- * ```typescript
- * // Manual type merging (rarely needed):
- * type AppRoutes = MergeRoutes<[
- *   typeof homeRoutes,
- *   PrefixRoutePatterns<typeof blogRoutes, "/blog">,
- * ]>;
- *
- * // Preferred: Let router accumulate types automatically
- * const router = createRSCRouter<AppEnv>()
- *   .routes(homeRoutes).map(...)
- *   .routes("/blog", blogRoutes).map(...);
- * type AppRoutes = typeof router.routeMap;
- * ```
- */
-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;
-};
-
-/**
- * Type-safe scoped href function signature for use with useHref<typeof patterns>()
- * Accepts local route names (from the patterns), absolute names (with dot), or path-based URLs.
- *
- * @example
- * ```typescript
- * // In a component rendered by blog routes:
- * const href = useHref<typeof blogPatterns>();
- *
- * href("index")                    // Local name → resolved with current prefix
- * href("post", { slug: "hello" })  // Local name with params
- * href("shop.cart")                // Absolute name → global lookup
- * href("/about")                   // Path-based → used directly
- * ```
- */
-export type ScopedHrefFunction<TLocalRoutes extends Record<string, string>> = {
-  // Overload 1: Local routes without params
-  <TName extends keyof TLocalRoutes & string>(
-    name: IsEmptyObject<ParamsFor<TLocalRoutes, TName>> extends true ? TName : never
-  ): string;
-
-  // Overload 2: Local routes with params
-  <TName extends keyof TLocalRoutes & string>(
-    name: TName,
-    params: ParamsFor<TLocalRoutes, TName>
-  ): string;
-
-  // Overload 3: Absolute name (contains dot) - global lookup
-  (name: `${string}.${string}`, params?: Record<string, string>): string;
-
-  // Overload 4: Path-based URL - used directly
-  (name: `/${string}`, params?: Record<string, string>): 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
- * // Given routes: { cart: "/shop/cart", detail: "/shop/product/:slug" }
- * const href = createHref(routeMap);
- * href("cart"); // "/shop/cart"
- * href("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/route-utils.ts

@@ -1,89 +0,0 @@
-/**
- * Client-safe route utilities
- *
- * These utilities can be imported in client code without pulling in server dependencies.
- */
-
-import type { RouteDefinition, RouteConfig, ResolvedRouteMap, TrailingSlashMode } from "./types.js";
-
-/**
- * Check if a value is a RouteConfig object
- */
-function isRouteConfig(value: unknown): value is RouteConfig {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "path" in value &&
-    typeof (value as RouteConfig).path === "string"
-  );
-}
-
-/**
- * Flatten nested route definitions
- */
-function flattenRoutes(
-  routes: RouteDefinition,
-  prefix: string,
-  trailingSlashConfig: Record<string, TrailingSlashMode>
-): Record<string, string> {
-  const flattened: Record<string, string> = {};
-
-  for (const [key, value] of Object.entries(routes)) {
-    const fullKey = prefix + key;
-    if (typeof value === "string") {
-      // Direct route pattern - include prefix
-      flattened[fullKey] = value;
-    } else if (isRouteConfig(value)) {
-      // Route config object - extract path and trailing slash config
-      flattened[fullKey] = value.path;
-      if (value.trailingSlash) {
-        trailingSlashConfig[fullKey] = value.trailingSlash;
-      }
-    } else {
-      // Nested routes - flatten recursively
-      const nested = flattenRoutes(value, `${fullKey}.`, trailingSlashConfig);
-      Object.assign(flattened, nested);
-    }
-  }
-
-  return flattened;
-}
-
-/**
- * Define routes with type safety (client-safe version)
- *
- * This is a client-safe version of the route function that can be imported
- * in client code without pulling in server dependencies.
- *
- * @param input - Route definition object
- * @returns Flattened route map with full type information
- *
- * @example
- * ```typescript
- * const shopRoutes = route({
- *   index: "/",
- *   cart: "/cart",
- *   products: {
- *     detail: "/product/:slug",
- *     category: "/products/:category",
- *   },
- * });
- * // Result: { index: "/", cart: "/cart", "products.detail": "/product/:slug", "products.category": "/products/:category" }
- * ```
- */
-export function route<const T extends RouteDefinition>(
-  input: T
-): ResolvedRouteMap<T> {
-  const trailingSlash: Record<string, TrailingSlashMode> = {};
-  const routes = flattenRoutes(input as RouteDefinition, "", trailingSlash);
-
-  const result = routes as ResolvedRouteMap<T> & { __trailingSlash?: Record<string, TrailingSlashMode> };
-  if (Object.keys(trailingSlash).length > 0) {
-    Object.defineProperty(result, "__trailingSlash", {
-      value: trailingSlash,
-      enumerable: false,
-      writable: false,
-    });
-  }
-  return result;
-}

package/src/router/__tests__/match-context.test.ts

@@ -1,104 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createPipelineState } from "../match-context";
-
-describe("match-context", () => {
-  describe("createPipelineState()", () => {
-    it("should create initial state with default values", () => {
-      const state = createPipelineState();
-
-      expect(state.cacheHit).toBe(false);
-      expect(state.segments).toEqual([]);
-      expect(state.matchedIds).toEqual([]);
-      expect(state.interceptSegments).toEqual([]);
-      expect(state.slots).toEqual({});
-    });
-
-    it("should create state without cached data by default", () => {
-      const state = createPipelineState();
-
-      expect(state.cachedSegments).toBeUndefined();
-      expect(state.cachedMatchedIds).toBeUndefined();
-      expect(state.shouldRevalidate).toBeUndefined();
-    });
-
-    it("should allow mutation of state properties", () => {
-      const state = createPipelineState();
-
-      state.cacheHit = true;
-      state.segments.push({
-        id: "seg1",
-        type: "route",
-        component: null,
-        params: {},
-      });
-      state.matchedIds.push("seg1");
-      state.slots["@modal"] = { active: true, segments: [] };
-
-      expect(state.cacheHit).toBe(true);
-      expect(state.segments).toHaveLength(1);
-      expect(state.matchedIds).toContain("seg1");
-      expect(state.slots["@modal"]).toBeDefined();
-    });
-
-    it("should create independent state instances", () => {
-      const state1 = createPipelineState();
-      const state2 = createPipelineState();
-
-      state1.cacheHit = true;
-      state1.segments.push({
-        id: "seg1",
-        type: "route",
-        component: null,
-        params: {},
-      });
-
-      expect(state2.cacheHit).toBe(false);
-      expect(state2.segments).toHaveLength(0);
-    });
-
-    it("should support setting cache-related properties", () => {
-      const state = createPipelineState();
-
-      state.cacheHit = true;
-      state.shouldRevalidate = true;
-      state.cachedSegments = [
-        { id: "cached1", type: "route", component: "CachedComponent", params: {} },
-      ];
-      state.cachedMatchedIds = ["cached1"];
-
-      expect(state.cacheHit).toBe(true);
-      expect(state.shouldRevalidate).toBe(true);
-      expect(state.cachedSegments).toHaveLength(1);
-      expect(state.cachedMatchedIds).toContain("cached1");
-    });
-
-    it("should support intercept segments", () => {
-      const state = createPipelineState();
-
-      state.interceptSegments.push({
-        id: "modal-seg",
-        type: "route",
-        component: "ModalComponent",
-        params: {},
-      });
-
-      expect(state.interceptSegments).toHaveLength(1);
-      expect(state.interceptSegments[0].id).toBe("modal-seg");
-    });
-
-    it("should support slots with nested segments", () => {
-      const state = createPipelineState();
-
-      state.slots["@modal"] = {
-        active: true,
-        segments: [
-          { id: "modal1", type: "route", component: "Modal1", params: {} },
-          { id: "modal2", type: "route", component: "Modal2", params: {} },
-        ],
-      };
-
-      expect(state.slots["@modal"].active).toBe(true);
-      expect(state.slots["@modal"].segments).toHaveLength(2);
-    });
-  });
-});