@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-vvq7rqtn.js

@@ -0,0 +1,329 @@
+// @bun
+import {
+  addTransitionType
+} from "./index-9ch50vtq.js";
+import {
+  addBasePath
+} from "./index-ms9v9tnx.js";
+
+// src/compat/next/link.tsx
+import { cloneElement, h as createElement, toChildArray } from "preact";
+import { useContext, useEffect, useRef, useState } from "preact/hooks";
+import { usePrefetchLifecycle } from "../../../src/api/link.tsx";
+import { blockJavascriptUrl, isJavascriptUrl } from "../../../src/client/router/index.ts";
+import { applyTrailingSlash, routeHref } from "../../../src/routing/href.ts";
+
+// src/compat/client/trailing-slash.ts
+function skipTrailingSlashRedirect() {
+  if (typeof window !== "undefined")
+    return window.__PNEXT_SKIP_TRAILING_SLASH__ === true;
+  return globalThis.__PNEXT_SKIP_TRAILING_SLASH__ === true;
+}
+
+// src/compat/client/link-status.ts
+import { createContext } from "preact";
+import { softNavigate } from "../../../src/client/router/index.ts";
+import { locationListeners, onNavigationStart } from "../../../src/client/router/events.ts";
+import { patchHistory } from "../../../src/api/client-navigation.ts";
+var LinkStatusContext = createContext({ pending: false });
+var pendingToken = null;
+var ownNavStart = null;
+var listeners = new Set;
+var wired = false;
+function notify() {
+  for (const listener of [...listeners])
+    listener();
+}
+function setPending(token) {
+  if (pendingToken === token)
+    return;
+  pendingToken = token;
+  notify();
+}
+function onNavStart() {
+  if (ownNavStart !== null) {
+    ownNavStart = null;
+    return;
+  }
+  setPending(null);
+}
+function onLocationChange() {
+  setPending(null);
+}
+function wire() {
+  if (wired || typeof window === "undefined")
+    return;
+  wired = true;
+  patchHistory();
+  onNavigationStart(onNavStart);
+  locationListeners().add(onLocationChange);
+  window.addEventListener("popstate", onLocationChange);
+}
+function subscribeLinkStatus(_token, listener) {
+  wire();
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function linkPending(token) {
+  return pendingToken === token;
+}
+function navigateWithStatus(token, href, options) {
+  ownNavStart = token;
+  setPending(token);
+  softNavigate(href, options).finally(() => {
+    if (pendingToken === token)
+      setPending(null);
+  });
+}
+
+// src/compat/next/link.tsx
+var reactClientReferenceSymbol = Symbol.for("react.client.reference");
+function Link({
+  href,
+  as,
+  prefetch = null,
+  unstable_dynamicOnHover,
+  replace,
+  scroll,
+  locale: _locale,
+  legacyBehavior,
+  passHref,
+  onClick,
+  onNavigate,
+  transitionTypes,
+  onPrefetchStart,
+  onPrefetchFinish,
+  __pnextLegacyChildKind,
+  children,
+  ref: forwardedRef,
+  ...anchorProps
+}) {
+  const target = as == null ? href : as;
+  const hrefBase = hrefString(target);
+  const resolvedHref = addBasePath(skipTrailingSlashRedirect() ? hrefBase : applyTrailingSlash(hrefBase));
+  const blocked = isJavascriptUrl(resolvedHref);
+  const prefetchMode = nextPrefetchMode(prefetch);
+  const lifecycleRef = usePrefetchLifecycle(onPrefetchStart, onPrefetchFinish);
+  const anchorRef = useComposedRef(lifecycleRef, forwardedRef);
+  const statusToken = useLinkToken();
+  const handleClick = (event) => {
+    onClick?.(event);
+    if (event.defaultPrevented)
+      return;
+    if (blocked) {
+      if (blockJavascriptUrl(resolvedHref))
+        event.preventDefault();
+      return;
+    }
+    if (!isPlainLeftClick(event))
+      return;
+    if (isExternalHref(resolvedHref)) {
+      if (replace) {
+        event.preventDefault();
+        window.location.replace(resolvedHref);
+      }
+      return;
+    }
+    if (onNavigate) {
+      const navEvent = navigationEvent();
+      onNavigate(navEvent);
+      if (navEvent.defaultPrevented) {
+        event.preventDefault();
+        return;
+      }
+    }
+    event.preventDefault();
+    for (const type of transitionTypes ?? [])
+      addTransitionType(type);
+    const url = new URL(resolvedHref, window.location.href);
+    const samePage = url.pathname === window.location.pathname && url.search === window.location.search;
+    if (samePage && url.hash) {
+      window.location.hash = url.hash;
+      return;
+    }
+    navigateWithStatus(statusToken, url.href, { replace, scroll });
+  };
+  const anchorAttributes = {
+    ...anchorProps,
+    ref: anchorRef,
+    href: resolvedHref,
+    "data-pnext-link": true,
+    "data-prefetch": prefetchMode === false ? "false" : prefetchMode,
+    "data-prefetch-full": prefetch === true || prefetch === "unstable_forceStale" ? "true" : undefined,
+    "data-prefetch-hover-full": unstable_dynamicOnHover ? "true" : undefined,
+    "data-pnext-replace": replace ? "true" : undefined,
+    "data-pnext-scroll": scroll === false ? "false" : undefined,
+    onClick: handleClick
+  };
+  if (blocked)
+    anchorAttributes["data-pnext-blocked-href"] = resolvedHref;
+  if ((typeof __PNEXT_LINK_LEGACY__ === "boolean" ? __PNEXT_LINK_LEGACY__ : true) && legacyBehavior) {
+    return renderLegacyChild(children, resolvedHref, passHref, handleClick, anchorAttributes, __pnextLegacyChildKind);
+  }
+  return createElement("a", anchorAttributes, createElement(LinkStatusContext.Provider, { value: { pending: linkPending(statusToken) } }, children));
+}
+var link_default = Link;
+function useLinkStatus() {
+  return useContext(LinkStatusContext);
+}
+function useLinkToken() {
+  const tokenRef = useRef(null);
+  tokenRef.current ??= Symbol("pnext-link");
+  const token = tokenRef.current;
+  const [, force] = useState(0);
+  useEffect(() => subscribeLinkStatus(token, () => force((n) => n + 1)), [token]);
+  return token;
+}
+function renderLegacyChild(children, resolvedHref, passHref, onClick, anchorAttributes, annotatedKind) {
+  reportLegacyDeprecation();
+  const isDev = false;
+  const isServer = typeof window === "undefined";
+  if (isLazyComponent(children))
+    throw unsupportedLegacyChildError();
+  if (children == null || children === false) {
+    if (isDev) {
+      throw validationError(`No children were passed to <Link> with \`href\` of \`${resolvedHref}\` but one child is required https://nextjs.org/docs/messages/link-no-children`, "E320");
+    }
+    return childrenOnlyOrThrow(children);
+  }
+  if (typeof children === "string" || typeof children === "number") {
+    return createElement("a", { ...anchorAttributes, href: resolvedHref }, children);
+  }
+  const count = toChildArray(children).length;
+  if (count > 1) {
+    if (isDev) {
+      throw validationError(`Multiple children were passed to <Link> with \`href\` of \`${resolvedHref}\` but only one child is supported https://nextjs.org/docs/messages/link-multiple-children`, "E266");
+    }
+    return childrenOnlyOrThrow(children);
+  }
+  const child = childrenOnlyOrThrow(children);
+  const kind = annotatedKind ?? (isAsyncFunctionComponent(child.type) ? "server-async" : isLazyComponent(child.type) ? "lazy" : undefined);
+  if (isServer && (kind === "server-sync" || kind === "server-async" || kind === "lazy")) {
+    reportUnsupportedServerChild(kind, isDev);
+  }
+  if (kind && kind !== "server-sync") {
+    const error = unsupportedLegacyChildError();
+    if (isServer && kind === "server-async-through-client") {
+      console.error(`\u2A2F ${error.stack ?? `Error: ${error.message}`}`);
+    }
+    throw error;
+  }
+  if (isServer && isDev && isServerComponent(child.type)) {
+    reportUnsupportedServerChild("server-sync", isDev);
+  }
+  const childProps = {
+    onClick: (event) => {
+      child.props.onClick?.(event);
+      onClick(event);
+    }
+  };
+  if (passHref || child.type === "a") {
+    childProps.href = resolvedHref;
+    childProps["data-pnext-link"] = anchorAttributes["data-pnext-link"];
+    childProps["data-prefetch"] = anchorAttributes["data-prefetch"];
+    childProps["data-prefetch-full"] = anchorAttributes["data-prefetch-full"];
+    childProps["data-prefetch-hover-full"] = anchorAttributes["data-prefetch-hover-full"];
+    childProps["data-pnext-replace"] = anchorAttributes["data-pnext-replace"];
+    childProps["data-pnext-scroll"] = anchorAttributes["data-pnext-scroll"];
+  }
+  return cloneElement(child, childProps);
+}
+function reportUnsupportedServerChild(kind, isDev) {
+  const message = kind === "lazy" ? "Using a Lazy Component as a direct child of `<Link legacyBehavior>` from a Server Component is not supported. If you need legacyBehavior, wrap your Lazy Component in a Client Component that renders the Link's `<a>` tag." : "Using a Server Component as a direct child of `<Link legacyBehavior>` is not supported. If you need legacyBehavior, wrap your Server Component in a Client Component that renders the Link's `<a>` tag.";
+  console.error(isDev ? validationError(message, "E394") : message);
+}
+function unsupportedLegacyChildError() {
+  return validationError("`<Link legacyBehavior>` received a direct child that is either a Server Component, or JSX that was loaded with React.lazy(). This is not supported. Either remove legacyBehavior, or make the direct child a Client Component that renders the Link's `<a>` tag.", "E863");
+}
+var deprecationWarned = false;
+function reportLegacyDeprecation() {
+  if (deprecationWarned || typeof window === "undefined" || true) {
+    return;
+  }
+  deprecationWarned = true;
+  console.error("`legacyBehavior` is deprecated and will be removed in a future release. A codemod is available to upgrade your components:\n\n" + `npx @next/codemod@latest new-link .
+
+` + "Learn more: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#remove-a-tags-from-link-components");
+}
+function validationError(message, digest) {
+  return Object.assign(new Error(message), { digest });
+}
+function childrenOnlyOrThrow(children) {
+  const array = toChildArray(children);
+  if (array.length === 1 && isValidElementLike(array[0]))
+    return array[0];
+  throw new Error("React.Children.only expected to receive a single React element child.");
+}
+function isValidElementLike(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+function isAsyncFunctionComponent(type) {
+  if (typeof type !== "function")
+    return false;
+  const asyncFunctionName = Object.prototype.toString.call(type);
+  return asyncFunctionName === "[object AsyncFunction]";
+}
+function isLazyComponent(type) {
+  if (type === null || typeof type !== "object" && typeof type !== "function")
+    return false;
+  const marked = type;
+  return marked.$$typeof === Symbol.for("react.lazy") || marked[Symbol.for("pnext.lazy")] === true;
+}
+function isServerComponent(type) {
+  if (isClientComponent(type))
+    return false;
+  return typeof type === "function" && type.$$typeof === undefined;
+}
+function isClientComponent(type) {
+  return (typeof type === "object" || typeof type === "function") && type.$$typeof === reactClientReferenceSymbol;
+}
+function useComposedRef(internalRef, userRef) {
+  return (node) => {
+    internalRef.current = node;
+    assignRef(userRef, node);
+  };
+}
+function assignRef(ref, node) {
+  if (!ref)
+    return;
+  if (typeof ref === "function") {
+    ref(node);
+    return;
+  }
+  ref.current = node;
+}
+function hrefString(href) {
+  if (typeof href === "string")
+    return href;
+  if (href instanceof URL)
+    return href.toString();
+  return routeHref(href.pathname ?? "", { search: href.query, hash: href.hash });
+}
+function nextPrefetchMode(prefetch) {
+  return prefetch === false ? false : "visible";
+}
+function isExternalHref(href) {
+  if (typeof window === "undefined")
+    return false;
+  try {
+    return new URL(href, window.location.href).origin !== window.location.origin;
+  } catch {
+    return true;
+  }
+}
+function navigationEvent() {
+  return {
+    defaultPrevented: false,
+    preventDefault() {
+      this.defaultPrevented = true;
+    }
+  };
+}
+function isPlainLeftClick(event) {
+  return event.button === 0 && !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey && isSelfTarget(event.currentTarget.target) && !event.currentTarget.hasAttribute("download");
+}
+function isSelfTarget(target) {
+  return target === "" || target === "_self";
+}
+
+export { Link, useLinkStatus, link_default };

package/dist/server/_chunks/index-vz0km5qk.js

@@ -0,0 +1,33 @@
+// @bun
+// src/utils/trace-flags.ts
+function parseTraceFlags(raw) {
+  const scopes = new Map;
+  for (const entry of raw?.split(",") ?? []) {
+    const trimmed = entry.trim();
+    if (!trimmed)
+      continue;
+    const eq = trimmed.indexOf("=");
+    const name = eq === -1 ? trimmed : trimmed.slice(0, eq).trim();
+    if (!name)
+      continue;
+    scopes.set(name === "1" ? "boot" : name, eq === -1 ? "" : trimmed.slice(eq + 1).trim());
+  }
+  return scopes;
+}
+var scopes;
+var all = false;
+function flags() {
+  if (!scopes) {
+    scopes = parseTraceFlags(process.env.PNEXT_TRACE);
+    all = scopes.has("all");
+  }
+  return scopes;
+}
+function traceEnabled(scope) {
+  return flags().has(scope) || all;
+}
+function traceValue(scope) {
+  return flags().get(scope) || undefined;
+}
+
+export { traceEnabled, traceValue };

package/dist/server/_chunks/index-w6h8m6vp.js

@@ -0,0 +1,138 @@
+// @bun
+import {
+  wrapComponentForPrimitiveThrows
+} from "./index-79ngvam8.js";
+
+// src/compat/react/parity.ts
+import { options } from "preact";
+var reactForwardRefSymbol = Symbol.for("react.forward_ref");
+var react19RefCompatInstalled = Symbol.for("pnext.react19-ref-compat-installed");
+var reactTextSeparatorSymbol = /* @__PURE__ */ Symbol.for("pnext.react-text-separator");
+var reactCompatActive = true;
+function setReactCompatActive(active) {
+  reactCompatActive = active;
+}
+var suspenseParity;
+function setSuspenseParity(pass) {
+  suspenseParity = pass;
+}
+var pnextOptions = options;
+if (!pnextOptions[react19RefCompatInstalled]) {
+  const previousVNode = options.vnode?.bind(options);
+  options.vnode = (vnode) => {
+    previousVNode?.(vnode);
+    if (!reactCompatActive)
+      return;
+    applyReact19RefProp(vnode);
+    suspenseParity?.beforeThrowSafety(vnode);
+    applyPrimitiveThrowSafety(vnode);
+    suspenseParity?.afterThrowSafety(vnode);
+    applyStrayDocumentChildren(vnode);
+    applyReactTextSeparators(vnode);
+  };
+  pnextOptions[react19RefCompatInstalled] = true;
+  if (typeof window !== "undefined" && typeof MessageChannel !== "undefined") {
+    const queue = [];
+    const channel = new MessageChannel;
+    channel.port1.onmessage = () => {
+      for (const callback of queue.splice(0))
+        callback();
+    };
+    options.requestAnimationFrame = (callback) => {
+      queue.push(callback);
+      channel.port2.postMessage(null);
+    };
+  }
+}
+function applyStrayDocumentChildren(vnode) {
+  if (typeof window !== "undefined")
+    return;
+  if (vnode.type !== "html")
+    return;
+  const props = vnode.props;
+  const children = props.children;
+  if (!Array.isArray(children))
+    return;
+  const kept = [];
+  const stray = [];
+  let body;
+  for (const child of children) {
+    const type = isElementVNode(child) ? child.type : undefined;
+    if (type === "body")
+      body = child;
+    if (type === "head" || type === "body" || !mayRenderContent(child)) {
+      kept.push(child);
+      continue;
+    }
+    stray.push(child);
+  }
+  if (!body || stray.length === 0)
+    return;
+  const bodyProps = body.props;
+  const bodyChildren = bodyProps.children;
+  bodyProps.children = [
+    ...stray,
+    ...Array.isArray(bodyChildren) ? bodyChildren : [bodyChildren]
+  ];
+  props.children = kept;
+}
+function isElementVNode(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function mayRenderContent(child) {
+  if (child == null || typeof child === "boolean")
+    return false;
+  return typeof child === "string" ? child.trim() !== "" : true;
+}
+function applyReactTextSeparators(vnode) {
+  if (typeof window !== "undefined")
+    return;
+  const props = vnode.props;
+  const children = props.children;
+  if (!Array.isArray(children) || children.length < 2)
+    return;
+  const values = children;
+  const separated = [];
+  let changed = false;
+  for (let index = 0;index < values.length; index += 1) {
+    const child = values[index];
+    separated.push(child);
+    if (!mayRenderText(child) || !mayRenderText(values[index + 1]))
+      continue;
+    separated.push({
+      type: reactTextSeparatorSymbol,
+      props: { UNSTABLE_comment: " " }
+    });
+    changed = true;
+  }
+  if (changed)
+    props.children = separated;
+}
+function mayRenderText(value) {
+  if (typeof value === "string" || typeof value === "number")
+    return true;
+  if (!value || typeof value !== "object" || !("type" in value))
+    return false;
+  return typeof value.type !== "string";
+}
+function applyPrimitiveThrowSafety(vnode) {
+  if (typeof window === "undefined")
+    return;
+  if (typeof vnode.type !== "function")
+    return;
+  vnode.type = wrapComponentForPrimitiveThrows(vnode.type);
+}
+function applyReact19RefProp(vnode) {
+  if (!vnode.ref || typeof vnode.type !== "function")
+    return;
+  const component = vnode.type;
+  if (component.prototype?.render || component.$$typeof === reactForwardRefSymbol)
+    return;
+  vnode.props = {
+    ...vnode.props,
+    ref: vnode.ref
+  };
+  vnode.ref = null;
+}
+
+export { setReactCompatActive, setSuspenseParity };

package/dist/server/_chunks/index-web361b8.js

@@ -0,0 +1,138 @@
+// @bun
+import {
+  restoreWithExtensionHost
+} from "./index-zqpqyg8p.js";
+
+// src/render/hooks.ts
+function nextCompatEnabled(config) {
+  return Boolean(config.compat?.next);
+}
+function reactCompatEnabled(config) {
+  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler);
+}
+var fontExtensions = {
+  runWithFontScope: (callback) => callback(),
+  collectFontAssets: () => Promise.resolve({ css: "", preloads: [] }),
+  prewarmFontAssets: () => Promise.resolve(),
+  releaseFonts: () => Promise.resolve({})
+};
+function getFontExtensions() {
+  return fontExtensions;
+}
+function setFontExtensions(overrides) {
+  Object.assign(fontExtensions, overrides);
+}
+var suspenseExtensions = {
+  ensureCompatSuspense: () => Promise.resolve(),
+  compatSuspenseType: () => {
+    return;
+  }
+};
+function getSuspenseExtensions() {
+  return suspenseExtensions;
+}
+function setSuspenseExtensions(overrides) {
+  Object.assign(suspenseExtensions, overrides);
+}
+var streamRouteExtensions = {
+  canStreamRoute: () => true,
+  inlineSuspenseStream: () => false
+};
+function getStreamRouteExtensions() {
+  return streamRouteExtensions;
+}
+function setStreamRouteExtensions(overrides) {
+  Object.assign(streamRouteExtensions, overrides);
+}
+var streamBoundaryExtensions = {
+  onStreamBoundaryError: () => {
+    return;
+  }
+};
+function setStreamBoundaryExtensions(overrides) {
+  Object.assign(streamBoundaryExtensions, overrides);
+}
+function reportStreamBoundaryError(error) {
+  try {
+    const result = streamBoundaryExtensions.onStreamBoundaryError(error);
+    if (isThenable(result)) {
+      Promise.resolve(result).catch((reportError) => {
+        console.error("stream boundary error hook failed:", reportError);
+      });
+    }
+  } catch (reportError) {
+    console.error("stream boundary error hook failed:", reportError);
+  }
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var metadataExtensions = {};
+function getActiveMetadataExtensions(config) {
+  return metadataExtensions.enabled?.(config) ? metadataExtensions : {};
+}
+function setMetadataExtensions(overrides) {
+  Object.assign(metadataExtensions, overrides);
+}
+var documentScriptExtensions = {
+  stylesheetPrecedence: () => {
+    return;
+  },
+  documentBodyScripts: () => ""
+};
+function getDocumentScriptExtensions() {
+  return documentScriptExtensions;
+}
+function setDocumentScriptExtensions(overrides) {
+  Object.assign(documentScriptExtensions, overrides);
+}
+var staticParamsExtensions = {
+  normalizeModule: (module) => typeof module.params === "function" || typeof module.generateStaticParams !== "function" ? module : { ...module, params: module.generateStaticParams }
+};
+function getStaticParamsExtensions() {
+  return staticParamsExtensions;
+}
+function setStaticParamsExtensions(overrides) {
+  Object.assign(staticParamsExtensions, overrides);
+}
+var actionModuleExtensions = {
+  tagActionModulesForRender: () => Promise.resolve(),
+  tagActionModuleExports: () => {
+    return;
+  }
+};
+function getActionModuleExtensions() {
+  return actionModuleExtensions;
+}
+function setActionModuleExtensions(overrides) {
+  Object.assign(actionModuleExtensions, overrides);
+}
+var renderSpanExtensions = {
+  withRenderBodySpan: (_route, fn) => fn(),
+  withFindPageComponentsSpan: (_route, fn) => fn(),
+  emitResolveSegmentSpan: () => {
+    return;
+  },
+  withRouteHandlerSpan: (_route, fn) => fn()
+};
+function getRenderSpanExtensions() {
+  return renderSpanExtensions;
+}
+function setRenderSpanExtensions(overrides) {
+  Object.assign(renderSpanExtensions, overrides);
+}
+for (const registry of [
+  fontExtensions,
+  suspenseExtensions,
+  streamRouteExtensions,
+  streamBoundaryExtensions,
+  metadataExtensions,
+  documentScriptExtensions,
+  staticParamsExtensions,
+  actionModuleExtensions,
+  renderSpanExtensions
+]) {
+  restoreWithExtensionHost(registry);
+}
+
+export { nextCompatEnabled, reactCompatEnabled, getFontExtensions, setFontExtensions, getSuspenseExtensions, setSuspenseExtensions, getStreamRouteExtensions, setStreamRouteExtensions, setStreamBoundaryExtensions, reportStreamBoundaryError, getActiveMetadataExtensions, setMetadataExtensions, getDocumentScriptExtensions, setDocumentScriptExtensions, getStaticParamsExtensions, setStaticParamsExtensions, getActionModuleExtensions, setActionModuleExtensions, getRenderSpanExtensions, setRenderSpanExtensions };