@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,132 @@
+// @bun
+// src/compat/ppr/root-params-scan.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+var LAYOUT_BASENAMES = ["layout.tsx", "layout.ts", "layout.jsx", "layout.js"];
+function isRootLayoutSource(source) {
+  return /<html[\s>]/.test(source);
+}
+function paramNameOfSegment(segment) {
+  const optional = /^\[\[\.\.\.(.+)\]\]$/.exec(segment);
+  if (optional)
+    return optional[1];
+  const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment);
+  if (catchAll)
+    return catchAll[1];
+  const dynamic = /^\[(.+)\]$/.exec(segment);
+  if (dynamic)
+    return dynamic[1];
+  return;
+}
+function findLayoutFile(dir) {
+  for (const base of LAYOUT_BASENAMES) {
+    const candidate = path.join(dir, base);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return;
+}
+function scanRootParams(appPath) {
+  const rootParams = new Set;
+  if (!existsSync(appPath))
+    return rootParams;
+  const walk = (dir, paramsAbove) => {
+    const layoutFile = findLayoutFile(dir);
+    if (layoutFile) {
+      let source = "";
+      try {
+        source = readFileSync(layoutFile, "utf8");
+      } catch {
+        source = "";
+      }
+      if (isRootLayoutSource(source)) {
+        for (const name of paramsAbove)
+          rootParams.add(name);
+      }
+    }
+    let children = [];
+    try {
+      children = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const child of children) {
+      const childPath = path.join(dir, child);
+      let isDir = false;
+      try {
+        isDir = statSync(childPath).isDirectory();
+      } catch {
+        isDir = false;
+      }
+      if (!isDir)
+        continue;
+      if (child.startsWith("@"))
+        continue;
+      const param = paramNameOfSegment(child);
+      walk(childPath, param ? [...paramsAbove, param] : paramsAbove);
+    }
+  };
+  walk(appPath, []);
+  return rootParams;
+}
+function scanRootParamTypes(appPath) {
+  const roots = [];
+  if (!existsSync(appPath))
+    return new Map;
+  const walk = (dir, paramsAbove) => {
+    const layoutFile = findLayoutFile(dir);
+    if (layoutFile) {
+      let source = "";
+      try {
+        source = readFileSync(layoutFile, "utf8");
+      } catch {
+        source = "";
+      }
+      if (isRootLayoutSource(source)) {
+        const params = new Map;
+        for (const { name, segment } of paramsAbove) {
+          params.set(name, segment.startsWith("[[...") ? ["string[]", "undefined"] : segment.startsWith("[...") ? ["string[]"] : ["string"]);
+        }
+        roots.push(params);
+      }
+    }
+    let children = [];
+    try {
+      children = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const child of children) {
+      const childPath = path.join(dir, child);
+      let isDir = false;
+      try {
+        isDir = statSync(childPath).isDirectory();
+      } catch {
+        isDir = false;
+      }
+      if (!isDir)
+        continue;
+      if (child.startsWith("@"))
+        continue;
+      const param = paramNameOfSegment(child);
+      walk(childPath, param ? [...paramsAbove, { name: param, segment: child }] : paramsAbove);
+    }
+  };
+  walk(appPath, []);
+  const combined = new Map;
+  for (const params of roots) {
+    for (const [name, types] of params) {
+      const set = combined.get(name) ?? new Set;
+      for (const type of types)
+        set.add(type);
+      combined.set(name, set);
+    }
+  }
+  for (const [name, set] of combined) {
+    if (roots.some((params) => !params.has(name)))
+      set.add("undefined");
+  }
+  return combined;
+}
+
+export { scanRootParams, scanRootParamTypes };

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

@@ -0,0 +1,170 @@
+// @bun
+import {
+  rewriteFacts
+} from "./index-x9c55pzy.js";
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/compat/next/link-transform.ts
+var parseSync = (...args) => loadNative(() => __require("oxc-parser")).parseSync(...args);
+var marker = "__pnextLegacyChildKind";
+function rewriteLegacyLinkValidation(source, file) {
+  if (!source.includes("Link") && !source.includes("legacyBehavior"))
+    return source;
+  const imports = rewriteFacts(file, source).imports;
+  const directLink = imports.some((statement) => statement.specifier === "next/link") && source.includes("legacyBehavior");
+  const asyncLinkWrapper = imports.some((statement) => statement.bindings.some((binding) => !binding.type && binding.local.endsWith("Link"))) && /<[A-Za-z_$][\w$]*Link\b/.test(source) && /\basync\s+function\b/.test(source);
+  if (!directLink && !asyncLinkWrapper)
+    return source;
+  const program = parseSync(file, source, { lang: langForFile(file) }).program;
+  const linkNames = new Set;
+  const asyncNames = new Set;
+  const functionNames = new Set;
+  const lazyNames = new Set;
+  const edits = [];
+  const isClient = program.body.some((statement) => statement.type === "ExpressionStatement" && statement.directive === "use client");
+  for (const statement of program.body) {
+    if (statement.type === "ImportDeclaration" && sourceValue(statement) === "next/link") {
+      for (const specifier of statement.specifiers ?? []) {
+        const local = identifierName(specifier.local);
+        if (!local)
+          continue;
+        if (specifier.type === "ImportDefaultSpecifier")
+          linkNames.add(local);
+        else if (identifierName(specifier.imported) === "Link")
+          linkNames.add(local);
+      }
+    }
+    if (statement.type === "FunctionDeclaration") {
+      const name = identifierName(statement.id);
+      if (name) {
+        functionNames.add(name);
+        if (statement.async === true)
+          asyncNames.add(name);
+      }
+    }
+    if (statement.type === "VariableDeclaration") {
+      for (const declarator of statement.declarations ?? []) {
+        const name = identifierName(declarator.id);
+        const init = declarator.init;
+        if (!name || !init)
+          continue;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+          functionNames.add(name);
+          if (init.async === true)
+            asyncNames.add(name);
+        }
+        if (isLazyCall(init))
+          lazyNames.add(name);
+      }
+    }
+  }
+  walk(program.body, (node) => {
+    if (node.type !== "JSXElement")
+      return;
+    const element = node;
+    if (element.closingElement === null)
+      return;
+    annotate(element);
+  });
+  function annotate(element) {
+    const opening = element.openingElement;
+    if (opening.name.type !== "JSXIdentifier" || hasMarker(opening))
+      return;
+    const parent = opening.name.name ?? "";
+    const isLink = linkNames.has(parent);
+    if (!isLink && !parent.endsWith("Link"))
+      return;
+    const children = element.children.filter(isMeaningfulChild);
+    if (children.length !== 1)
+      return;
+    const kind = childKind(children[0]);
+    if (!kind || !isLink && kind !== "server-async")
+      return;
+    const annotatedKind = !isLink ? "server-async-through-client" : isClient && kind === "lazy" ? "client-lazy" : kind;
+    edits.push({ at: opening.name.end, text: ` ${marker}="${annotatedKind}"` });
+  }
+  function childKind(child) {
+    let name;
+    if (child.type === "JSXElement") {
+      const opening = child.openingElement;
+      if (opening.name.type === "JSXIdentifier")
+        name = opening.name.name;
+    } else if (child.type === "JSXExpressionContainer") {
+      const expression = child.expression;
+      if (expression?.type === "Identifier")
+        name = expression.name;
+    }
+    if (!name)
+      return;
+    if (lazyNames.has(name))
+      return "lazy";
+    if (asyncNames.has(name))
+      return "server-async";
+    if (!isClient && functionNames.has(name))
+      return "server-sync";
+    return;
+  }
+  if (edits.length === 0)
+    return source;
+  let output = source;
+  for (const edit of edits.sort((a, b) => b.at - a.at)) {
+    output = output.slice(0, edit.at) + edit.text + output.slice(edit.at);
+  }
+  return output;
+}
+function isMeaningfulChild(child) {
+  if (child.type === "JSXText") {
+    return typeof child.value === "string" && child.value.trim().length > 0;
+  }
+  if (child.type === "JSXExpressionContainer") {
+    return child.expression?.type !== "JSXEmptyExpression";
+  }
+  return true;
+}
+function hasMarker(opening) {
+  return opening.attributes.some((attribute) => attribute.type === "JSXAttribute" && attribute.name?.name === marker);
+}
+function isLazyCall(expression) {
+  if (expression.type !== "CallExpression")
+    return false;
+  const callee = expression.callee;
+  if (!callee)
+    return false;
+  if (callee.type === "Identifier")
+    return callee.name === "lazy";
+  return callee.type === "MemberExpression" && identifierName(callee.property) === "lazy";
+}
+function identifierName(node) {
+  const named = node;
+  return typeof named?.name === "string" ? named.name : undefined;
+}
+function sourceValue(statement) {
+  const literal = statement.source;
+  return typeof literal?.value === "string" ? literal.value : undefined;
+}
+function walk(node, visit) {
+  if (Array.isArray(node)) {
+    for (const item of node)
+      walk(item, visit);
+    return;
+  }
+  if (!node || typeof node !== "object")
+    return;
+  const candidate = node;
+  if (typeof candidate.type === "string")
+    visit(candidate);
+  for (const key in candidate) {
+    if (key !== "type")
+      walk(candidate[key], visit);
+  }
+}
+function langForFile(file) {
+  return /\.[cm]?ts$/.test(file) ? "ts" : "tsx";
+}
+
+export { rewriteLegacyLinkValidation };

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 };