@rangojs/router 0.32.0 → 0.33.0

package/README.md

@@ -445,8 +445,9 @@ that per link with `prefetch`: `"hover"`, `"viewport"`, `"render"`,
 When a navigation has been fully prefetched, the page appears finished, with
 no skeleton or loading flash. If you click while a prefetch is still loading,
 the navigation reuses that request instead of starting a new one. Every
-action clears the prefetch caches by default, so a prefetched page can't
-show data from before a mutation.
+action marks prefetches stale by default: a click on a prefetch made before
+the action shows the prefetched page at once, then revalidates it. Call
+`invalidateClientCache()` for a full flush.
 
 You can do the same caching work at other times:
 

package/dist/bin/browser-7KIJ5HSV.js

@@ -0,0 +1,15 @@
+// src/deps/browser.ts
+import {
+  createFromReadableStream,
+  createFromFetch,
+  setServerCallback,
+  encodeReply,
+  createTemporaryReferenceSet
+} from "@vitejs/plugin-rsc/browser";
+export {
+  createFromFetch,
+  createFromReadableStream,
+  createTemporaryReferenceSet,
+  encodeReply,
+  setServerCallback
+};

package/dist/bin/chunk-3B7CKBRO.js

@@ -0,0 +1,463 @@
+// src/internal-debug.ts
+var INTERNAL_RANGO_DEBUG = typeof process !== "undefined" && Boolean(process.env?.INTERNAL_RANGO_DEBUG);
+
+// src/browser/logging.ts
+var IS_BROWSER_DEBUG = INTERNAL_RANGO_DEBUG;
+function debugLog(msg, ...args) {
+  if (INTERNAL_RANGO_DEBUG) {
+    console.log(msg, ...args);
+  }
+}
+
+// src/browser/cookie-name.ts
+var DEFAULT_STATE_COOKIE_PREFIX = "rango-state";
+function getRawCookieValue(cookieString, name) {
+  if (!cookieString) return null;
+  const target = name + "=";
+  for (const part of cookieString.split(";")) {
+    const trimmed = part.trim();
+    if (trimmed.startsWith(target)) {
+      const value = trimmed.slice(target.length);
+      return value === "" ? null : value;
+    }
+  }
+  return null;
+}
+function encodeStateValue(version, timestamp, write = 0) {
+  const base = `${encodeURIComponent(version)}:${timestamp}`;
+  return write === 0 ? base : `${base}:${write}`;
+}
+function decodeStateValue(raw) {
+  const colon = raw.indexOf(":");
+  if (colon <= 0) return null;
+  const parts = raw.slice(colon + 1).split(":");
+  if (parts.length > 2) return null;
+  const timestamp = parseStatePart(parts[0]);
+  const write = parts.length === 2 ? parseStatePart(parts[1]) : 0;
+  if (timestamp === null || write === null) return null;
+  let version;
+  try {
+    version = decodeURIComponent(raw.slice(0, colon));
+  } catch {
+    return null;
+  }
+  return { version, timestamp, write };
+}
+function parseStatePart(part) {
+  if (part === "") return null;
+  const value = Number(part);
+  return Number.isFinite(value) ? value : null;
+}
+function stateEpoch(raw) {
+  const first = raw.indexOf(":");
+  if (first < 0) return raw;
+  const second = raw.indexOf(":", first + 1);
+  return second < 0 ? raw : raw.slice(0, second);
+}
+function mintStateValue(version, prevRaw) {
+  const prevTs = prevRaw ? decodeStateValue(prevRaw)?.timestamp ?? 0 : 0;
+  const ts = Math.max(Date.now(), prevTs + 1);
+  return encodeStateValue(version, ts);
+}
+function stateCookieAttributes(secure) {
+  return `; Path=/; SameSite=Lax${secure ? "; Secure" : ""}`;
+}
+function serializeStateCookie(name, value, secure) {
+  return `${name}=${value}${stateCookieAttributes(secure)}`;
+}
+
+// src/browser/rango-state.ts
+var cookieName = DEFAULT_STATE_COOKIE_PREFIX;
+var currentVersion = "0";
+var mirror = null;
+var cookieBacked = false;
+var externalRotationObserver = null;
+var externalWriteObserver = null;
+function notifyExternalRotation(value) {
+  externalRotationObserver?.(value);
+}
+function readCookie(name) {
+  if (typeof document === "undefined") return { readable: false, value: null };
+  let raw;
+  try {
+    raw = document.cookie;
+  } catch {
+    return { readable: false, value: null };
+  }
+  return { readable: true, value: getRawCookieValue(raw, name) };
+}
+function writeCookie(name, value) {
+  if (typeof document === "undefined") return;
+  const secure = typeof location !== "undefined" && location.protocol === "https:";
+  try {
+    document.cookie = serializeStateCookie(name, value, secure);
+  } catch {
+  }
+}
+function mintValue() {
+  return mintStateValue(currentVersion, mirror);
+}
+function getRangoState() {
+  const read = readCookie(cookieName);
+  if (!read.readable) {
+    return mirror ?? "0:0";
+  }
+  if (read.value !== null) {
+    if (read.value !== mirror) {
+      const rotated = mirror === null || stateEpoch(mirror) !== stateEpoch(read.value);
+      mirror = read.value;
+      cookieBacked = true;
+      if (rotated) notifyExternalRotation(read.value);
+      else externalWriteObserver?.();
+    } else {
+      cookieBacked = true;
+    }
+    return read.value;
+  }
+  if (cookieBacked) {
+    mirror = mintValue();
+    cookieBacked = false;
+    writeCookie(cookieName, mirror);
+    notifyExternalRotation(mirror);
+  } else if (mirror === null) {
+    mirror = mintValue();
+    writeCookie(cookieName, mirror);
+  }
+  return mirror;
+}
+
+// src/wire-params.ts
+var WIRE = {
+  /** A navigation or prefetch: `true`. */
+  partial: "_rsc_partial",
+  /** The mounted segment ids, comma-joined. */
+  segments: "_rsc_segments",
+  /** A JS server action's id, in place of `partial`. */
+  action: "_rsc_action",
+  /** The client's build version (version-mismatch reload). */
+  version: "_rsc_v",
+  /** The client's router id (app-switch reload). */
+  routerId: "_rsc_rid",
+  /** The rewrite target of the page on screen (#1144). */
+  rewriteTarget: "_rsc_rt",
+  /** A stale request: `true` (router/navigation-snapshot.ts). */
+  stale: "_rsc_stale",
+  /**
+   * The id of an action's error boundary on screen that a stale request
+   * holds: read only beside `stale` (router/navigation-snapshot.ts).
+   */
+  boundary: "_rsc_boundary",
+  /** A fill request (docs/design/prefetch-false.md): `1`. */
+  fill: "_rsc_fill",
+  /** A loader fetch's loader id (rsc/loader-fetch.ts). */
+  loader: "_rsc_loader",
+  /** A loader fetch's params, JSON: a query param, or a form field on a POST. */
+  loaderParams: "_rsc_loader_params",
+  /** The forced-MISS marker of a degraded PPR shell reload (rsc/shell-serve.ts). */
+  shellMiss: "_rsc_shell",
+  /** A connection warmup HEAD request (browser/connection-warmup.ts). */
+  warmup: "_rsc_warmup"
+};
+var WIRE_PREFIX = "_rsc_";
+
+// src/prefetch-source-scope.ts
+var PARAMS_SCOPE_PREFIX = "params; ";
+function formatSourceLabel(shape, page) {
+  const parts = [];
+  if (shape.keys) {
+    parts.push(
+      "$k=" + Object.keys(page.params).sort().map(encodeURIComponent).join(",")
+    );
+  }
+  if (shape.route) parts.push(entry("$r", page.routeName));
+  for (const name of shape.names) {
+    parts.push(entry(encodeURIComponent(name), page.params[name]));
+  }
+  return parts.join("&");
+}
+function entry(name, value) {
+  return value === void 0 ? name : name + "=" + encodeURIComponent(value);
+}
+function paramsScopeLabel(header) {
+  if (!header?.startsWith(PARAMS_SCOPE_PREFIX)) return void 0;
+  return header.slice(PARAMS_SCOPE_PREFIX.length);
+}
+function parseSourceShape(label) {
+  let keys = false;
+  let route = false;
+  const names = [];
+  for (const part of label.split("&")) {
+    if (part === "") continue;
+    const eq = part.indexOf("=");
+    const name = eq === -1 ? part : part.slice(0, eq);
+    if (name === "$k") keys = true;
+    else if (name === "$r") route = true;
+    else names.push(decodeURIComponent(name));
+  }
+  return { keys, route, names: names.sort() };
+}
+function sourceShapeId(shape) {
+  return (shape.keys ? "k" : "") + (shape.route ? "r" : "") + ":" + shape.names.map(encodeURIComponent).join(",");
+}
+
+// src/browser/prefetch/loader.ts
+var runtime = null;
+var runtimePromise = null;
+var decoder = null;
+var concurrency;
+var requestGeneration = 0;
+function loadRuntime() {
+  if (runtime) return Promise.resolve(runtime);
+  if (!runtimePromise) {
+    runtimePromise = import("./runtime-EPUDEHO4.js").then(
+      (loaded) => {
+        runtime = loaded;
+        if (decoder) loaded.setPrefetchDecoder(decoder);
+        if (concurrency !== void 0) {
+          loaded.setPrefetchConcurrency(concurrency);
+        }
+        return loaded;
+      },
+      (error) => {
+        runtimePromise = null;
+        throw error;
+      }
+    );
+  }
+  return runtimePromise;
+}
+function withRuntime(run) {
+  if (runtime) {
+    run(runtime);
+    return;
+  }
+  const generation2 = requestGeneration;
+  void loadRuntime().then((loaded) => {
+    if (generation2 === requestGeneration) run(loaded);
+  }).catch(() => {
+  });
+}
+function prefetchDirect(url, segmentIds, version, routerId, prefetchKey) {
+  withRuntime(
+    (loaded) => loaded.prefetchDirect(url, segmentIds, version, routerId, prefetchKey)
+  );
+}
+function prefetchQueued(url, segmentIds, version, routerId, prefetchKey) {
+  withRuntime(
+    (loaded) => loaded.prefetchQueued(url, segmentIds, version, routerId, prefetchKey)
+  );
+}
+function schedulePrefetchWhenRouterIdle(eventController, callback) {
+  const state = eventController.getState();
+  if (state.state === "idle" && !state.isStreaming) {
+    callback();
+    return;
+  }
+  const unsubscribe = eventController.subscribe(() => {
+    const nextState = eventController.getState();
+    if (nextState.state === "idle" && !nextState.isStreaming) {
+      unsubscribe();
+      callback();
+    }
+  });
+  return unsubscribe;
+}
+
+// src/browser/notify-listeners.ts
+function notifyListeners(entries, notify, isActive, shouldContinue) {
+  const errors = [];
+  for (const entry2 of entries) {
+    if (shouldContinue && !shouldContinue()) break;
+    if (isActive && !isActive(entry2)) continue;
+    try {
+      notify(entry2);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1) {
+    throw new AggregateError(errors, "Multiple listener callbacks failed");
+  }
+}
+
+// src/browser/prefetch/cache.ts
+var cacheTTL = 3e5;
+var fragmentPassthroughEnabled = true;
+var maxPrefetchCacheSize = 100;
+function isPrefetchCacheDisabled() {
+  return cacheTTL <= 0;
+}
+var cache = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Set();
+var earliestTimestamp = Infinity;
+var inflightPromises = /* @__PURE__ */ new Map();
+var inflightAliases = /* @__PURE__ */ new Map();
+var adoptedKeys = /* @__PURE__ */ new Set();
+var paramsShapes = /* @__PURE__ */ new Map();
+var generation = 0;
+var staleEpoch = 0;
+function buildPrefetchKey(prefix, targetUrl) {
+  const normalizedTarget = new URL(targetUrl);
+  normalizedTarget.searchParams.delete(WIRE.segments);
+  return prefix + "\0" + normalizedTarget.pathname + normalizedTarget.search;
+}
+function buildSourceKey(rangoState, sourceHref, targetUrl) {
+  return rangoState + "\0" + sourceHref + "\0" + targetUrl.pathname + targetUrl.search;
+}
+function buildParamsKey(rangoState, label, targetUrl) {
+  return buildPrefetchKey(rangoState + "\0p:" + label, targetUrl);
+}
+function rememberParamsShape(targetUrl, label) {
+  const target = buildPrefetchKey("", targetUrl);
+  const shape = parseSourceShape(label);
+  let shapes = paramsShapes.get(target);
+  if (!shapes) {
+    if (paramsShapes.size >= maxPrefetchCacheSize) {
+      const oldest = paramsShapes.keys().next().value;
+      if (oldest !== void 0) paramsShapes.delete(oldest);
+    }
+    shapes = /* @__PURE__ */ new Map();
+    paramsShapes.set(target, shapes);
+  }
+  shapes.set(sourceShapeId(shape), shape);
+}
+function paramsCandidateKeys(rangoState, targetUrl, page) {
+  if (!page) return [];
+  const shapes = paramsShapes.get(buildPrefetchKey("", targetUrl));
+  if (!shapes) return [];
+  return [...shapes.values()].sort((a, b) => weightOf(b) - weightOf(a)).map(
+    (shape) => buildParamsKey(rangoState, formatSourceLabel(shape, page), targetUrl)
+  );
+}
+var weightOf = (shape) => shape.names.length + (shape.route ? 1 : 0) + (shape.keys ? 1 : 0);
+function forEachAlias(key, fn) {
+  const aliases = inflightAliases.get(key);
+  if (aliases) {
+    for (const k of aliases) fn(k);
+  } else {
+    fn(key);
+  }
+}
+function hasPrefetch(key) {
+  if (inflight.has(key)) return true;
+  if (cacheTTL <= 0) return false;
+  const entry2 = cache.get(key);
+  if (!entry2) return false;
+  if (Date.now() - entry2.timestamp > cacheTTL || isPrefetchStale(entry2.entry)) {
+    entry2.entry.dispose?.();
+    cache.delete(key);
+    return false;
+  }
+  return true;
+}
+function storePrefetch(key, entry2, fetchGeneration, inflightKey = key) {
+  if (cacheTTL <= 0) return;
+  if (fetchGeneration !== generation) return;
+  if (adoptedKeys.has(inflightKey)) {
+    forEachAlias(inflightKey, (k) => adoptedKeys.delete(k));
+    return;
+  }
+  const now = Date.now();
+  if (now - earliestTimestamp > cacheTTL) {
+    let min = Infinity;
+    for (const [k, cached] of cache) {
+      if (now - cached.timestamp > cacheTTL) {
+        cached.entry.dispose?.();
+        cache.delete(k);
+      } else if (cached.timestamp < min) {
+        min = cached.timestamp;
+      }
+    }
+    earliestTimestamp = min;
+  }
+  if (cache.size >= maxPrefetchCacheSize) {
+    const oldest = cache.keys().next().value;
+    if (oldest) {
+      cache.get(oldest)?.entry.dispose?.();
+      cache.delete(oldest);
+    }
+  }
+  cache.set(key, { entry: entry2, timestamp: now });
+  if (now < earliestTimestamp) earliestTimestamp = now;
+}
+function removePrefetch(key, entry2) {
+  if (cache.get(key)?.entry === entry2) {
+    entry2.dispose?.();
+    cache.delete(key);
+  }
+}
+function currentGeneration() {
+  return generation;
+}
+function currentPrefetchEpoch() {
+  return staleEpoch;
+}
+function isPrefetchStale(entry2) {
+  return entry2.epoch < staleEpoch;
+}
+function markPrefetchInflight(key) {
+  inflight.add(key);
+}
+function setInflightPromiseWithAliases(keys, promise) {
+  for (const k of keys) {
+    inflightPromises.set(k, promise);
+    inflightAliases.set(k, keys);
+  }
+}
+function clearPrefetchInflight(key) {
+  forEachAlias(key, (k) => {
+    inflight.delete(k);
+    inflightPromises.delete(k);
+    inflightAliases.delete(k);
+    adoptedKeys.delete(k);
+  });
+}
+function isFragmentPassthroughEnabled() {
+  return fragmentPassthroughEnabled;
+}
+
+// src/browser/action-fence.ts
+var fenceCount = 0;
+function isActionFenceActive() {
+  return fenceCount > 0;
+}
+
+// src/prefetch-markers.ts
+var PREFETCH_HEADER = "X-Rango-Prefetch";
+var PREFETCH_INTENT = "intent";
+var PREFETCH_FAILED_ROW = ":H_0\n";
+
+export {
+  IS_BROWSER_DEBUG,
+  debugLog,
+  notifyListeners,
+  stateEpoch,
+  getRangoState,
+  WIRE,
+  WIRE_PREFIX,
+  paramsScopeLabel,
+  isPrefetchCacheDisabled,
+  buildPrefetchKey,
+  buildSourceKey,
+  buildParamsKey,
+  rememberParamsShape,
+  paramsCandidateKeys,
+  hasPrefetch,
+  storePrefetch,
+  removePrefetch,
+  currentGeneration,
+  currentPrefetchEpoch,
+  isPrefetchStale,
+  markPrefetchInflight,
+  setInflightPromiseWithAliases,
+  clearPrefetchInflight,
+  isFragmentPassthroughEnabled,
+  isActionFenceActive,
+  PREFETCH_HEADER,
+  PREFETCH_INTENT,
+  PREFETCH_FAILED_ROW,
+  prefetchDirect,
+  prefetchQueued,
+  schedulePrefetchWhenRouterIdle
+};

package/dist/bin/chunk-524VACCG.js

@@ -0,0 +1,71 @@
+// src/vite/discovery/state.ts
+var VIRTUAL_ROUTES_MANIFEST_ID = "virtual:rsc-router/routes-manifest";
+var VIRTUAL_LOADER_MANIFEST_ID = "virtual:rsc-router/loader-manifest";
+function createClientUrlRevalidateIndex() {
+  return { fileByKey: /* @__PURE__ */ new Map(), filesByGroup: /* @__PURE__ */ new Map() };
+}
+function recordDiscoveryFailure(state, err) {
+  state.lastDiscoveryError = {
+    message: err?.message ?? String(err),
+    at: Date.now()
+  };
+}
+function canRefreshRuntimeDiscovery(state) {
+  return state.perRouterManifests.length > 0 || !!state.lastDiscoveryError;
+}
+function createDiscoveryState(entryPath, opts) {
+  return {
+    resolvedEntryPath: entryPath,
+    projectRoot: "",
+    isBuildMode: false,
+    viteCommand: "build",
+    viteMode: "production",
+    userResolveAlias: void 0,
+    userRunnerConfig: void 0,
+    userResolvePlugins: [],
+    scanFilter: void 0,
+    cachedRouterFiles: void 0,
+    opts,
+    mergedRouteManifest: null,
+    perRouterManifests: [],
+    perRouterTrieMap: /* @__PURE__ */ new Map(),
+    perRouterPrecomputedMap: /* @__PURE__ */ new Map(),
+    perRouterManifestDataMap: /* @__PURE__ */ new Map(),
+    clientUrlSourceByReferenceId: /* @__PURE__ */ new Map(),
+    clientUrlProjectionMap: /* @__PURE__ */ new Map(),
+    clientUrlRevalidate: opts?.clientUrlRevalidate ?? createClientUrlRevalidateIndex(),
+    prerenderManifestEntries: null,
+    staticManifestEntries: null,
+    shellCandidates: null,
+    prerenderPayloadValues: null,
+    shellPhaseTempServer: null,
+    serverBuildGraph: null,
+    clientBuildGraph: null,
+    ssrBundle: null,
+    versionModuleFiles: /* @__PURE__ */ new Map(),
+    buildData: [],
+    handlerChunkInfoMap: /* @__PURE__ */ new Map(),
+    staticHandlerChunkInfoMap: /* @__PURE__ */ new Map(),
+    onDemandHandlerIds: /* @__PURE__ */ new Map(),
+    rscEntryFileName: null,
+    resolvedPrerenderModules: void 0,
+    resolvedStaticModules: void 0,
+    discoveryDone: null,
+    devDiscoveryEpoch: opts?.preset === "cloudflare" ? Date.now() : void 0,
+    devServerOrigin: null,
+    devServer: null,
+    transitionWhenOverlay: null,
+    selfWrittenGenFiles: /* @__PURE__ */ new Map(),
+    SELF_WRITE_WINDOW_MS: 5e3,
+    lastDiscoveryError: null
+  };
+}
+
+export {
+  VIRTUAL_ROUTES_MANIFEST_ID,
+  VIRTUAL_LOADER_MANIFEST_ID,
+  createClientUrlRevalidateIndex,
+  recordDiscoveryFailure,
+  canRefreshRuntimeDiscovery,
+  createDiscoveryState
+};