@rangojs/router 0.31.0 → 0.33.0

package/dist/bin/runtime-EPUDEHO4.js

@@ -0,0 +1,596 @@
+import {
+  IS_BROWSER_DEBUG,
+  PREFETCH_FAILED_ROW,
+  PREFETCH_HEADER,
+  PREFETCH_INTENT,
+  WIRE,
+  WIRE_PREFIX,
+  buildParamsKey,
+  buildPrefetchKey,
+  buildSourceKey,
+  clearPrefetchInflight,
+  currentGeneration,
+  currentPrefetchEpoch,
+  debugLog,
+  getRangoState,
+  hasPrefetch,
+  isActionFenceActive,
+  isFragmentPassthroughEnabled,
+  isPrefetchCacheDisabled,
+  isPrefetchStale,
+  markPrefetchInflight,
+  paramsCandidateKeys,
+  paramsScopeLabel,
+  rememberParamsShape,
+  removePrefetch,
+  setInflightPromiseWithAliases,
+  stateEpoch,
+  storePrefetch
+} from "./chunk-3B7CKBRO.js";
+
+// src/browser/prefetch/resource-ready.ts
+function waitForViewportImages() {
+  if (typeof document === "undefined") return Promise.resolve();
+  const pending = Array.from(document.querySelectorAll("img")).filter((img) => {
+    if (img.complete) return false;
+    const rect = img.getBoundingClientRect();
+    return rect.bottom > 0 && rect.right > 0 && rect.top < window.innerHeight && rect.left < window.innerWidth;
+  });
+  if (pending.length === 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    const settled = /* @__PURE__ */ new Set();
+    const settle = (img) => {
+      if (settled.has(img)) return;
+      settled.add(img);
+      if (settled.size >= pending.length) resolve();
+    };
+    for (const img of pending) {
+      img.addEventListener("load", () => settle(img), { once: true });
+      img.addEventListener("error", () => settle(img), { once: true });
+      if (img.complete) settle(img);
+    }
+  });
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function waitForIdle(timeout = 200) {
+  if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+    return new Promise((resolve) => {
+      window.requestIdleCallback(() => resolve(), { timeout });
+    });
+  }
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+
+// src/browser/prefetch/queue.ts
+var maxConcurrent = 2;
+var IMAGE_WAIT_TIMEOUT = 2e3;
+function setPrefetchConcurrency(n) {
+  if (Number.isFinite(n) && n >= 1) {
+    maxConcurrent = Math.floor(n);
+  }
+}
+var active = 0;
+var queue = [];
+var queued = /* @__PURE__ */ new Set();
+var executing = /* @__PURE__ */ new Set();
+var abortControllers = /* @__PURE__ */ new Map();
+var drainScheduled = false;
+var drainGeneration = 0;
+function startExecution(key, execute) {
+  active++;
+  executing.add(key);
+  const ac = new AbortController();
+  abortControllers.set(key, ac);
+  execute(ac.signal).finally(() => {
+    abortControllers.delete(key);
+    if (executing.delete(key)) {
+      active--;
+    }
+    scheduleDrain();
+  });
+}
+function scheduleDrain() {
+  if (drainScheduled) return;
+  if (active >= maxConcurrent || queue.length === 0) return;
+  drainScheduled = true;
+  const gen = drainGeneration;
+  waitForIdle().then(
+    () => Promise.race([waitForViewportImages(), wait(IMAGE_WAIT_TIMEOUT)])
+  ).then(() => {
+    if (gen !== drainGeneration) return;
+    drainScheduled = false;
+    if (queue.length > 0) drain();
+  });
+}
+function drain() {
+  while (active < maxConcurrent && queue.length > 0) {
+    const item = queue.shift();
+    queued.delete(item.key);
+    startExecution(item.key, item.execute);
+  }
+}
+function enqueuePrefetch(key, execute) {
+  if (queued.has(key) || executing.has(key)) return;
+  queued.add(key);
+  queue.push({ key, execute });
+  scheduleDrain();
+}
+function normalizeForMatch(urlish) {
+  try {
+    const u = new URL(urlish, "http://placeholder");
+    for (const k of [...u.searchParams.keys()]) {
+      if (k.startsWith(WIRE_PREFIX)) u.searchParams.delete(k);
+    }
+    return u.pathname + u.search;
+  } catch {
+    return urlish;
+  }
+}
+function cancelAllPrefetches(keepUrl) {
+  queue.length = 0;
+  queued.clear();
+  drainScheduled = false;
+  drainGeneration++;
+  const normalizedKeep = keepUrl ? normalizeForMatch(keepUrl) : null;
+  for (const [key, ac] of abortControllers) {
+    const lastNul = key.lastIndexOf("\0");
+    const target = lastNul >= 0 ? key.substring(lastNul + 1) : "";
+    if (normalizedKeep && target && normalizeForMatch(target) === normalizedKeep)
+      continue;
+    ac.abort();
+    abortControllers.delete(key);
+    if (executing.delete(key)) {
+      active--;
+    }
+  }
+}
+function abortAllPrefetches() {
+  for (const ac of abortControllers.values()) {
+    ac.abort();
+  }
+  abortControllers.clear();
+  queue.length = 0;
+  queued.clear();
+  executing.clear();
+  active = 0;
+  drainScheduled = false;
+  drainGeneration++;
+}
+
+// src/browser/prefetch/policy.ts
+function shouldPrefetch() {
+  if (typeof window === "undefined") return false;
+  if (isPrefetchCacheDisabled()) return false;
+  const nav = typeof navigator !== "undefined" ? navigator : void 0;
+  if (nav?.connection?.saveData) return false;
+  if (typeof window.matchMedia === "function") {
+    try {
+      if (window.matchMedia("(prefers-reduced-data: reduce)").matches) {
+        return false;
+      }
+    } catch {
+    }
+  }
+  return true;
+}
+
+// src/browser/response-adapter.ts
+var NULL_BODY_STATUS = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+function isForeignRouterId(response, expectedId) {
+  const got = response.headers.get("X-RSC-Router-Id");
+  if (!got || !expectedId) return false;
+  return got !== expectedId;
+}
+function teeWithCompletion(response, onComplete, signal, silent = false) {
+  let settled = false;
+  const settle = (endedCleanly) => {
+    if (!settled) {
+      settled = true;
+      onComplete(endedCleanly);
+    }
+  };
+  if (!response.body || NULL_BODY_STATUS.has(response.status)) {
+    settle(true);
+    return response;
+  }
+  const [rscStream, trackingStream] = response.body.tee();
+  (async () => {
+    const reader = trackingStream.getReader();
+    const onAbort = signal ? reader.cancel.bind(reader) : void 0;
+    if (onAbort) signal.addEventListener("abort", onAbort, { once: true });
+    let cleanEof = false;
+    let tail = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          cleanEof = tail !== PREFETCH_FAILED_ROW;
+          break;
+        }
+        tail = (tail + String.fromCharCode(...value.slice(-5))).slice(-5);
+      }
+    } finally {
+      if (onAbort) signal.removeEventListener("abort", onAbort);
+      reader.releaseLock();
+      settle(cleanEof && !signal?.aborted);
+    }
+  })().catch((error) => {
+    if (!silent && !signal?.aborted) {
+      console.error("[Browser] Error reading tracking stream:", error);
+    }
+    settle(false);
+  });
+  return new Response(rscStream, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+
+// src/segment-fragments.ts
+var SEGMENT_FRAGMENT_CAPABILITY_HEADER = "X-Rango-Fragment-Passthrough";
+
+// src/browser/navigation-store-handle.ts
+var registeredStore = null;
+function getRegisteredStore() {
+  return registeredStore;
+}
+var readCommittedPage = null;
+function getCommittedPage() {
+  return readCommittedPage ? readCommittedPage() : null;
+}
+
+// src/browser/wire-protocol.ts
+function writePartialParams(url, init) {
+  const params = url.searchParams;
+  if (init.action !== void 0) params.set(WIRE.action, init.action);
+  else params.set(WIRE.partial, "true");
+  if (init.segmentIds.length > 0 || init.emptySegments === "send") {
+    params.set(WIRE.segments, init.segmentIds.join(","));
+  }
+  if (init.stale) params.set(WIRE.stale, "true");
+  if (init.boundary) params.set(WIRE.boundary, init.boundary);
+  if (init.version) params.set(WIRE.version, init.version);
+  if (init.routerId) params.set(WIRE.routerId, init.routerId);
+  if (init.rewriteTarget) params.set(WIRE.rewriteTarget, init.rewriteTarget);
+  if (init.fill) params.set(WIRE.fill, "1");
+  return url;
+}
+
+// src/browser/prefetch/fetch.ts
+var decoder = null;
+var PREFETCH_FETCH_TIMEOUT_MS = 3e4;
+function setPrefetchDecoder(fn) {
+  decoder = fn;
+}
+function makeRespawn(storageKey, reserve, slot, epoch) {
+  return () => {
+    const [body, nextReserve] = reserve.tee();
+    const payload = decoder(Promise.resolve(new Response(body)));
+    payload.catch(() => {
+    });
+    const entry = {
+      payload,
+      streamComplete: Promise.resolve(),
+      scope: slot.scope,
+      paramsLabel: slot.paramsLabel,
+      epoch,
+      complete: true,
+      dispose: () => {
+        nextReserve.cancel().catch(() => {
+        });
+      }
+    };
+    entry.respawn = makeRespawn(storageKey, nextReserve, slot, epoch);
+    payload.catch(() => removePrefetch(storageKey, entry));
+    return entry;
+  };
+}
+function committedHref() {
+  const committed = getRegisteredStore()?.getSegmentState().currentUrl;
+  return committed ? new URL(committed, window.location.origin).href : window.location.href;
+}
+function withoutHash(href) {
+  const hash = href.indexOf("#");
+  return hash === -1 ? href : href.slice(0, hash);
+}
+function isSamePage(url, sourceHref) {
+  try {
+    const target = new URL(url, window.location.origin);
+    const source = new URL(sourceHref, window.location.origin);
+    return target.pathname + target.search === source.pathname + source.search;
+  } catch {
+    return false;
+  }
+}
+function buildPrefetchUrl(url, segmentIds, version, routerId) {
+  let targetUrl;
+  try {
+    targetUrl = new URL(url, window.location.origin);
+  } catch {
+    return null;
+  }
+  if (targetUrl.origin !== window.location.origin) {
+    return null;
+  }
+  return writePartialParams(targetUrl, {
+    segmentIds,
+    emptySegments: "omit",
+    version,
+    routerId,
+    rewriteTarget: getRegisteredStore()?.getHistoryEntryMemory()?.rewriteTarget
+  });
+}
+function prefetchStorageSlot(forceSourceScope, scopeHeader, sourceKey, wildcardKey, stateKey, targetUrl) {
+  if (forceSourceScope || scopeHeader === "source") {
+    return { scope: "source", key: sourceKey };
+  }
+  const label = paramsScopeLabel(scopeHeader);
+  if (label === void 0) return { scope: "wildcard", key: wildcardKey };
+  return {
+    scope: "params",
+    key: buildParamsKey(stateKey, label, targetUrl),
+    paramsLabel: label
+  };
+}
+function executePrefetchFetch(wildcardKey, sourceKey, sourceHref, targetUrl, forceSourceScope, rangoState, intent, expectedRouterId, signal) {
+  const gen = currentGeneration();
+  const epoch = currentPrefetchEpoch();
+  const inflightKeys = forceSourceScope ? [sourceKey] : [wildcardKey, sourceKey];
+  for (const k of inflightKeys) markPrefetchInflight(k);
+  let publishedKey;
+  let publishedEntry;
+  const timeoutController = new AbortController();
+  const timeoutId = setTimeout(() => {
+    timeoutController.abort();
+    if (publishedKey !== void 0 && publishedEntry !== void 0) {
+      removePrefetch(publishedKey, publishedEntry);
+    }
+  }, PREFETCH_FETCH_TIMEOUT_MS);
+  let effectiveSignal;
+  if (!signal) {
+    effectiveSignal = timeoutController.signal;
+  } else if (typeof AbortSignal.any === "function") {
+    effectiveSignal = AbortSignal.any([signal, timeoutController.signal]);
+  } else {
+    effectiveSignal = timeoutController.signal;
+    if (signal.aborted) timeoutController.abort();
+    else
+      signal.addEventListener("abort", () => timeoutController.abort(), {
+        once: true
+      });
+  }
+  const promise = fetch(targetUrl.toString(), {
+    priority: "low",
+    // During an action's flight the state is not rotated, so the old
+    // X-Rango-State still matches the Vary-keyed HTTP-cache entry; bypass it so
+    // a prefetch fetches fresh rather than warming the map with stale bytes (the
+    // fence's HTTP-cache-bypass requirement applies to prefetch as well as
+    // navigation fetches).
+    ...isActionFenceActive() && { cache: "no-store" },
+    signal: effectiveSignal,
+    headers: {
+      "X-Rango-State": rangoState,
+      "X-RSC-Router-Client-Path": sourceHref,
+      [PREFETCH_HEADER]: intent ? PREFETCH_INTENT : "1",
+      ...isFragmentPassthroughEnabled() && {
+        [SEGMENT_FRAGMENT_CAPABILITY_HEADER]: "1"
+      }
+    }
+  }).then((response) => {
+    if (!response.ok || !decoder) return null;
+    if (response.headers.has("X-RSC-Reload") || response.headers.has("X-RSC-Redirect")) {
+      return null;
+    }
+    if (isForeignRouterId(response, expectedRouterId)) {
+      return null;
+    }
+    const slot = prefetchStorageSlot(
+      forceSourceScope,
+      response.headers.get("x-rsc-prefetch-scope"),
+      sourceKey,
+      wildcardKey,
+      stateEpoch(rangoState),
+      targetUrl
+    );
+    const storageKey = slot.key;
+    let resolveStreamComplete;
+    let endedCleanly = false;
+    const streamComplete = new Promise((resolve) => {
+      resolveStreamComplete = resolve;
+    });
+    const tracked = teeWithCompletion(
+      response,
+      (clean) => {
+        endedCleanly = clean;
+        resolveStreamComplete();
+      },
+      effectiveSignal,
+      // Speculative prefetch: a never-consumed/aborted stream error is benign.
+      true
+    );
+    let decodeSource = tracked;
+    let reserve;
+    if (tracked.body) {
+      const [decodeBody, reserveBody] = tracked.body.tee();
+      decodeSource = new Response(decodeBody, { headers: tracked.headers });
+      reserve = reserveBody;
+    }
+    const payload = decoder(Promise.resolve(decodeSource));
+    payload.catch(() => {
+    });
+    const entry = {
+      payload,
+      streamComplete,
+      scope: slot.scope,
+      paramsLabel: slot.paramsLabel,
+      epoch,
+      complete: false,
+      stallTimer: timeoutId,
+      ...reserve && {
+        dispose: () => {
+          reserve.cancel().catch(() => {
+          });
+        }
+      }
+    };
+    storePrefetch(storageKey, entry, gen, inflightKeys[0]);
+    if (slot.paramsLabel !== void 0) {
+      rememberParamsShape(targetUrl, slot.paramsLabel);
+    }
+    publishedKey = storageKey;
+    publishedEntry = entry;
+    payload.catch(() => removePrefetch(storageKey, entry));
+    streamComplete.then(() => {
+      if (!endedCleanly) removePrefetch(storageKey, entry);
+    });
+    Promise.allSettled([payload, streamComplete]).then(([decode]) => {
+      clearTimeout(timeoutId);
+      if (decode.status === "fulfilled" && endedCleanly) {
+        entry.complete = true;
+        if (reserve) {
+          entry.respawn = makeRespawn(storageKey, reserve, slot, epoch);
+          if (!isPrefetchStale(entry) && !hasPrefetch(storageKey)) {
+            storePrefetch(storageKey, entry.respawn(), gen);
+          }
+        }
+      }
+    });
+    return entry;
+  }).catch(() => null).finally(() => {
+    clearPrefetchInflight(inflightKeys[0]);
+    if (publishedKey === void 0) clearTimeout(timeoutId);
+  });
+  setInflightPromiseWithAliases(inflightKeys, promise);
+  return promise;
+}
+function hasPrefetchHit(forceSourceScope, wildcardKey, sourceKey, stateKey, targetUrl) {
+  if (forceSourceScope) return hasPrefetch(sourceKey);
+  return hasPrefetch(wildcardKey) || hasPrefetch(sourceKey) || paramsCandidateKeys(stateKey, targetUrl, getCommittedPage()).some(
+    hasPrefetch
+  );
+}
+function prefetchDirect(url, segmentIds, version, routerId, prefetchKey) {
+  if (!shouldPrefetch()) return;
+  const targetUrl = buildPrefetchUrl(url, segmentIds, version, routerId);
+  if (!targetUrl) return;
+  const forceSourceScope = prefetchKey === ":source";
+  const sourceHref = committedHref();
+  if (!forceSourceScope && isSamePage(url, sourceHref)) {
+    return;
+  }
+  const rangoState = getRangoState();
+  const stateKey = stateEpoch(rangoState);
+  const wildcardKey = buildPrefetchKey(stateKey, targetUrl);
+  const sourceKey = buildSourceKey(stateKey, sourceHref, targetUrl);
+  if (hasPrefetchHit(
+    forceSourceScope,
+    wildcardKey,
+    sourceKey,
+    stateKey,
+    targetUrl
+  )) {
+    if (IS_BROWSER_DEBUG) {
+      debugLog("[prefetch] direct dedup (key already exists)", {
+        url,
+        wildcardKey,
+        sourceKey,
+        forceSourceScope
+      });
+    }
+    return;
+  }
+  if (IS_BROWSER_DEBUG) {
+    debugLog("[prefetch] direct fetch", {
+      url,
+      wildcardKey,
+      sourceKey,
+      source: sourceHref,
+      forceSourceScope
+    });
+  }
+  executePrefetchFetch(
+    wildcardKey,
+    sourceKey,
+    sourceHref,
+    targetUrl,
+    forceSourceScope,
+    rangoState,
+    true,
+    routerId
+  );
+}
+function prefetchQueued(url, segmentIds, version, routerId, prefetchKey) {
+  if (!shouldPrefetch()) return "";
+  const targetUrl = buildPrefetchUrl(url, segmentIds, version, routerId);
+  if (!targetUrl) return "";
+  const forceSourceScope = prefetchKey === ":source";
+  const sourceHref = committedHref();
+  if (!forceSourceScope && isSamePage(url, sourceHref)) {
+    return "";
+  }
+  const rangoState = getRangoState();
+  const stateKey = stateEpoch(rangoState);
+  const wildcardKey = buildPrefetchKey(stateKey, targetUrl);
+  const sourceKey = buildSourceKey(stateKey, sourceHref, targetUrl);
+  const queueKey = forceSourceScope ? sourceKey : wildcardKey;
+  if (hasPrefetchHit(
+    forceSourceScope,
+    wildcardKey,
+    sourceKey,
+    stateKey,
+    targetUrl
+  )) {
+    if (IS_BROWSER_DEBUG) {
+      debugLog("[prefetch] queued dedup (key already exists)", {
+        url,
+        wildcardKey,
+        sourceKey,
+        forceSourceScope
+      });
+    }
+    return queueKey;
+  }
+  enqueuePrefetch(queueKey, (signal) => {
+    const liveState = getRangoState();
+    if (stateEpoch(liveState) !== stateKey) return Promise.resolve();
+    if (hasPrefetchHit(
+      forceSourceScope,
+      wildcardKey,
+      sourceKey,
+      stateKey,
+      targetUrl
+    )) {
+      return Promise.resolve();
+    }
+    const committed = committedHref();
+    if (withoutHash(committed) !== withoutHash(sourceHref) || !forceSourceScope && isSamePage(url, committed)) {
+      return Promise.resolve();
+    }
+    return executePrefetchFetch(
+      wildcardKey,
+      sourceKey,
+      sourceHref,
+      targetUrl,
+      forceSourceScope,
+      liveState,
+      false,
+      routerId,
+      signal
+    ).then(() => {
+    });
+  });
+  return queueKey;
+}
+export {
+  abortAllPrefetches,
+  cancelAllPrefetches,
+  prefetchDirect,
+  prefetchQueued,
+  setPrefetchConcurrency,
+  setPrefetchDecoder
+};