@reckona/mreact-router 0.0.65 → 0.0.67

package/src/native-route-matcher.ts

@@ -0,0 +1,173 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { AppRoute, MatchedRoute, RouteMatcher } from "./routes.js";
+
+interface NativeRouteMatcherInstance {
+  matchRoute(pathname: string): NativeMatchOutput | null | undefined;
+}
+
+interface NativeRouteMatcherConstructor {
+  new (routesJson: string): NativeRouteMatcherInstance;
+}
+
+interface NativeRouteMatcherModule {
+  NativeRouteMatcher?: NativeRouteMatcherConstructor | undefined;
+}
+
+interface NativeMatchOutput {
+  index: number;
+  params: Record<string, string>;
+}
+
+let loadedNativeModule: NativeRouteMatcherModule | false | undefined;
+const nativeRouteMatcherAutoThreshold = 100;
+
+export function createNativeRouteMatcher(
+  sortedRoutes: readonly AppRoute[],
+): RouteMatcher | undefined {
+  if (
+    !shouldUseNativeRouteMatcher(
+      sortedRoutes.length,
+      process.env.MREACT_APP_ROUTER_NATIVE_ROUTE_MATCHER,
+    )
+  ) {
+    return undefined;
+  }
+
+  const nativeModule = loadNativeRouteMatcherModule();
+  const NativeRouteMatcher = nativeModule === false
+    ? undefined
+    : nativeModule.NativeRouteMatcher;
+
+  if (NativeRouteMatcher === undefined) {
+    return undefined;
+  }
+
+  const nativeRoutes = sortedRoutes.map((route, index) => ({
+    index,
+    segments: route.segments,
+  }));
+  const matcher = new NativeRouteMatcher(JSON.stringify(nativeRoutes));
+
+  return {
+    match(pathname): MatchedRoute | undefined {
+      const output = matcher.matchRoute(pathname);
+
+      if (output == null) {
+        return undefined;
+      }
+
+      const route = sortedRoutes[output.index];
+
+      return route === undefined
+        ? undefined
+        : {
+            route,
+            params: normalizeNativeParams(route, output.params),
+          };
+    },
+  };
+}
+
+function normalizeNativeParams(
+  route: AppRoute,
+  params: Record<string, string>,
+): MatchedRoute["params"] {
+  const normalized: MatchedRoute["params"] = { ...params };
+
+  for (const segment of route.segments) {
+    if (segment.kind !== "catch-all") {
+      continue;
+    }
+    const value = normalized[segment.name];
+    if (typeof value === "string") {
+      normalized[segment.name] = value.split("/").filter((part: string) => part !== "");
+    }
+  }
+
+  return normalized;
+}
+
+export function shouldUseNativeRouteMatcher(
+  routeCount: number,
+  mode: string | undefined,
+): boolean {
+  if (mode === "1" || mode === "true") {
+    return true;
+  }
+
+  if (mode === "0" || mode === "false") {
+    return false;
+  }
+
+  return routeCount >= nativeRouteMatcherAutoThreshold;
+}
+
+function loadNativeRouteMatcherModule(): NativeRouteMatcherModule | false {
+  if (loadedNativeModule !== undefined) {
+    return loadedNativeModule;
+  }
+
+  const require = nativePackageRequire();
+
+  if (require === undefined) {
+    loadedNativeModule = false;
+    return loadedNativeModule;
+  }
+
+  for (const candidate of nativeModuleCandidates()) {
+    try {
+      loadedNativeModule = require(candidate) as NativeRouteMatcherModule;
+      return loadedNativeModule;
+    } catch {
+      // Native package is optional. The JS matcher remains the portable fallback.
+    }
+  }
+
+  loadedNativeModule = false;
+  return false;
+}
+
+function nativePackageRequire(): ReturnType<typeof createRequire> | undefined {
+  try {
+    return new URL(import.meta.url).protocol === "file:" ? createRequire(import.meta.url) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function nativeModuleCandidates(): string[] {
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const workspaceNativePackage = join(currentDir, "..", "..", "router-native");
+
+  return [
+    ...nativeModulePackageCandidates(process.platform, process.arch),
+    workspaceNativePackage,
+  ];
+}
+
+export function nativeModulePackageCandidates(platform: NodeJS.Platform, arch: string): string[] {
+  const platformPackage = nativePlatformPackageName(platform, arch);
+
+  return [
+    ...(platformPackage === undefined ? [] : [platformPackage]),
+    "@reckona/mreact-router-native",
+  ];
+}
+
+function nativePlatformPackageName(platform: NodeJS.Platform, arch: string): string | undefined {
+  if (platform === "linux" && arch === "x64") {
+    return "@reckona/mreact-router-native-linux-x64-gnu";
+  }
+
+  if (platform === "darwin" && arch === "arm64") {
+    return "@reckona/mreact-router-native-darwin-arm64";
+  }
+
+  if (platform === "win32" && arch === "x64") {
+    return "@reckona/mreact-router-native-win32-x64-msvc";
+  }
+
+  return undefined;
+}

package/src/navigation-state.ts

@@ -0,0 +1,98 @@
+export type AppRouterNavigationType = "push" | "replace" | "pop" | "refresh";
+
+export interface AppRouterNavigationState {
+  pending: boolean;
+  from: string | null;
+  to: string | null;
+  type: AppRouterNavigationType | null;
+}
+
+export type AppRouterNavigationStateListener = (
+  state: AppRouterNavigationState,
+) => void;
+
+const idleNavigationState: AppRouterNavigationState = {
+  from: null,
+  pending: false,
+  to: null,
+  type: null,
+};
+
+export function getNavigationState(): AppRouterNavigationState {
+  const runtimeState = (globalThis as {
+    __mreactNavigationState?: { current?: unknown };
+  }).__mreactNavigationState?.current;
+  const normalized = normalizeNavigationState(runtimeState);
+
+  if (normalized !== undefined) {
+    return normalized;
+  }
+
+  return navigationStateFromDocument();
+}
+
+export function subscribeNavigationState(
+  listener: AppRouterNavigationStateListener,
+): () => void {
+  if (typeof window === "undefined") {
+    return () => undefined;
+  }
+
+  const handleNavigationStateChange = (event: Event) => {
+    const state = normalizeNavigationState((event as CustomEvent<unknown>).detail);
+
+    if (state !== undefined) {
+      listener(state);
+    }
+  };
+
+  window.addEventListener("mreact:navigation-state-change", handleNavigationStateChange);
+
+  return () => {
+    window.removeEventListener("mreact:navigation-state-change", handleNavigationStateChange);
+  };
+}
+
+function navigationStateFromDocument(): AppRouterNavigationState {
+  if (typeof document === "undefined") {
+    return { ...idleNavigationState };
+  }
+
+  const root = document.documentElement;
+
+  if (root.getAttribute("data-mreact-navigation-pending") !== "true") {
+    return { ...idleNavigationState };
+  }
+
+  return {
+    from: root.getAttribute("data-mreact-navigation-from"),
+    pending: true,
+    to: root.getAttribute("data-mreact-navigation-to"),
+    type: navigationType(root.getAttribute("data-mreact-navigation-type")),
+  };
+}
+
+function normalizeNavigationState(value: unknown): AppRouterNavigationState | undefined {
+  if (value === null || typeof value !== "object") {
+    return undefined;
+  }
+
+  const state = value as Partial<AppRouterNavigationState>;
+
+  if (typeof state.pending !== "boolean") {
+    return undefined;
+  }
+
+  return {
+    from: typeof state.from === "string" ? state.from : null,
+    pending: state.pending,
+    to: typeof state.to === "string" ? state.to : null,
+    type: navigationType(state.type),
+  };
+}
+
+function navigationType(value: unknown): AppRouterNavigationType | null {
+  return value === "push" || value === "replace" || value === "pop" || value === "refresh"
+    ? value
+    : null;
+}

package/src/navigation.ts

@@ -0,0 +1,215 @@
+import { parseCookieHeader } from "./cookies.js";
+
+const redirectErrorName = "MReactRedirect";
+const notFoundErrorName = "MReactNotFound";
+const rewriteHeaderName = "x-mreact-rewrite";
+const rewriteLocationSymbol = Symbol.for("mreact.router.rewriteLocation");
+
+export interface RedirectOptions {
+  status?: 301 | 302 | 303 | 307 | 308;
+}
+
+export type MiddlewareNext = undefined;
+
+export interface ParseSchema<T> {
+  parse(value: FormData): T;
+}
+
+// Strip leading C0 controls + ASCII whitespace per WHATWG URL parsing.
+// Browsers ignore these characters when resolving the Location header,
+// so attacker payloads must be rejected after the same normalization.
+function stripLeadingControlOrWhitespace(value: string): string {
+  let start = 0;
+
+  while (start < value.length && value.charCodeAt(start) <= 0x20) {
+    start += 1;
+  }
+
+  return value.slice(start);
+}
+
+// Returns true if `location` is safe to use as a same-origin Location header.
+// Allowed: path-absolute (`/foo`), query-only (`?x=1`), hash-only (`#x`),
+// relative (`foo`). Rejected: protocol-relative (`//evil`), backslash variants
+// (`/\evil`, `\\evil`), and anything with a scheme like `javascript:`.
+function isSafeInternalRedirect(location: string): boolean {
+  const trimmed = stripLeadingControlOrWhitespace(location);
+  if (trimmed === "") return false;
+  if (trimmed.startsWith("//")) return false;
+  if (trimmed.startsWith("/\\")) return false;
+  if (trimmed.startsWith("\\")) return false;
+  // Reject anything that parses as a URL with a scheme.
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(trimmed)) return false;
+  return true;
+}
+
+function isSafeExternalRedirect(location: string): boolean {
+  const trimmed = stripLeadingControlOrWhitespace(location);
+  const match = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(trimmed);
+  if (match === null || match[1] === undefined) return false;
+  const scheme = match[1].toLowerCase();
+  return scheme === "http" || scheme === "https";
+}
+
+function throwUnsafeRedirect(location: string): never {
+  throw new TypeError(
+    `unsafe redirect target: ${JSON.stringify(location)} - use redirectExternal() for off-site destinations and ensure the URL is http(s)`,
+  );
+}
+
+export function redirect(location: string, options: RedirectOptions = {}): never {
+  if (!isSafeInternalRedirect(location)) {
+    throwUnsafeRedirect(location);
+  }
+  throw Object.assign(new Error(`Redirect to ${location}`), {
+    location,
+    name: redirectErrorName,
+    status: options.status ?? 303,
+  });
+}
+
+export function redirectExternal(
+  location: string,
+  options: RedirectOptions = {},
+): never {
+  if (!isSafeExternalRedirect(location)) {
+    throwUnsafeRedirect(location);
+  }
+  throw Object.assign(new Error(`Redirect to ${location}`), {
+    location,
+    name: redirectErrorName,
+    status: options.status ?? 307,
+  });
+}
+
+export function redirect303(location: string, init: ResponseInit = {}): Response {
+  if (!isSafeInternalRedirect(location)) {
+    throwUnsafeRedirect(location);
+  }
+
+  const headers = new Headers(init.headers);
+  headers.set("location", location);
+
+  return new Response(null, {
+    ...init,
+    headers,
+    status: 303,
+  });
+}
+
+export function textError(message: string, status = 400, init: ResponseInit = {}): Response {
+  const headers = new Headers(init.headers);
+
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "text/plain; charset=utf-8");
+  }
+
+  return new Response(message, {
+    ...init,
+    headers,
+    status,
+  });
+}
+
+export async function parseForm(request: Request): Promise<FormData>;
+export async function parseForm<T>(request: Request, schema: ParseSchema<T>): Promise<T>;
+export async function parseForm<T>(
+  request: Request,
+  schema?: ParseSchema<T>,
+): Promise<FormData | T> {
+  const form = await request.formData();
+
+  return schema === undefined ? form : schema.parse(form);
+}
+
+export function notFound(): never {
+  throw Object.assign(new Error("Not Found"), {
+    name: notFoundErrorName,
+    status: 404,
+  });
+}
+
+export function next(): MiddlewareNext {
+  return undefined;
+}
+
+export function rewrite(location: string, init: ResponseInit = {}): Response {
+  const response = new Response(null, {
+    ...init,
+    status: init.status ?? 200,
+  });
+
+  Object.defineProperty(response, rewriteLocationSymbol, {
+    configurable: false,
+    enumerable: false,
+    value: location,
+  });
+
+  return response;
+}
+
+export function json(value: unknown, init?: ResponseInit): Response {
+  return Response.json(value, init);
+}
+
+export function html(value: string, init: ResponseInit = {}): Response {
+  if (init.headers === undefined) {
+    return new Response(value, {
+      ...init,
+      headers: { "content-type": "text/html; charset=utf-8" },
+    });
+  }
+
+  const headers = new Headers(init.headers);
+
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "text/html; charset=utf-8");
+  }
+
+  return new Response(value, {
+    ...init,
+    headers,
+  });
+}
+
+export function headers(request: Request): Headers {
+  return request.headers;
+}
+
+export interface RequestCookies {
+  entries(): IterableIterator<[string, string]>;
+  get(name: string): string | undefined;
+  has(name: string): boolean;
+}
+
+export function cookies(request: Request): RequestCookies {
+  let values: ReadonlyMap<string, string> | undefined;
+  const cookieValues = () => {
+    values ??= parseCookieHeader(request.headers.get("cookie"));
+    return values;
+  };
+
+  return {
+    entries: () => cookieValues().entries(),
+    get: (name) => cookieValues().get(name),
+    has: (name) => cookieValues().has(name),
+  };
+}
+
+export function rewriteLocation(response: Response): string | undefined {
+  const marked = (response as { [rewriteLocationSymbol]?: unknown })[rewriteLocationSymbol];
+
+  return typeof marked === "string"
+    ? marked
+    : response.headers.get(rewriteHeaderName) ?? undefined;
+}
+
+export function isRedirectError(error: unknown): error is Error & { location: string; status: number } {
+  return error instanceof Error &&
+    error.name === redirectErrorName &&
+    typeof (error as { location?: unknown }).location === "string";
+}
+
+export function isNotFoundError(error: unknown): boolean {
+  return error instanceof Error && error.name === notFoundErrorName;
+}

package/src/prerender-store.ts

@@ -0,0 +1,233 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { BuiltPrerenderedRoute } from "./build.js";
+import type { AppRouterPrerenderStore } from "./serve.js";
+
+export interface MemoryPrerenderStoreOptions {
+  backing?: Map<string, MemoryPrerenderStoreEntry>;
+  maxEntries?: number;
+  namespace?: string;
+  now?: () => number;
+  ttlMs?: number;
+}
+
+export interface MemoryPrerenderStoreEntry {
+  entry: BuiltPrerenderedRoute;
+  expiresAt: number;
+  lastAccessedAt: number;
+}
+
+export interface FileSystemPrerenderStoreOptions {
+  directory: string;
+  lockPollMs?: number;
+  lockTimeoutMs?: number;
+  namespace?: string;
+}
+
+export interface KeyValuePrerenderStoreAdapter {
+  delete(key: string): void | Promise<void>;
+  get(key: string): string | undefined | Promise<string | undefined>;
+  set(key: string, value: string, options?: { ttlMs?: number | undefined }): void | Promise<void>;
+  withLock?<T>(key: string, task: (token: string) => Promise<T>): Promise<T>;
+}
+
+export interface KeyValuePrerenderStoreOptions {
+  adapter: KeyValuePrerenderStoreAdapter;
+  namespace?: string;
+  ttlMs?: number;
+}
+
+export function createMemoryPrerenderStore(
+  options: MemoryPrerenderStoreOptions = {},
+): AppRouterPrerenderStore {
+  const backing = options.backing ?? new Map<string, MemoryPrerenderStoreEntry>();
+  const locks = new Map<string, Promise<void>>();
+  const namespace = options.namespace ?? "default";
+  const now = options.now ?? Date.now;
+  const maxEntries = options.maxEntries ?? Number.POSITIVE_INFINITY;
+  const ttlMs = options.ttlMs ?? Number.POSITIVE_INFINITY;
+
+  return {
+    delete(path) {
+      backing.delete(storeKey(namespace, path));
+    },
+    get(path) {
+      const key = storeKey(namespace, path);
+      const current = backing.get(key);
+
+      if (current === undefined) {
+        return undefined;
+      }
+
+      if (current.expiresAt <= now()) {
+        backing.delete(key);
+        return undefined;
+      }
+
+      current.lastAccessedAt = now();
+      return current.entry;
+    },
+    set(path, entry) {
+      backing.set(storeKey(namespace, path), {
+        entry,
+        expiresAt: now() + ttlMs,
+        lastAccessedAt: now(),
+      });
+      evictLeastRecentlyUsed(backing, namespace, maxEntries);
+    },
+    async withLock(path, task) {
+      const key = storeKey(namespace, path);
+      const previous = locks.get(key) ?? Promise.resolve();
+      let release: () => void = () => undefined;
+      const current = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      const queued = previous.then(() => current, () => current);
+      locks.set(key, queued);
+
+      await previous.catch(() => undefined);
+
+      try {
+        return await task();
+      } finally {
+        release();
+        if (locks.get(key) === queued) {
+          locks.delete(key);
+        }
+      }
+    },
+  };
+}
+
+export function createFileSystemPrerenderStore(
+  options: FileSystemPrerenderStoreOptions,
+): AppRouterPrerenderStore {
+  const namespace = options.namespace ?? "default";
+  const lockPollMs = options.lockPollMs ?? 5;
+  const lockTimeoutMs = options.lockTimeoutMs ?? 5_000;
+
+  return {
+    async delete(path) {
+      await rm(filePath(options.directory, namespace, path), { force: true });
+    },
+    async get(path) {
+      try {
+        return JSON.parse(
+          await readFile(filePath(options.directory, namespace, path), "utf8"),
+        ) as BuiltPrerenderedRoute;
+      } catch (error) {
+        if (isNodeError(error, "ENOENT")) {
+          return undefined;
+        }
+
+        throw error;
+      }
+    },
+    async set(path, entry) {
+      const target = filePath(options.directory, namespace, path);
+      const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+
+      await mkdir(dirname(target), { recursive: true });
+      await writeFile(temporary, JSON.stringify(entry), "utf8");
+      await rename(temporary, target);
+    },
+    async withLock(path, task) {
+      const lock = `${filePath(options.directory, namespace, path)}.lock`;
+      const startedAt = Date.now();
+
+      while (true) {
+        try {
+          await mkdir(lock, { recursive: false });
+          break;
+        } catch (error) {
+          if (!isNodeError(error, "EEXIST")) {
+            throw error;
+          }
+
+          if (Date.now() - startedAt > lockTimeoutMs) {
+            throw new Error(`Timed out acquiring prerender lock for ${path}.`);
+          }
+
+          await new Promise((resolve) => setTimeout(resolve, lockPollMs));
+        }
+      }
+
+      try {
+        return await task();
+      } finally {
+        await rm(lock, { force: true, recursive: true });
+      }
+    },
+  };
+}
+
+export function createKeyValuePrerenderStore(
+  options: KeyValuePrerenderStoreOptions,
+): AppRouterPrerenderStore {
+  const namespace = options.namespace ?? "default";
+  const store: AppRouterPrerenderStore = {
+    delete(path) {
+      return options.adapter.delete(keyValueStoreKey(namespace, path));
+    },
+    async get(path) {
+      const value = await options.adapter.get(keyValueStoreKey(namespace, path));
+
+      return value === undefined ? undefined : JSON.parse(value) as BuiltPrerenderedRoute;
+    },
+    set(path, entry) {
+      return options.adapter.set(
+        keyValueStoreKey(namespace, path),
+        JSON.stringify(entry),
+        { ttlMs: options.ttlMs },
+      );
+    },
+  };
+
+  if (options.adapter.withLock !== undefined) {
+    store.withLock = (path, task) =>
+      options.adapter.withLock?.(keyValueStoreKey(namespace, path), async () => await task()) ??
+        task();
+  }
+
+  return store;
+}
+
+function storeKey(namespace: string, path: string): string {
+  return `${namespace}\0${path}`;
+}
+
+function keyValueStoreKey(namespace: string, path: string): string {
+  return `${namespace}:${path}`;
+}
+
+function filePath(directory: string, namespace: string, path: string): string {
+  const digest = createHash("sha256")
+    .update(storeKey(namespace, path))
+    .digest("hex");
+
+  return join(directory, namespace, `${digest}.json`);
+}
+
+function isNodeError(error: unknown, code: string): boolean {
+  return error instanceof Error && (error as NodeJS.ErrnoException).code === code;
+}
+
+function evictLeastRecentlyUsed(
+  backing: Map<string, MemoryPrerenderStoreEntry>,
+  namespace: string,
+  maxEntries: number,
+): void {
+  if (!Number.isFinite(maxEntries) || maxEntries < 0) {
+    return;
+  }
+
+  const prefix = `${namespace}\0`;
+  const entries = Array.from(backing.entries())
+    .filter(([key]) => key.startsWith(prefix))
+    .sort(([, left], [, right]) => left.lastAccessedAt - right.lastAccessedAt);
+
+  for (const [key] of entries.slice(0, Math.max(0, entries.length - maxEntries))) {
+    backing.delete(key);
+  }
+}