@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,7 @@
+// @bun
+// src/dev/restart/enabled.ts
+function restartCacheEnabled() {
+  return process.env.PNEXT_DEV_RESTART_CACHE !== "0";
+}
+
+export { restartCacheEnabled };

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

@@ -0,0 +1,472 @@
+// @bun
+import {
+  devServerModuleHref,
+  registerServerRuntime
+} from "./index-3xbr4eyv.js";
+import {
+  pathToFileHref
+} from "./index-x93hv0sc.js";
+import {
+  runWithRequest
+} from "./index-grta8ap3.js";
+import {
+  getProxyExtensions,
+  withRouteRuntime
+} from "./index-zqpqyg8p.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/routing/proxy.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import path from "path";
+import {
+  copyMiddlewareHeaders,
+  forwardMiddlewareRequestHeaders,
+  getSetCookie,
+  NextResponse,
+  nextResponseMeta,
+  parseCookies,
+  requestCookieHeader,
+  toNextRequest
+} from "../../../src/api/server.ts";
+import { canonicalTrailingSlashPath, isBuildAssetPathname } from "../../../src/routing/href.ts";
+var proxyRewriteObserver;
+function setProxyRewriteObserver(observer) {
+  proxyRewriteObserver = observer;
+}
+var proxyRunObserver;
+function setProxyRunObserver(observer) {
+  proxyRunObserver = observer;
+}
+function wrapMiddleware(request, fn) {
+  return proxyRunObserver ? proxyRunObserver(request, fn) : fn();
+}
+var proxyExtensions = [".ts", ".tsx", ".js", ".jsx", ".mts"];
+function findProxyFile(config) {
+  return findProxyFiles(config)[0];
+}
+function proxyExternalLoadTarget(file) {
+  return path.basename(file).startsWith("proxy.") ? "client-ssr" : "edge";
+}
+function findProxyFiles(config, names = getProxyExtensions().names) {
+  const files = [];
+  for (const base of proxyBases(config)) {
+    for (const name of names) {
+      for (const extension of proxyExtensions) {
+        const file = path.join(base, `${name}${extension}`);
+        if (existsSync(file))
+          files.push(file);
+      }
+    }
+  }
+  return files;
+}
+async function validateProxyFiles(config) {
+  await getProxyExtensions().validateFiles(config);
+}
+function createProxyRunner(config, runnerOptions = {}) {
+  const { released } = runnerOptions;
+  const file = released ? released.file : findProxyFile(config);
+  const releasedMatchers = released?.config ? proxyMatchers(released.config) : undefined;
+  const runtimeReady = registerServerRuntime(config, file ? [file] : []);
+  runtimeReady.catch(() => {
+    return;
+  });
+  let moduleKey;
+  let modulePromise;
+  let matchers;
+  function proxyModule(options) {
+    const key = proxyModuleKey(options);
+    const load = () => runtimeReady.then(() => importProxyModule(config, file, options, runnerOptions));
+    if (key !== moduleKey) {
+      moduleKey = key;
+      modulePromise = load();
+      matchers = undefined;
+    }
+    return modulePromise ??= load();
+  }
+  const runner = async (request, options = {}) => {
+    const url = new URL(request.url);
+    if (url.pathname.startsWith("/__pnext/") || !config.compat?.next && isBuildAssetPathname(url.pathname)) {
+      return;
+    }
+    if (!file)
+      return;
+    if (!matchers && proxyMatcherGateEnabled()) {
+      const staticMatchers = released ? releasedMatchers : await staticProxyMatchers(file);
+      if (staticMatchers && !matchesProxy(staticMatchers, url, request))
+        return;
+    }
+    const module = await proxyModule(options);
+    matchers ??= proxyMatchers(module.config);
+    if (!matchesProxy(matchers, url, request))
+      return;
+    request = await bufferProxyRequestBody(request, url.pathname);
+    const handlerExport = getProxyExtensions().handlerExport(module);
+    if (typeof handlerExport !== "function")
+      throw new Error(`${file} must export proxy or default`);
+    const handler = handlerExport;
+    const handlerRequest = getProxyExtensions().skipUrlNormalize() ? request : stripFlightHeaders(stripRscUnionQuery(request));
+    const nextRequest = toNextRequest(handlerRequest);
+    const proxyResponseHeaders = new Headers;
+    let response = await runWithRequest(nextRequest, () => withRouteRuntime("edge", () => wrapMiddleware(nextRequest, () => handler(nextRequest, {
+      waitUntil(promise) {}
+    }))), {}, { responseHeaders: proxyResponseHeaders });
+    const scopedCookies = getSetCookie(proxyResponseHeaders);
+    if (scopedCookies.length > 0) {
+      if (!response)
+        response = NextResponse.next();
+      for (const cookie of scopedCookies)
+        response.headers.append("set-cookie", cookie);
+    }
+    if (!response)
+      return { request };
+    response = await normalizeRedirectResponse(response, url, request.method, config);
+    const meta = nextResponseMeta(response);
+    if (!meta)
+      return response;
+    const forwardedRequest = forwardMiddlewareRequestHeaders(response, applyProxyCookies(applyRequestOverride(request, meta.requestHeaders), response));
+    if (meta.kind === "rewrite" && meta.url) {
+      let rewritten = rewriteRequest(forwardedRequest, meta.url);
+      const rewrittenUrl = new URL(rewritten.url);
+      if (rewrittenUrl.origin !== url.origin) {
+        const rscHash = url.searchParams.get("_rsc");
+        if (rscHash !== null && !rewrittenUrl.searchParams.has("_rsc")) {
+          rewrittenUrl.searchParams.set("_rsc", rscHash);
+          rewritten = new Request(rewrittenUrl, rewritten);
+        }
+        getProxyExtensions().onExternalRewrite(rewritten);
+        const externalHeaders = new Headers(rewritten.headers);
+        externalHeaders.delete("host");
+        const external = await fetch(new Request(rewritten, { headers: externalHeaders }));
+        const headers = new Headers(external.headers);
+        headers.delete("content-encoding");
+        headers.delete("content-length");
+        headers.delete("transfer-encoding");
+        const proxied = new Response(external.body, {
+          status: external.status,
+          statusText: external.statusText,
+          headers
+        });
+        copyMiddlewareHeaders(response, proxied);
+        return proxied;
+      }
+      if (rewrittenUrl.origin === url.origin) {
+        proxyRewriteObserver?.(url, rewrittenUrl);
+        if (request.headers.get("x-nextjs-data") === "1") {
+          response.headers.set("x-nextjs-rewrite", rewrittenUrl.href);
+        }
+      }
+      return { request: rewritten, response };
+    }
+    return { request: forwardedRequest, response };
+  };
+  runner.warm = (options = {}) => {
+    if (!file)
+      return;
+    proxyModule(options).catch(() => {
+      return;
+    });
+  };
+  return runner;
+}
+async function normalizeRedirectResponse(response, requestUrl, method, config) {
+  if (response.status < 300 || response.status >= 400)
+    return response;
+  const location = response.headers.get("location");
+  if (!location)
+    return response;
+  let target;
+  try {
+    target = new URL(location, requestUrl);
+  } catch {
+    return response;
+  }
+  if (target.origin === requestUrl.origin) {
+    if (!config.skipTrailingSlashRedirect && config.trailingSlash) {
+      target.pathname = canonicalTrailingSlashPath(target.pathname, true);
+    }
+  }
+  const destination = target.origin === requestUrl.origin ? `${target.pathname}${target.search}${target.hash}` : target.href;
+  const headers = new Headers(response.headers);
+  headers.set("location", destination);
+  const body = method.toUpperCase() === "HEAD" || response.body === null ? null : await response.arrayBuffer();
+  const synthesizeDestination = method.toUpperCase() !== "HEAD" && (!body || body.byteLength === 0);
+  if (synthesizeDestination)
+    headers.delete("content-length");
+  return new Response(synthesizeDestination ? destination : body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function formatBodyLimit(bytes) {
+  if (bytes >= 1024 * 1024 && bytes % (1024 * 1024) === 0)
+    return `${bytes / (1024 * 1024)}MB`;
+  if (bytes >= 1024 && bytes % 1024 === 0)
+    return `${bytes / 1024}KB`;
+  return `${bytes}B`;
+}
+async function bufferProxyRequestBody(request, pathname) {
+  if (request.method === "GET" || request.method === "HEAD" || !request.body)
+    return request;
+  const limit = getProxyExtensions().clientMaxBodySize();
+  const chunks = [];
+  let total = 0;
+  let truncated = false;
+  const reader = request.body.getReader();
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    if (!truncated && total + value.byteLength > limit) {
+      const keep = limit - total;
+      if (keep > 0)
+        chunks.push(value.subarray(0, keep));
+      total = limit;
+      truncated = true;
+      continue;
+    }
+    if (!truncated) {
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  }
+  if (truncated) {
+    console.warn(`Request body exceeded ${formatBodyLimit(limit)} for ${pathname}`);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const headers = new Headers(request.headers);
+  headers.set("content-length", String(total));
+  return new Request(request.url, {
+    method: request.method,
+    headers,
+    body,
+    duplex: "half"
+  });
+}
+function applyProxyResponse(response, proxyResponse) {
+  if (proxyResponse)
+    copyMiddlewareHeaders(proxyResponse, response);
+  return response;
+}
+function proxyRoutePatterns(config) {
+  const matcher = config?.matcher;
+  if (!matcher)
+    return ["^/(.*)$"];
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.map((item) => anchoredMatcherPattern(matcherSource(item)));
+}
+async function importProxyModule(config, file, options, runnerOptions) {
+  const href = options.dev ? await devServerModuleHref(config, file, options.devImportVersion ?? "dev", {
+    conditionTarget: "edge",
+    externalLoadTarget: proxyExternalLoadTarget(file),
+    reactServerLayer: true
+  }) : runnerOptions.compiledModuleHref ?? pathToFileHref(file);
+  return import(href);
+}
+function proxyBases(config) {
+  return config.appPath === path.join(config.root, "src", "app") ? [path.join(config.root, "src"), config.root] : [config.root];
+}
+function proxyMatcherGateEnabled() {
+  return process.env.PNEXT_PROXY_MATCHER_GATE !== "0";
+}
+var staticMatcherCache = new Map;
+async function staticProxyMatchers(file) {
+  let key;
+  try {
+    const stats = statSync(file);
+    key = `${stats.size}:${stats.mtimeMs}`;
+  } catch {
+    return;
+  }
+  const cached = staticMatcherCache.get(file);
+  if (cached?.key === key)
+    return cached.matchers;
+  let matchers;
+  try {
+    const { staticProxyConfig } = await import("./proxy-config-j84dgksn.js");
+    const config = staticProxyConfig(file, readFileSync(file, "utf8"));
+    if (config)
+      matchers = proxyMatchers(config);
+  } catch {
+    matchers = undefined;
+  }
+  staticMatcherCache.set(file, { key, matchers });
+  return matchers;
+}
+function proxyMatchers(config) {
+  const matcher = config?.matcher;
+  if (!matcher)
+    return [{ regex: /.*/ }];
+  const matchers = Array.isArray(matcher) ? matcher : [matcher];
+  return matchers.map((item) => ({
+    regex: matcherRegex(matcherSource(item)),
+    ...typeof item === "object" && item.has ? { has: item.has } : {},
+    ...typeof item === "object" && item.missing ? { missing: item.missing } : {}
+  }));
+}
+function matchesProxy(matchers, url, request) {
+  const { pathname } = url;
+  const decoded = pathname.includes("%") ? decodedPathnames(pathname) : [];
+  return matchers.some((matcher) => (matcher.regex.test(pathname) || decoded.some((item) => matcher.regex.test(item))) && matchesConditions(matcher, url, request));
+}
+function matchesConditions(matcher, url, request) {
+  if (matcher.has && !matcher.has.every((condition) => hasCondition(condition, url, request))) {
+    return false;
+  }
+  if (matcher.missing?.some((condition) => hasCondition(condition, url, request))) {
+    return false;
+  }
+  return true;
+}
+function hasCondition(condition, url, request) {
+  const actual = conditionValue(condition, url, request);
+  if (actual === null)
+    return false;
+  if (condition.value === undefined)
+    return true;
+  try {
+    return new RegExp(`^${condition.value}$`).test(actual);
+  } catch {
+    return condition.value === actual;
+  }
+}
+function conditionValue(condition, url, request) {
+  switch (condition.type) {
+    case "header":
+      return condition.key ? request.headers.get(condition.key) : null;
+    case "query":
+      return condition.key ? url.searchParams.get(condition.key) : null;
+    case "cookie": {
+      if (!condition.key)
+        return null;
+      const cookie = parseCookies(request.headers.get("cookie") ?? "").find((item) => item.name === condition.key);
+      return cookie ? cookie.value : null;
+    }
+    case "host":
+      return url.host;
+    default:
+      return null;
+  }
+}
+function decodedPathnames(pathname) {
+  const decoded = [pathname.replace(/%2f/gi, "/")];
+  try {
+    decoded.push(decodeURIComponent(pathname));
+  } catch {}
+  return decoded;
+}
+function matcherSource(matcher) {
+  return typeof matcher === "string" ? matcher : matcher.source;
+}
+function matcherRegex(matcher) {
+  return new RegExp(anchoredMatcherPattern(matcher));
+}
+function anchoredMatcherPattern(matcher) {
+  return `^(?:${matcherPattern(matcher)})/*$`;
+}
+function matcherPattern(matcher) {
+  if (matcher.includes("("))
+    return matcher;
+  if (matcher === "/")
+    return "/";
+  let source = "";
+  for (const segment of matcher.split("/").filter(Boolean)) {
+    if (/^:[^/]+\*$/.test(segment)) {
+      source += "(?:/.*)?";
+    } else if (/^:[^/]+$/.test(segment)) {
+      source += "/[^/]+";
+    } else {
+      source += `/${escapeRegex(segment)}`;
+    }
+  }
+  return source || "/";
+}
+function rewriteRequest(request, url) {
+  return new Request(new URL(url, request.url), request);
+}
+function stripRscUnionQuery(request) {
+  const url = new URL(request.url);
+  if (!url.searchParams.has("_rsc"))
+    return request;
+  url.searchParams.delete("_rsc");
+  return new Request(url, request);
+}
+var FLIGHT_HEADERS = [
+  "rsc",
+  "next-router-state-tree",
+  "next-router-prefetch",
+  "next-hmr-refresh",
+  "next-router-segment-prefetch"
+];
+function stripFlightHeaders(request) {
+  if (!FLIGHT_HEADERS.some((header) => request.headers.has(header)))
+    return request;
+  const headers = new Headers(request.headers);
+  for (const header of FLIGHT_HEADERS)
+    headers.delete(header);
+  return new Request(request, { headers });
+}
+function applyRequestOverride(request, headers) {
+  if (!headers)
+    return request;
+  return new Request(request, { headers });
+}
+function applyProxyCookies(request, response) {
+  const setCookies = getSetCookie(response.headers);
+  if (setCookies.length === 0)
+    return request;
+  const cookies = parseCookies(request.headers.get("cookie") ?? "");
+  for (const header of setCookies) {
+    const cookie = parseSetCookie(header);
+    if (!cookie)
+      continue;
+    const index = cookies.findIndex((item) => item.name === cookie.name);
+    if (cookie.deleted) {
+      if (index !== -1)
+        cookies.splice(index, 1);
+      continue;
+    }
+    if (index === -1)
+      cookies.push({ name: cookie.name, value: cookie.value });
+    else
+      cookies[index] = { name: cookie.name, value: cookie.value };
+  }
+  const headers = new Headers(request.headers);
+  const cookieHeader = requestCookieHeader(cookies);
+  if (cookieHeader)
+    headers.set("cookie", cookieHeader);
+  else
+    headers.delete("cookie");
+  return new Request(request, { headers });
+}
+function parseSetCookie(header) {
+  const [pair = "", ...attributes] = header.split(";").map((part) => part.trim());
+  const [name = "", ...valueParts] = pair.split("=");
+  if (!name)
+    return;
+  const deleted = attributes.some((attribute) => /^max-age=0$/i.test(attribute));
+  return { name: decodeCookiePart(name), value: decodeCookiePart(valueParts.join("=")), deleted };
+}
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function proxyModuleKey(options) {
+  return options.dev ? `dev:${options.devImportVersion ?? "dev"}` : "prod";
+}
+
+export { setProxyRewriteObserver, setProxyRunObserver, findProxyFile, proxyExternalLoadTarget, findProxyFiles, validateProxyFiles, createProxyRunner, applyProxyResponse, proxyRoutePatterns };

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

@@ -0,0 +1,50 @@
+// @bun
+// src/compat/react/style-values.ts
+import { options } from "preact";
+var UNITLESS = " animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex" + " boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative" + " flexOrder fontWeight gridArea gridColumn gridColumnEnd gridColumnSpan gridColumnStart gridRow" + " gridRowEnd gridRowSpan gridRowStart lineClamp lineHeight opacity order orphans scale tabSize widows" + " zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit" + " strokeOpacity strokeWidth ";
+var VENDOR_PREFIX = /^(?:Webkit|Moz|ms|O)(?=[A-Z])/;
+function unitless(name) {
+  if (UNITLESS.includes(` ${name} `))
+    return true;
+  const base = name.replace(VENDOR_PREFIX, "");
+  return base !== name && UNITLESS.includes(` ${base[0].toLowerCase()}${base.slice(1)} `);
+}
+function reactStyleValue(name, value) {
+  if (typeof value === "boolean")
+    return "";
+  if (typeof value !== "number")
+    return;
+  if (value !== 0 && !name.startsWith("--") && !unitless(name))
+    return;
+  return String(value);
+}
+function applyReactStyleValues(vnode) {
+  if (typeof vnode.type !== "string")
+    return;
+  const props = vnode.props;
+  const style = props?.style;
+  if (!style || typeof style !== "object" || Array.isArray(style))
+    return;
+  let normalized;
+  for (const name in style) {
+    const resolved = reactStyleValue(name, style[name]);
+    if (resolved === undefined)
+      continue;
+    normalized ??= { ...style };
+    normalized[name] = resolved;
+  }
+  if (normalized)
+    props.style = normalized;
+}
+var installed = Symbol.for("pnext.react-style-values-installed");
+var styleOptions = options;
+if (!styleOptions[installed]) {
+  const previousVNode = options.vnode?.bind(options);
+  options.vnode = (vnode) => {
+    previousVNode?.(vnode);
+    applyReactStyleValues(vnode);
+  };
+  styleOptions[installed] = true;
+}
+
+export { reactStyleValue, applyReactStyleValues };