@absolutejs/absolute 0.20.0-beta.174 → 0.20.0-beta.175

package/dist/react/components/client.js

@@ -0,0 +1,506 @@
+// @bun
+"use client";
+
+// src/react/router/Link.tsx
+import {
+  useContext
+} from "react";
+
+// src/dev/client/cspNonce.ts
+var applyPageNonce = (element) => {
+  const nonce = readPageNonce();
+  if (nonce)
+    element.nonce = nonce;
+  return element;
+};
+var readPageNonce = () => {
+  if (typeof document === "undefined")
+    return;
+  const carrier = document.querySelector("script[nonce], style[nonce]");
+  return carrier?.nonce || undefined;
+};
+
+// src/client/prefetch.ts
+var PREFETCH_CACHE_LIMIT = 16;
+var HOVER_DEBOUNCE_MS = 250;
+var MAX_IN_FLIGHT = 2;
+var MAX_LIVE_SPECULATION_RULES = 2;
+var VIEWPORT_ROOT_MARGIN = "128px";
+var SLOW_EFFECTIVE_TYPES = new Set(["slow-2g", "2g"]);
+var NOT_FOUND = 404;
+var NOT_ACCEPTABLE = 406;
+var ROUTE_DATA_MEDIA_TYPE = "application/vnd.absolute.route+json";
+var cache = new Map;
+var queue = [];
+var inFlight = 0;
+var preloadedModules = new Set;
+var prefetchedStyles = new Set;
+var liveSpeculationRules = new Map;
+var offlineResponse = () => new Response(null, { status: 0 });
+var storageKind = (kind) => kind === "route" ? "document" : kind;
+var cacheKey = (kind, url) => `${storageKind(kind)}:${url}`;
+var resolveHref = (url) => {
+  if (typeof window === "undefined")
+    return url;
+  try {
+    return new URL(url, window.location.href).href;
+  } catch {
+    return url;
+  }
+};
+var isGloballyDisabled = () => typeof window !== "undefined" && Reflect.get(window, "__ABSOLUTE_PREFETCH__") === false;
+var isSlowConnection = () => {
+  if (typeof navigator === "undefined")
+    return false;
+  const connection = Reflect.get(navigator, "connection");
+  if (typeof connection !== "object" || connection === null)
+    return false;
+  if (Reflect.get(connection, "saveData") === true)
+    return true;
+  const effectiveType = Reflect.get(connection, "effectiveType");
+  return typeof effectiveType === "string" && SLOW_EFFECTIVE_TYPES.has(effectiveType);
+};
+var prefersReducedData = () => {
+  if (typeof window === "undefined" || !window.matchMedia)
+    return false;
+  return window.matchMedia("(prefers-reduced-data: reduce)").matches;
+};
+var canPrefetch = () => typeof window !== "undefined" && !isGloballyDisabled() && !isSlowConnection() && !prefersReducedData();
+var readNodeEnv = () => {
+  const processLike = Reflect.get(globalThis, "process");
+  if (typeof processLike !== "object" || processLike === null) {
+    return;
+  }
+  const env = Reflect.get(processLike, "env");
+  if (typeof env !== "object" || env === null)
+    return;
+  const value = Reflect.get(env, "NODE_ENV");
+  return typeof value === "string" ? value : undefined;
+};
+var isDevelopmentClient = () => {
+  if (typeof window === "undefined")
+    return false;
+  if (Reflect.get(window, "__HMR_FRAMEWORK__") !== undefined)
+    return true;
+  if (Reflect.get(window, "__HMR_WS__") !== undefined)
+    return true;
+  if (typeof document !== "undefined" && document.querySelector("script[data-hmr-client]") !== null) {
+    return true;
+  }
+  return readNodeEnv() === "development";
+};
+var isPrefetchableHref = (href) => {
+  if (typeof window === "undefined")
+    return false;
+  if (href === "" || href.startsWith("#"))
+    return false;
+  try {
+    const url = new URL(href, window.location.href);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return false;
+    return url.origin === window.location.origin;
+  } catch {
+    return false;
+  }
+};
+var resolveDefaultPrefetchMode = () => isDevelopmentClient() ? "hover" : "viewport";
+var runQueue = () => {
+  while (inFlight < MAX_IN_FLIGHT) {
+    const next = queue.shift();
+    if (!next)
+      return;
+    if (next.cancelled)
+      continue;
+    next.start();
+  }
+};
+var finishTask = () => {
+  inFlight = Math.max(0, inFlight - 1);
+  runQueue();
+};
+var runWhenReleased = async (gate, task, signal) => {
+  await gate;
+  try {
+    return await task(signal);
+  } catch {
+    return offlineResponse();
+  } finally {
+    finishTask();
+  }
+};
+var enqueue = (task) => {
+  const controller = new AbortController;
+  let release = () => {
+    return;
+  };
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const queued = {
+    cancelled: false,
+    start: () => {
+      inFlight += 1;
+      release();
+    }
+  };
+  const promise = runWhenReleased(gate, task, controller.signal);
+  queue.push(queued);
+  runQueue();
+  const abort = () => {
+    if (queued.cancelled)
+      return;
+    queued.cancelled = true;
+    controller.abort();
+  };
+  return { abort, promise };
+};
+var evictOldest = () => {
+  const oldest = cache.keys().next();
+  if (oldest.done)
+    return;
+  cache.get(oldest.value)?.abort();
+  cache.delete(oldest.value);
+};
+var touch = (key, entry) => {
+  cache.delete(key);
+  cache.set(key, entry);
+};
+var injectLink = (rel, href, asType) => {
+  if (typeof document === "undefined")
+    return;
+  const link = document.createElement("link");
+  link.rel = rel;
+  link.href = href;
+  if (asType)
+    link.setAttribute("as", asType);
+  document.head.append(link);
+};
+var injectPrefetchFallback = (kind, url) => {
+  if (kind !== "document" || !supportsLinkRel("prefetch"))
+    return;
+  injectLink("prefetch", url, "document");
+};
+var supportsLinkRel = (rel) => {
+  if (typeof document === "undefined")
+    return false;
+  const link = document.createElement("link");
+  return typeof link.relList?.supports === "function" && link.relList.supports(rel);
+};
+var prefetchStylesheet = (href) => {
+  if (typeof document === "undefined")
+    return false;
+  const resolved = resolveHref(href);
+  if (prefetchedStyles.has(resolved))
+    return false;
+  prefetchedStyles.add(resolved);
+  injectLink("prefetch", href, "style");
+  return true;
+};
+var preloadModule = (href) => {
+  if (typeof document === "undefined")
+    return false;
+  const resolved = resolveHref(href);
+  if (preloadedModules.has(resolved))
+    return false;
+  const existing = Array.from(document.querySelectorAll('link[rel="modulepreload"]'));
+  if (existing.some((link) => resolveHref(link.href) === resolved)) {
+    preloadedModules.add(resolved);
+    return false;
+  }
+  preloadedModules.add(resolved);
+  injectLink("modulepreload", href);
+  return true;
+};
+var isRecord = (value) => typeof value === "object" && value !== null;
+var isHref = (value) => typeof value === "string" && value.length > 0;
+var warmRouteDataAssets = (envelope) => {
+  if (!isRecord(envelope))
+    return;
+  const { assets } = envelope;
+  if (!isRecord(assets))
+    return;
+  const { client, css, index } = assets;
+  for (const href of [index, client].filter(isHref))
+    preloadModule(href);
+  if (!Array.isArray(css))
+    return;
+  for (const href of css.filter(isHref))
+    prefetchStylesheet(href);
+};
+var warmFromRouteData = async (response) => {
+  try {
+    warmRouteDataAssets(await response.clone().json());
+  } catch {}
+  return response;
+};
+var fetchDocument = (url, signal) => fetch(url, { credentials: "same-origin", signal });
+var fetchRouteData = async (url, signal) => {
+  const response = await fetch(url, {
+    credentials: "same-origin",
+    headers: { Accept: ROUTE_DATA_MEDIA_TYPE },
+    signal
+  });
+  const contentType = response.headers.get("content-type") ?? "";
+  const isRouteData = response.ok && contentType.includes(ROUTE_DATA_MEDIA_TYPE);
+  if (isRouteData)
+    return warmFromRouteData(response);
+  await response.body?.cancel().catch(() => {
+    return;
+  });
+  const status = response.status === NOT_FOUND || response.status === NOT_ACCEPTABLE ? response.status : NOT_ACCEPTABLE;
+  return new Response(null, { status });
+};
+var prefetch = (url, options = {}) => {
+  const kind = options.kind ?? "document";
+  if (!canPrefetch())
+    return;
+  if (kind === "module") {
+    preloadModule(url);
+    return;
+  }
+  if (kind === "route") {
+    prefetch(url, { kind: "document" });
+    prefetch(url, { kind: "data" });
+    return;
+  }
+  const key = cacheKey(kind, url);
+  const existing = cache.get(key);
+  if (existing) {
+    touch(key, existing);
+    return;
+  }
+  if (typeof fetch === "undefined") {
+    injectPrefetchFallback(kind, url);
+    return;
+  }
+  while (cache.size >= PREFETCH_CACHE_LIMIT)
+    evictOldest();
+  const { abort, promise } = enqueue((signal) => kind === "data" ? fetchRouteData(url, signal) : fetchDocument(url, signal));
+  cache.set(key, { abort, kind, promise, url });
+};
+var supportsSpeculationRules = () => typeof HTMLScriptElement !== "undefined" && typeof HTMLScriptElement.supports === "function" && HTMLScriptElement.supports("speculationrules");
+var speculate = (url) => {
+  if (!canPrefetch() || !supportsSpeculationRules())
+    return false;
+  if (typeof document === "undefined")
+    return false;
+  const resolved = resolveHref(url);
+  if (liveSpeculationRules.has(resolved))
+    return false;
+  while (liveSpeculationRules.size >= MAX_LIVE_SPECULATION_RULES) {
+    const oldest = liveSpeculationRules.keys().next();
+    if (oldest.done)
+      break;
+    liveSpeculationRules.get(oldest.value)?.remove();
+    liveSpeculationRules.delete(oldest.value);
+  }
+  const script = applyPageNonce(document.createElement("script"));
+  script.type = "speculationrules";
+  script.textContent = JSON.stringify({
+    prerender: [{ eagerness: "immediate", urls: [url] }]
+  });
+  document.head.append(script);
+  liveSpeculationRules.set(resolved, script);
+  return true;
+};
+var noopHandle = {
+  cancel: () => {}
+};
+var scheduleHoverPrefetch = (url, options = {}) => {
+  if (typeof window === "undefined")
+    return noopHandle;
+  const timer = window.setTimeout(() => {
+    prefetch(url, { kind: options.kind ?? "route" });
+    if (options.prerender)
+      speculate(url);
+    options.onPrefetch?.();
+  }, HOVER_DEBOUNCE_MS);
+  return {
+    cancel: () => window.clearTimeout(timer)
+  };
+};
+var viewportTargets = new WeakMap;
+var viewportObserver = null;
+var handleIntersections = (entries) => {
+  for (const entry of entries) {
+    if (!entry.isIntersecting)
+      continue;
+    const target = viewportTargets.get(entry.target);
+    viewportObserver?.unobserve(entry.target);
+    viewportTargets.delete(entry.target);
+    if (!target)
+      continue;
+    prefetch(target.url, { kind: target.options.kind });
+    target.options.onVisible?.();
+  }
+};
+var getViewportObserver = () => {
+  if (viewportObserver)
+    return viewportObserver;
+  if (typeof IntersectionObserver === "undefined")
+    return null;
+  viewportObserver = new IntersectionObserver(handleIntersections, {
+    rootMargin: VIEWPORT_ROOT_MARGIN
+  });
+  return viewportObserver;
+};
+var observeViewport = (element, url, options = {}) => {
+  const observer = getViewportObserver();
+  if (!observer || !canPrefetch())
+    return () => {
+      return;
+    };
+  viewportTargets.set(element, { options, url });
+  observer.observe(element);
+  return () => {
+    observer.unobserve(element);
+    viewportTargets.delete(element);
+  };
+};
+
+// src/react/hooks/usePrefetch.ts
+import { useCallback, useEffect, useRef } from "react";
+var usePrefetch = (href, options = {}) => {
+  const { kind, mode, prerender = false } = options;
+  const viewportKind = kind ?? "document";
+  const triggerKind = kind ?? "route";
+  const elementRef = useRef(null);
+  const hoverHandle = useRef(null);
+  const cancelHover = useCallback(() => {
+    hoverHandle.current?.cancel();
+    hoverHandle.current = null;
+  }, []);
+  const isActive = useCallback(() => {
+    if (href === undefined || !isPrefetchableHref(href))
+      return false;
+    const resolved = mode ?? resolveDefaultPrefetchMode();
+    return resolved !== "none";
+  }, [href, mode]);
+  useEffect(() => {
+    const element = elementRef.current;
+    if (!element || href === undefined || !isActive())
+      return;
+    const resolved = mode ?? resolveDefaultPrefetchMode();
+    if (resolved !== "viewport")
+      return;
+    return observeViewport(element, href, { kind: viewportKind });
+  }, [href, isActive, mode, viewportKind]);
+  useEffect(() => cancelHover, [cancelHover]);
+  const onPointerEnter = useCallback(() => {
+    if (href === undefined || !isActive())
+      return;
+    cancelHover();
+    hoverHandle.current = scheduleHoverPrefetch(href, {
+      kind: triggerKind,
+      prerender
+    });
+  }, [cancelHover, href, isActive, prerender, triggerKind]);
+  const onPointerDown = useCallback(() => {
+    if (href === undefined || !isActive())
+      return;
+    cancelHover();
+    prefetch(href, { kind: triggerKind });
+    if (prerender)
+      speculate(href);
+  }, [cancelHover, href, isActive, prerender, triggerKind]);
+  return {
+    onBlur: cancelHover,
+    onFocus: onPointerEnter,
+    onPointerDown,
+    onPointerEnter,
+    onPointerLeave: cancelHover,
+    ref: elementRef
+  };
+};
+
+// src/react/router/navigationContext.ts
+import { createContext } from "react";
+var RouterNavigationContext = createContext(null);
+
+// src/react/router/Link.tsx
+import { jsx } from "react/jsx-runtime";
+var isModifierClick = (event) => event.metaKey || event.ctrlKey || event.shiftKey || event.altKey;
+var Link = ({
+  href,
+  prefetch: prefetchMode,
+  prerender = false,
+  replace = false,
+  target,
+  download,
+  children,
+  onBlur,
+  onClick,
+  onFocus,
+  onPointerDown,
+  onPointerEnter,
+  onPointerLeave,
+  ...rest
+}) => {
+  const navigation = useContext(RouterNavigationContext);
+  const {
+    ref,
+    onBlur: prefetchBlur,
+    onFocus: prefetchFocus,
+    onPointerDown: prefetchPointerDown,
+    onPointerEnter: prefetchPointerEnter,
+    onPointerLeave: prefetchPointerLeave
+  } = usePrefetch(href, { mode: prefetchMode, prerender });
+  const handleClick = (event) => {
+    onClick?.(event);
+    if (event.defaultPrevented)
+      return;
+    if (isModifierClick(event) || event.button !== 0)
+      return;
+    if (target && target !== "_self")
+      return;
+    if (download !== undefined)
+      return;
+    if (!navigation || !isPrefetchableHref(href))
+      return;
+    if (navigation.matches(href) === false)
+      return;
+    event.preventDefault();
+    navigation.navigate(href, { replace });
+  };
+  const handlePointerEnter = (event) => {
+    onPointerEnter?.(event);
+    prefetchPointerEnter();
+  };
+  const handlePointerLeave = (event) => {
+    onPointerLeave?.(event);
+    prefetchPointerLeave();
+  };
+  const handlePointerDown = (event) => {
+    onPointerDown?.(event);
+    prefetchPointerDown();
+  };
+  const handleFocus = (event) => {
+    onFocus?.(event);
+    prefetchFocus();
+  };
+  const handleBlur = (event) => {
+    onBlur?.(event);
+    prefetchBlur();
+  };
+  return /* @__PURE__ */ jsx("a", {
+    ...rest,
+    download,
+    href,
+    onBlur: handleBlur,
+    onClick: handleClick,
+    onFocus: handleFocus,
+    onPointerDown: handlePointerDown,
+    onPointerEnter: handlePointerEnter,
+    onPointerLeave: handlePointerLeave,
+    ref,
+    target,
+    children
+  });
+};
+
+// src/react/components/client.ts
+"use client";
+export {
+  Link,
+  usePrefetch
+};

package/dist/react/components/index.js

@@ -162,6 +162,19 @@ var init_constants = __esm(() => {
   TWO_THIRDS = 2 / 3;
 });
 
+// src/dev/client/cspNonce.ts
+var applyPageNonce = (element) => {
+  const nonce = readPageNonce();
+  if (nonce)
+    element.nonce = nonce;
+  return element;
+}, readPageNonce = () => {
+  if (typeof document === "undefined")
+    return;
+  const carrier = document.querySelector("script[nonce], style[nonce]");
+  return carrier?.nonce || undefined;
+};
+
 // src/react/components/Head.tsx
 init_cspNonceRef();
 init_fontAssets();
@@ -987,20 +1000,6 @@ import {
   useContext
 } from "react";
 
-// src/dev/client/cspNonce.ts
-var applyPageNonce = (element) => {
-  const nonce = readPageNonce();
-  if (nonce)
-    element.nonce = nonce;
-  return element;
-};
-var readPageNonce = () => {
-  if (typeof document === "undefined")
-    return;
-  const carrier = document.querySelector("script[nonce], style[nonce]");
-  return carrier?.nonce || undefined;
-};
-
 // src/client/prefetch.ts
 var PREFETCH_CACHE_LIMIT = 16;
 var HOVER_DEBOUNCE_MS = 250;
@@ -1488,5 +1487,5 @@ export {
   usePrefetch
 };
 
-//# debugId=44BDD08A7AD6CC8F64756E2164756E21
+//# debugId=A6EB3EF7F464277264756E2164756E21
 //# sourceMappingURL=index.js.map