@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,158 @@
+// @bun
+import {
+  getWorkUnit,
+  runWithRequest
+} from "./index-grta8ap3.js";
+import {
+  getRenderExtensions,
+  reportRequestError
+} from "./index-zqpqyg8p.js";
+
+// src/routing/handler.ts
+import { isNotFoundError, isRedirectError } from "../../../src/api/navigation.ts";
+import { nextResponseMeta, toNextRequest } from "../../../src/api/server.ts";
+import { safeDecode } from "../../../src/utils/decode.ts";
+var routeMethods = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+var httpMethods = new Set([
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+]);
+async function handleRouteModule(module, request, params, options = {}) {
+  const responseHeaders = new Headers;
+  const method = request.method.toUpperCase();
+  try {
+    if (!httpMethods.has(method))
+      return new Response(null, { status: 400 });
+    const handler = routeMethods.includes(method) ? module[method] : undefined;
+    if (!handler) {
+      if (method === "HEAD" && module.GET) {
+        const response = finalizeResponse(await callHandler(module.GET, request, params, responseHeaders), request, responseHeaders, options);
+        return new Response(null, { status: response.status, headers: response.headers });
+      }
+      return missingMethodResponse(module, method);
+    }
+    return finalizeResponse(await callHandler(handler, request, params, responseHeaders), request, responseHeaders, options);
+  } catch (error) {
+    if (isRedirectError(error)) {
+      const status = method === "POST" ? 303 : error.status;
+      return withResponseHeaders(new Response(null, { status, headers: { location: error.location } }), responseHeaders);
+    }
+    if (isNotFoundError(error)) {
+      return withResponseHeaders(new Response(null, { status: 404 }), responseHeaders);
+    }
+    await reportRequestError(error, { method, url: request.url, headers: request.headers }, { phase: "handler", routeKind: "route-handler", ...getWorkUnit()?.responseHints ?? {} });
+    console.error(error);
+    return new Response(null, { status: 500 });
+  }
+}
+function finalizeResponse(response, request, responseHeaders, options) {
+  const method = request.method.toUpperCase();
+  if (!response) {
+    const file = options.routeFile ?? "<route>";
+    console.error(`No response is returned from route handler '${file}'. Expected a Response object but ` + `received '${typeof response}' (method: ${method}, url: ${request.url}). Ensure you ` + "return a `Response` or a `NextResponse` in all branches of your handler.");
+    return new Response(null, { status: 500 });
+  }
+  if (nextResponseMeta(response)?.kind === "next") {
+    console.error("https://nextjs.org/docs/messages/next-response-next-in-app-route-handler");
+    return new Response(null, { status: 500 });
+  }
+  return withResponseHeaders(response, responseHeaders);
+}
+function callHandler(handler, request, params, responseHeaders) {
+  const nextRequest = toNextRequest(request);
+  const context = Object.keys(params).length > 0 ? {
+    params: getRenderExtensions().legacySyncProps(Promise.resolve(params), "params", params)
+  } : {};
+  return runWithRequest(nextRequest, () => handler(nextRequest, context), params, {
+    responseHeaders
+  });
+}
+function withResponseHeaders(response, extra) {
+  const withSetCookie = extra;
+  const scopeCookies = withSetCookie.getSetCookie?.() ?? [];
+  let hasOthers = false;
+  extra.forEach((_, key) => {
+    if (key !== "set-cookie")
+      hasOthers = true;
+  });
+  if (scopeCookies.length === 0 && !hasOthers)
+    return response;
+  const apply = (headers) => {
+    extra.forEach((value, key) => {
+      if (key !== "set-cookie")
+        headers.set(key, value);
+    });
+    const responseCookies = headers.getSetCookie?.() ?? [];
+    const jar = new Map;
+    for (const cookie of [...scopeCookies, ...responseCookies]) {
+      jar.set(cookieName(cookie), normalizeSetCookie(cookie));
+    }
+    headers.delete("set-cookie");
+    for (const cookie of jar.values())
+      headers.append("set-cookie", cookie);
+  };
+  try {
+    apply(response.headers);
+    return response;
+  } catch {
+    const headers = new Headers(response.headers);
+    apply(headers);
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+function cookieName(setCookie) {
+  return (setCookie.split("=")[0] ?? "").trim();
+}
+function normalizeSetCookie(setCookie) {
+  return /;\s*path=/i.test(setCookie) ? setCookie : `${setCookie}; Path=/`;
+}
+async function staticRouteParams(route, module) {
+  if (typeof module.GET !== "function")
+    return [];
+  const config = route.segmentConfig;
+  const optedStatic = config?.dynamic === "force-static" || config?.dynamic === "error" || config?.revalidate === false || typeof config?.revalidate === "number" && config.revalidate > 0;
+  if (route.hasStaticParams)
+    return module.params?.() ?? [];
+  if (route.usesRequest && !optedStatic)
+    return [];
+  return route.mode === "static" || optedStatic ? [{}] : [];
+}
+function routeParamsFromPath(route, pathname) {
+  const match = new RegExp(`^${route.pattern}$`).exec(pathname);
+  const params = {};
+  if (!match)
+    return params;
+  for (let index = 0;index < route.params.length; index += 1) {
+    params[route.params[index]] = safeDecode(match[index + 1] ?? "");
+  }
+  if (route.catchAll) {
+    params[route.catchAll] = (match[route.params.length + 1] ?? "").split("/").filter(Boolean).map(safeDecode);
+  }
+  return params;
+}
+function missingMethodResponse(module, method) {
+  const headers = { Allow: allowedMethods(module).join(", ") };
+  if (method === "OPTIONS")
+    return new Response(null, { status: 204, headers });
+  return new Response(null, { status: 405, headers });
+}
+function allowedMethods(module) {
+  const allowed = new Set(routeMethods.filter((method) => typeof module[method] === "function"));
+  if (allowed.has("GET"))
+    allowed.add("HEAD");
+  allowed.add("OPTIONS");
+  return [...allowed].sort();
+}
+
+export { handleRouteModule, staticRouteParams, routeParamsFromPath };

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

@@ -0,0 +1,97 @@
+// @bun
+// src/compat/next/user-agent.ts
+var URLPattern = globalThis.URLPattern;
+var botPattern = /bot|crawler|spider|crawling|slurp|bingpreview|facebookexternalhit|mediapartners|headless/i;
+function userAgentFromString(input) {
+  const ua = input ?? "";
+  return {
+    ua,
+    browser: parseBrowser(ua),
+    os: parseOs(ua),
+    device: parseDevice(ua),
+    engine: parseEngine(ua),
+    cpu: parseCpu(ua),
+    isBot: botPattern.test(ua)
+  };
+}
+function userAgent({ headers }) {
+  return userAgentFromString(headers.get("user-agent") ?? undefined);
+}
+function parseBrowser(ua) {
+  const edge = ua.match(/Edg(?:e|A|iOS)?\/([\d.]+)/);
+  if (edge)
+    return { name: "Edge", version: edge[1] };
+  const samsung = ua.match(/SamsungBrowser\/([\d.]+)/);
+  if (samsung)
+    return { name: "Samsung Internet", version: samsung[1] };
+  const chrome = ua.match(/(?:Chrome|CriOS)\/([\d.]+)/);
+  if (chrome)
+    return { name: "Chrome", version: chrome[1] };
+  const firefox = ua.match(/(?:Firefox|FxiOS)\/([\d.]+)/);
+  if (firefox)
+    return { name: "Firefox", version: firefox[1] };
+  if (ua.includes("Safari"))
+    return { name: "Safari", version: ua.match(/Version\/([\d.]+)/)?.[1] };
+  return {};
+}
+function parseEngine(ua) {
+  const gecko = ua.match(/rv:([\d.]+)\).*Gecko/);
+  if (gecko)
+    return { name: "Gecko", version: gecko[1] };
+  const webkit = ua.match(/AppleWebKit\/([\d.]+)/);
+  if (webkit) {
+    const chrome = ua.match(/(?:Chrome|CriOS|Edg(?:e|A|iOS)?|OPR)\/([\d.]+)/);
+    if (chrome)
+      return { name: "Blink", version: chrome[1] };
+    return { name: "WebKit", version: webkit[1] };
+  }
+  return {};
+}
+function parseCpu(ua) {
+  if (/arm64|aarch64/i.test(ua))
+    return { architecture: "arm64" };
+  if (/\barm\b/i.test(ua))
+    return { architecture: "arm" };
+  if (/x86_64|x64|Win64|WOW64/i.test(ua))
+    return { architecture: "amd64" };
+  if (/i686|\bx86\b/i.test(ua))
+    return { architecture: "ia32" };
+  return {};
+}
+function parseOs(ua) {
+  if (ua.includes("Windows"))
+    return { name: "Windows", version: ua.match(/Windows NT ([\d.]+)/)?.[1] };
+  if (ua.includes("Android"))
+    return { name: "Android", version: ua.match(/Android ([\d.]+)/)?.[1] };
+  if (/iPhone|iPad|iPod/.test(ua)) {
+    return { name: "iOS", version: ua.match(/OS (\d+(?:[_.]\d+)*)/)?.[1]?.replace(/_/g, ".") };
+  }
+  if (ua.includes("Mac OS X")) {
+    return {
+      name: "Mac OS",
+      version: ua.match(/Mac OS X (\d+(?:[_.]\d+)*)/)?.[1]?.replace(/_/g, ".")
+    };
+  }
+  if (ua.includes("Linux"))
+    return { name: "Linux" };
+  return {};
+}
+function parseDevice(ua) {
+  if (ua.includes("iPhone"))
+    return { type: "mobile", vendor: "Apple", model: "iPhone" };
+  if (ua.includes("iPad"))
+    return { type: "tablet", vendor: "Apple", model: "iPad" };
+  if (ua.includes("Android")) {
+    const type = ua.includes("Mobile") ? "mobile" : "tablet";
+    const samsung = ua.match(/\b(SM-[\w]+)\b/);
+    if (samsung)
+      return { type, vendor: "Samsung", model: samsung[1] };
+    const pixel = ua.match(/;\s*(Pixel[\w ]*?)\s*(?:Build|\))/);
+    if (pixel)
+      return { type, vendor: "Google", model: pixel[1] };
+    return { type };
+  }
+  return ua.includes("Mobile") ? { type: "mobile" } : {};
+}
+
+export { URLPattern, userAgentFromString, userAgent };

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

@@ -0,0 +1,26 @@
+// @bun
+// src/client/reference.ts
+import { createHash } from "crypto";
+import path from "path";
+var compiledClientReferences = new Set;
+function noteCompiledClientReference(file) {
+  compiledClientReferences.add(path.resolve(file));
+}
+function compiledClientReferenceFiles() {
+  return compiledClientReferences;
+}
+var clientReferenceSymbol = Symbol.for("pnext.clientReference");
+function clientReferenceId(file, exportName) {
+  return createHash("sha256").update(file).update("\x00").update(exportName).digest("hex").slice(0, 10);
+}
+function ssrClientReference(reference) {
+  if (reference.sideEffect)
+    return false;
+  if (reference.dynamic?.ssr === false)
+    return false;
+  if (reference.dynamic?.load === "visible" && reference.dynamic.ssr !== true)
+    return false;
+  return true;
+}
+
+export { noteCompiledClientReference, compiledClientReferenceFiles, clientReferenceSymbol, clientReferenceId, ssrClientReference };

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

@@ -0,0 +1,19 @@
+// @bun
+import {
+  getAssetExtensions
+} from "./index-zqpqyg8p.js";
+
+// src/cli/serve/immutable.ts
+var immutableCacheControl = "public, max-age=31536000, immutable";
+function immutableAssetPath(relativePath) {
+  return immutableAssetPrefixes().some((prefix) => relativePath.startsWith(prefix));
+}
+function immutableAssetPrefixes() {
+  return [
+    "assets/",
+    "_next/static/",
+    ...getAssetExtensions().staticAssetPublicPrefixes().map((prefix) => prefix.replace(/^\/+/, ""))
+  ];
+}
+
+export { immutableCacheControl, immutableAssetPath, immutableAssetPrefixes };

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

@@ -0,0 +1,126 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  readText
+} from "./index-20ppawv7.js";
+import {
+  pathToFileHref
+} from "./index-x93hv0sc.js";
+import {
+  clientReferenceId
+} from "./index-ras0sdab.js";
+import {
+  moduleExportNames,
+  moduleExportStars
+} from "./index-z4z9zv3b.js";
+import {
+  resolveImport
+} from "./index-yz54pxrh.js";
+
+// src/client/reference-stub.ts
+import path from "path";
+var clientReferenceRuntimeFile = path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/client", "reference.ts");
+function clientReferenceModuleSource(sourceFile, exportNames, options = {}) {
+  const portable = options.portable;
+  const located = portable ? `decodeURIComponent(new URL(${JSON.stringify(path.relative(path.dirname(portable.from), portable.target).split(path.sep).join("/"))}, import.meta.url).pathname)` : undefined;
+  const file = !located ? JSON.stringify(sourceFile) : portable?.real ? `__pnextRealpath(${located})` : located;
+  const reference = (exportName) => `createReference({ id: ${JSON.stringify(`c-${clientReferenceId(sourceFile, exportName)}`)}, file: ${file}, exportName: ${JSON.stringify(exportName)} })`;
+  const defaultExport = exportNames.includes("default") ? `export default ${reference("default")};` : "";
+  const namedExports = exportNames.filter((name) => name !== "default").map((name) => `export const ${name} = ${reference(name)};`);
+  const symbol = options.inlineSymbol ? `const clientReferenceSymbol = Symbol.for('pnext.clientReference');` : `import { clientReferenceSymbol } from ${JSON.stringify(pathToFileHref(clientReferenceRuntimeFile))};`;
+  const realpath = portable?.real ? `import { realpathSync as __pnextRealpath } from 'node:fs';
+` : "";
+  return `${realpath}${symbol}
+
+function createReference(reference) {
+  function ClientReference({ children }) {
+    return children ?? null;
+  }
+  ClientReference[clientReferenceSymbol] = reference;
+  return ClientReference;
+}
+
+${defaultExport}
+${namedExports.join(`
+`)}
+`;
+}
+async function clientReferenceExportNames(config, file, source, visited = new Set) {
+  const key = path.resolve(file);
+  if (visited.has(key))
+    return [];
+  visited.add(key);
+  const text = source ?? await readText(file);
+  const names = new Set(moduleExportNames(text, file));
+  if (names.size === 0) {
+    for (const match of text.matchAll(/\bexports\.([A-Za-z_$][\w$]*)\s*=/g)) {
+      if (match[1] !== "__esModule")
+        names.add(match[1]);
+    }
+    if (/\bmodule\.exports\s*=/.test(text))
+      names.add("default");
+  }
+  for (const specifier of moduleExportStars(text, file)) {
+    const resolved = resolveImport(config.root, file, specifier, config.workspaceRoot);
+    if (!resolved || !isInside(config.workspaceRoot, resolved))
+      continue;
+    for (const name of await clientReferenceExportNames(config, resolved, undefined, visited)) {
+      if (name !== "default")
+        names.add(name);
+    }
+  }
+  return [...names];
+}
+function hasUseClientDirective(source) {
+  const isSpace = (index) => {
+    const code = source.charCodeAt(index);
+    return code === 32 || code >= 9 && code <= 13 || code > 127 && /\s/.test(source[index]);
+  };
+  let i = 0;
+  for (;; ) {
+    while (i < source.length && isSpace(i))
+      i += 1;
+    if (source.startsWith("//", i)) {
+      const newline = source.indexOf(`
+`, i);
+      if (newline === -1)
+        return false;
+      i = newline + 1;
+      continue;
+    }
+    if (source.startsWith("/*", i)) {
+      const end2 = source.indexOf("*/", i + 2);
+      if (end2 === -1)
+        return false;
+      i = end2 + 2;
+      continue;
+    }
+    const quote = source[i];
+    if (quote !== '"' && quote !== "'")
+      return false;
+    let end = i + 1;
+    while (end < source.length) {
+      const char = source[end];
+      if (char === quote || char === `
+` || char === "\\")
+        break;
+      end += 1;
+    }
+    if (source[end] !== quote)
+      return false;
+    if (source.slice(i + 1, end) === "use client")
+      return true;
+    i = end + 1;
+    while (i < source.length && isSpace(i))
+      i += 1;
+    if (source[i] === ";")
+      i += 1;
+  }
+}
+function isInside(root, file) {
+  const relative = path.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+
+export { clientReferenceModuleSource, clientReferenceExportNames, hasUseClientDirective };

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

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };