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

package/src/__tests__/route-definition.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { route } from "../route-definition";
-
-describe("route()", () => {
-  describe("with nested RouteConfig objects", () => {
-    it("should flatten nested RouteConfig with trailing slash config", () => {
-      const routes = route({
-        index: "/",
-        trailingSlash: {
-          ignore: { path: "/ts-ignore", trailingSlash: "ignore" },
-          always: { path: "/ts-always", trailingSlash: "always" },
-          never: { path: "/ts-never", trailingSlash: "never" },
-        },
-      }) as any;
-
-      // Check routes are flattened correctly
-      expect(routes.index).toBe("/");
-      expect(routes["trailingSlash.ignore"]).toBe("/ts-ignore");
-      expect(routes["trailingSlash.always"]).toBe("/ts-always");
-      expect(routes["trailingSlash.never"]).toBe("/ts-never");
-
-      // Check trailing slash config is attached
-      expect(routes.__trailingSlash).toBeDefined();
-      expect(routes.__trailingSlash["trailingSlash.ignore"]).toBe("ignore");
-      expect(routes.__trailingSlash["trailingSlash.always"]).toBe("always");
-      expect(routes.__trailingSlash["trailingSlash.never"]).toBe("never");
-    });
-
-    it("should be enumerable for Object.entries", () => {
-      const routes = route({
-        index: "/",
-        trailingSlash: {
-          ignore: { path: "/ts-ignore", trailingSlash: "ignore" },
-        },
-      });
-
-      const entries = Object.entries(routes);
-      expect(entries).toContainEqual(["index", "/"]);
-      expect(entries).toContainEqual(["trailingSlash.ignore", "/ts-ignore"]);
-    });
-
-    it("should apply global default to string routes", () => {
-      const routes = route({
-        blog: "/blog",
-        about: "/about",
-      }, { trailingSlash: "never" }) as any;
-
-      expect(routes.__trailingSlash).toBeDefined();
-      expect(routes.__trailingSlash.blog).toBe("never");
-      expect(routes.__trailingSlash.about).toBe("never");
-    });
-
-    it("should let per-route config override global default", () => {
-      const routes = route({
-        blog: "/blog",
-        api: { path: "/api", trailingSlash: "ignore" },
-      }, { trailingSlash: "never" }) as any;
-
-      expect(routes.__trailingSlash.blog).toBe("never");
-      expect(routes.__trailingSlash.api).toBe("ignore");
-    });
-  });
-});

package/src/__tests__/urls.test.tsx

@@ -1,436 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { urls } from "../urls.js";
-import { RSCRouterContext, type EntryData } from "../server/context.js";
-
-describe("urls()", () => {
-  describe("basic structure", () => {
-    it("should return UrlPatterns with handler function", () => {
-      const patterns = urls(({ path }) => [
-        path("/", () => <div>Home</div>),
-      ]);
-
-      expect(typeof patterns.handler).toBe("function");
-      expect(patterns.definitions).toEqual([]);
-    });
-
-    it("should accept empty array", () => {
-      const patterns = urls(() => []);
-
-      expect(typeof patterns.handler).toBe("function");
-    });
-  });
-
-  describe("path() helper", () => {
-    let manifest: Map<string, EntryData>;
-    let patterns: Map<string, string>;
-
-    beforeEach(() => {
-      manifest = new Map();
-      patterns = new Map();
-    });
-
-    afterEach(() => {
-      manifest.clear();
-      patterns.clear();
-    });
-
-    it("should register route with pattern only", () => {
-      const urlPatterns = urls(({ path }) => [
-        path("/about", () => <div>About</div>),
-      ]);
-
-      // Execute the handler within context to register routes
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => urlPatterns.handler()
-      );
-
-      // Should have registered a route
-      expect(manifest.size).toBeGreaterThan(0);
-    });
-
-    it("should register route with name option", () => {
-      const urlPatterns = urls(({ path }) => [
-        path("/about", () => <div>About</div>, { name: "about" }),
-      ]);
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => urlPatterns.handler()
-      );
-
-      // Should have registered route with name "about"
-      expect(manifest.has("about")).toBe(true);
-      expect(patterns.get("about")).toBe("/about");
-    });
-
-    it("should store pattern on route entry", () => {
-      const urlPatterns = urls(({ path }) => [
-        path("/:slug", () => <div>Post</div>, { name: "post" }),
-      ]);
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => urlPatterns.handler()
-      );
-
-      const entry = manifest.get("post");
-      expect(entry).toBeDefined();
-      expect((entry as any).pattern).toBe("/:slug");
-    });
-
-    it("should accept use callback as third argument", () => {
-      const urlPatterns = urls(({ path, middleware }) => [
-        path("/admin", () => <div>Admin</div>, () => [
-          middleware(() => {}),
-        ]),
-      ]);
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => urlPatterns.handler()
-      );
-
-      // Should have a route registered
-      expect(manifest.size).toBeGreaterThan(0);
-    });
-
-    it("should accept options and use callback", () => {
-      const urlPatterns = urls(({ path, middleware }) => [
-        path("/admin", () => <div>Admin</div>, { name: "admin" }, () => [
-          middleware(() => {}),
-        ]),
-      ]);
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => urlPatterns.handler()
-      );
-
-      expect(manifest.has("admin")).toBe(true);
-    });
-  });
-
-  describe("layout() helper", () => {
-    let manifest: Map<string, EntryData>;
-    let patterns: Map<string, string>;
-
-    beforeEach(() => {
-      manifest = new Map();
-      patterns = new Map();
-    });
-
-    it("should work with path() inside layout", () => {
-      const urlPatterns = urls(({ path, layout }) => [
-        layout(() => <div>Layout</div>, () => [
-          path("/", () => <div>Home</div>, { name: "home" }),
-          path("/about", () => <div>About</div>, { name: "about" }),
-        ]),
-      ]);
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => urlPatterns.handler()
-      );
-
-      expect(manifest.has("home")).toBe(true);
-      expect(manifest.has("about")).toBe(true);
-    });
-  });
-
-  describe("trailingSlash option", () => {
-    it("should store trailingSlash config in context", () => {
-      const manifest = new Map();
-      const patterns = new Map();
-      const trailingSlash = new Map<string, "always" | "never" | "ignore">();
-
-      const urlPatterns = urls(({ path }) => [
-        path("/ts-always", () => <div>Always</div>, { name: "tsAlways", trailingSlash: "always" }),
-        path("/ts-never", () => <div>Never</div>, { name: "tsNever", trailingSlash: "never" }),
-        path("/ts-ignore", () => <div>Ignore</div>, { name: "tsIgnore", trailingSlash: "ignore" }),
-      ]);
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          trailingSlash,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => urlPatterns.handler()
-      );
-
-      expect(trailingSlash.get("tsAlways")).toBe("always");
-      expect(trailingSlash.get("tsNever")).toBe("never");
-      expect(trailingSlash.get("tsIgnore")).toBe("ignore");
-    });
-  });
-
-  describe("include() helper", () => {
-    it("should return IncludeItem with correct structure", () => {
-      const blogPatterns = urls(({ path }) => [
-        path("/", () => <div>Blog Index</div>, { name: "index" }),
-      ]);
-
-      // Verify include() returns the right structure directly
-      const manifest = new Map();
-      const patterns = new Map();
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => {
-          // Test include() directly within context
-          const urlPatterns = urls(({ include }) => {
-            const includeItem = include("/blog", blogPatterns, { name: "blog" });
-
-            // Verify include item structure
-            expect(includeItem.type).toBe("include");
-            expect(includeItem.prefix).toBe("/blog");
-            expect(includeItem.options?.name).toBe("blog");
-            expect(includeItem.patterns).toBe(blogPatterns);
-
-            return [includeItem];
-          });
-
-          // Execute handler to verify it doesn't throw
-          urlPatterns.handler();
-        }
-      );
-    });
-
-    it("should apply URL prefix to nested patterns", () => {
-      const blogPatterns = urls(({ path }) => [
-        path("/", () => <div>Blog Index</div>, { name: "index" }),
-        path("/:slug", () => <div>Blog Post</div>, { name: "post" }),
-      ]);
-
-      const manifest = new Map<string, EntryData>();
-      const patterns = new Map<string, string>();
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => {
-          const urlPatterns = urls(({ include }) => [
-            include("/blog", blogPatterns, { name: "blog" }),
-          ]);
-
-          urlPatterns.handler();
-        }
-      );
-
-      // Routes should be prefixed with "blog."
-      expect(manifest.has("blog.index")).toBe(true);
-      expect(manifest.has("blog.post")).toBe(true);
-
-      // Patterns should be prefixed with "/blog"
-      expect(patterns.get("blog.index")).toBe("/blog");
-      expect(patterns.get("blog.post")).toBe("/blog/:slug");
-    });
-
-    it("should apply name prefix to nested route names", () => {
-      const shopPatterns = urls(({ path }) => [
-        path("/", () => <div>Shop</div>, { name: "index" }),
-        path("/cart", () => <div>Cart</div>, { name: "cart" }),
-        path("/product/:id", () => <div>Product</div>, { name: "product" }),
-      ]);
-
-      const manifest = new Map<string, EntryData>();
-      const patterns = new Map<string, string>();
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => {
-          const urlPatterns = urls(({ include }) => [
-            include("/shop", shopPatterns, { name: "shop" }),
-          ]);
-
-          urlPatterns.handler();
-        }
-      );
-
-      // All route names should be prefixed with "shop."
-      expect(manifest.has("shop.index")).toBe(true);
-      expect(manifest.has("shop.cart")).toBe(true);
-      expect(manifest.has("shop.product")).toBe(true);
-
-      // URL patterns should be prefixed with "/shop"
-      expect(patterns.get("shop.cart")).toBe("/shop/cart");
-      expect(patterns.get("shop.product")).toBe("/shop/product/:id");
-    });
-
-    it("should work without name prefix (routes keep local names)", () => {
-      const adminPatterns = urls(({ path }) => [
-        path("/", () => <div>Admin</div>, { name: "index" }),
-        path("/users", () => <div>Users</div>, { name: "users" }),
-      ]);
-
-      const manifest = new Map<string, EntryData>();
-      const patterns = new Map<string, string>();
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => {
-          const urlPatterns = urls(({ include }) => [
-            // No name option - routes keep their local names
-            include("/admin", adminPatterns),
-          ]);
-
-          urlPatterns.handler();
-        }
-      );
-
-      // Routes should keep local names (no prefix)
-      expect(manifest.has("index")).toBe(true);
-      expect(manifest.has("users")).toBe(true);
-
-      // But URL patterns should still be prefixed
-      expect(patterns.get("index")).toBe("/admin");
-      expect(patterns.get("users")).toBe("/admin/users");
-    });
-
-    it("should support nested includes", () => {
-      const postPatterns = urls(({ path }) => [
-        path("/", () => <div>Posts</div>, { name: "index" }),
-        path("/:id", () => <div>Post</div>, { name: "detail" }),
-      ]);
-
-      const blogPatterns = urls(({ path, include }) => [
-        path("/", () => <div>Blog</div>, { name: "home" }),
-        include("/posts", postPatterns, { name: "posts" }),
-      ]);
-
-      const manifest = new Map<string, EntryData>();
-      const patterns = new Map<string, string>();
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => {
-          const urlPatterns = urls(({ include }) => [
-            include("/blog", blogPatterns, { name: "blog" }),
-          ]);
-
-          urlPatterns.handler();
-        }
-      );
-
-      // Top level blog routes
-      expect(manifest.has("blog.home")).toBe(true);
-      expect(patterns.get("blog.home")).toBe("/blog");
-
-      // Nested posts routes (blog.posts.index, blog.posts.detail)
-      expect(manifest.has("blog.posts.index")).toBe(true);
-      expect(manifest.has("blog.posts.detail")).toBe(true);
-      expect(patterns.get("blog.posts.index")).toBe("/blog/posts");
-      expect(patterns.get("blog.posts.detail")).toBe("/blog/posts/:id");
-    });
-
-    it("should reuse same patterns with different prefixes", () => {
-      // Same pattern module can be included multiple times with different prefixes
-      const contentPatterns = urls(({ path }) => [
-        path("/", () => <div>Index</div>, { name: "index" }),
-        path("/:slug", () => <div>Detail</div>, { name: "detail" }),
-      ]);
-
-      const manifest = new Map<string, EntryData>();
-      const patterns = new Map<string, string>();
-
-      RSCRouterContext.run(
-        {
-          manifest,
-          patterns,
-          namespace: "test",
-          parent: null,
-          counters: {},
-        },
-        () => {
-          const urlPatterns = urls(({ include }) => [
-            include("/blog", contentPatterns, { name: "blog" }),
-            include("/news", contentPatterns, { name: "news" }),
-          ]);
-
-          urlPatterns.handler();
-        }
-      );
-
-      // Both should have their own prefixed routes
-      expect(manifest.has("blog.index")).toBe(true);
-      expect(manifest.has("blog.detail")).toBe(true);
-      expect(manifest.has("news.index")).toBe(true);
-      expect(manifest.has("news.detail")).toBe(true);
-
-      // With different URL prefixes
-      expect(patterns.get("blog.index")).toBe("/blog");
-      expect(patterns.get("news.index")).toBe("/news");
-      expect(patterns.get("blog.detail")).toBe("/blog/:slug");
-      expect(patterns.get("news.detail")).toBe("/news/:slug");
-    });
-  });
-});

package/src/browser/lru-cache.ts

@@ -1,69 +0,0 @@
-/**
- * Simple LRU (Least Recently Used) cache implementation
- * Used for caching navigation segments to enable instant back/forward
- */
-export class LRUCache<K, V> {
-  private cache = new Map<K, V>();
-  private maxSize: number;
-
-  constructor(maxSize: number) {
-    this.maxSize = maxSize;
-  }
-
-  get(key: K): V | undefined {
-    if (!this.cache.has(key)) {
-      return undefined;
-    }
-
-    // Move to end (most recently used)
-    const value = this.cache.get(key)!;
-    this.cache.delete(key);
-    this.cache.set(key, value);
-    return value;
-  }
-
-  set(key: K, value: V): void {
-    // If key exists, delete it first to update position
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    }
-
-    this.cache.set(key, value);
-
-    // Evict oldest entries if over capacity
-    while (this.cache.size > this.maxSize) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey !== undefined) {
-        this.cache.delete(oldestKey);
-      }
-    }
-  }
-
-  has(key: K): boolean {
-    if (!this.cache.has(key)) {
-      return false;
-    }
-
-    // Move to end (most recently used) - same as get()
-    const value = this.cache.get(key)!;
-    this.cache.delete(key);
-    this.cache.set(key, value);
-    return true;
-  }
-
-  delete(key: K): boolean {
-    return this.cache.delete(key);
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-
-  keys(): IterableIterator<K> {
-    return this.cache.keys();
-  }
-
-  get size(): number {
-    return this.cache.size;
-  }
-}