@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,112 @@
+// @bun
+import {
+  restartCacheEnabled
+} from "./index-knp0s912.js";
+import {
+  frameworkFingerprint
+} from "./index-gcmj16xy.js";
+import {
+  writeFileAtomic
+} from "./index-4da76t62.js";
+import {
+  outCachePath
+} from "./index-bzd2ef7t.js";
+
+// src/compat/next/font/cache.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { mkdir, stat } from "fs/promises";
+import path from "path";
+var INDEX_VERSION = 2;
+var indexes = new Map;
+function fontIndex(config) {
+  const file = path.join(outCachePath(config.outPath), "fonts", "index.json");
+  const existing = indexes.get(file);
+  if (existing)
+    return existing;
+  const created = { file, fonts: readIndex(file), dirty: false };
+  indexes.set(file, created);
+  process.on("exit", () => {
+    if (!created.dirty)
+      return;
+    created.dirty = false;
+    try {
+      writeFileSync(created.file, serializeIndex(created.fonts));
+    } catch {}
+  });
+  return created;
+}
+async function persistedFont(config, key) {
+  if (!restartCacheEnabled())
+    return;
+  const entry = fontIndex(config).fonts.get(key);
+  if (!entry)
+    return;
+  if (!entry.files.every((file) => existsSync(file)))
+    return;
+  const stats = await Promise.all(entry.sourceStats.map(async ([file, mtimeMs, size]) => {
+    const current = await stat(file).catch(() => {
+      return;
+    });
+    return current?.mtimeMs === mtimeMs && current.size === size;
+  }));
+  if (!stats.every(Boolean))
+    return;
+  return entry;
+}
+async function persistFont(config, key, font) {
+  const index = fontIndex(config);
+  const sourceStats = await Promise.all((font.sources ?? []).map(async (file) => {
+    const stats = await stat(file).catch(() => {
+      return;
+    });
+    return stats ? [file, stats.mtimeMs, stats.size] : undefined;
+  }));
+  if (sourceStats.some((entry) => entry === undefined))
+    return;
+  index.fonts.set(key, { ...font, sourceStats });
+  persist(index);
+}
+function persist(index) {
+  index.dirty = true;
+  if (index.flush)
+    return;
+  index.flush = setTimeout(async () => {
+    index.flush = undefined;
+    if (!index.dirty)
+      return;
+    const contents = serializeIndex(index.fonts);
+    try {
+      await mkdir(path.dirname(index.file), { recursive: true });
+      await writeFileAtomic(index.file, contents);
+      index.dirty = false;
+    } catch {}
+  }, 50);
+}
+function readIndex(file) {
+  const fonts = new Map;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return fonts;
+  }
+  if (parsed?.version !== INDEX_VERSION || parsed.runtime !== runtimeFingerprint()) {
+    return fonts;
+  }
+  for (const [key, entry] of Object.entries(parsed.fonts ?? {})) {
+    if (entry && Array.isArray(entry.files) && Array.isArray(entry.sourceStats)) {
+      fonts.set(key, entry);
+    }
+  }
+  return fonts;
+}
+function serializeIndex(fonts) {
+  return JSON.stringify({
+    version: INDEX_VERSION,
+    runtime: runtimeFingerprint(),
+    fonts: Object.fromEntries(fonts)
+  });
+}
+var runtimeFingerprint = () => frameworkFingerprint();
+
+export { persistedFont, persistFont };

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

@@ -0,0 +1,54 @@
+// @bun
+// src/utils/code.ts
+function escapeRegex(value) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+function specifierSniffTokens(keys) {
+  const heads = [
+    ...new Set([...keys].map((key) => {
+      const head = key.split("/").slice(0, key.startsWith("@") ? 2 : 1).join("/");
+      return head.replace(/\*.*$/, "");
+    }))
+  ];
+  return heads.filter((head) => !heads.some((other) => other !== head && head.startsWith(other)));
+}
+function uniqueIdentifier(source, base, ...used) {
+  const usedNames = new Set(used);
+  let name = base;
+  let index = 0;
+  while (source.includes(name) || usedNames.has(name)) {
+    index += 1;
+    name = `${base}${index}`;
+  }
+  return name;
+}
+function isIdentifier(value) {
+  return /^[A-Za-z_$][\w$]*$/.test(value);
+}
+function esbuildEntryExportNames(code) {
+  const scope = entryCommonJsScope(code);
+  const assignments = [
+    ...scope.matchAll(/module\.exports\s*=\s*(?:[A-Za-z_$][\w$]*\s*\(\s*)?([A-Za-z_$][\w$]*)\s*\)?\s*[;\n]/g)
+  ];
+  const entryVar = assignments.at(-1)?.[1];
+  if (!entryVar)
+    return [];
+  const exportCall = new RegExp(`[A-Za-z_$][\\w$]*\\(\\s*${escapeRegex(entryVar)}\\s*,\\s*\\{([\\s\\S]*?)\\}\\s*\\)`).exec(scope);
+  if (!exportCall?.[1])
+    return [];
+  return [
+    ...exportCall[1].matchAll(/(?:^|,)\s*(?:["']([^"']+)["']|([A-Za-z_$][\w$]*))\s*:\s*\(\s*\)\s*=>/g)
+  ].map((match) => match[1] ?? match[2]).filter((name) => Boolean(name && isIdentifier(name)));
+}
+function entryCommonJsScope(code) {
+  const wrapper = /(^|\n)export default ([A-Za-z_$][\w$]*)\(\)/.exec(code)?.[2];
+  if (!wrapper)
+    return code;
+  const start = code.lastIndexOf(`var ${wrapper} = `);
+  return start === -1 ? code : code.slice(start);
+}
+function stripComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+
+export { escapeRegex, specifierSniffTokens, uniqueIdentifier, isIdentifier, esbuildEntryExportNames, stripComments };

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-rgj5mx84.js

@@ -0,0 +1,101 @@
+// @bun
+import {
+  compileSource,
+  evaluateConditions,
+  loadNextConfig,
+  loadResolvedNextConfig,
+  parseConditions,
+  substitute
+} from "./index-he6n2bvp.js";
+
+// src/compat/next/config-headers.ts
+async function loadCompatHeaders(root) {
+  let config = await loadResolvedNextConfig(root);
+  if (typeof config?.headers !== "function")
+    config = await loadNextConfig(root);
+  const producer = config?.headers;
+  if (typeof producer !== "function")
+    return [];
+  let value;
+  try {
+    value = await producer();
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(value))
+    return [];
+  const rules = [];
+  for (const entry of value) {
+    if (!entry?.source || !Array.isArray(entry.headers))
+      continue;
+    const headers = parseHeaderPairs(entry.headers);
+    if (headers.length === 0)
+      continue;
+    const has = parseConditions(entry.has);
+    const missing = parseConditions(entry.missing);
+    if (has === null || missing === null)
+      continue;
+    const compiled = compileSource(entry.source);
+    if (!compiled)
+      continue;
+    rules.push({
+      ...compiled,
+      headers,
+      has,
+      missing,
+      outsideBasePath: entry.basePath === false
+    });
+  }
+  return rules;
+}
+function parseHeaderPairs(value) {
+  const pairs = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const { key, value: headerValue } = raw;
+    if (typeof key !== "string" || typeof headerValue !== "string")
+      continue;
+    pairs.push({ key, value: headerValue });
+  }
+  return pairs;
+}
+function resolveCompatHeaders(rules, pathname, ctx) {
+  const context = ctx ?? {
+    host: "",
+    headers: new Headers,
+    cookies: {},
+    query: new URLSearchParams
+  };
+  const resolved = [];
+  for (const rule of rules) {
+    const match = rule.regex.exec(pathname);
+    if (!match)
+      continue;
+    const params = {};
+    rule.paramNames.forEach((name, index) => {
+      params[name] = match[index + 1] ?? "";
+    });
+    const conditionParams = evaluateConditions(rule, context);
+    if (conditionParams === null)
+      continue;
+    Object.assign(params, conditionParams);
+    const hasParams = Object.keys(params).length > 0;
+    for (const pair of rule.headers) {
+      resolved.push(hasParams ? {
+        key: substitute(pair.key, params).pathname,
+        value: substitute(pair.value, params).pathname
+      } : pair);
+    }
+  }
+  return resolved;
+}
+function appPathname(pathname, basePath) {
+  if (!basePath)
+    return pathname;
+  if (pathname === basePath)
+    return "/";
+  return pathname.startsWith(`${basePath}/`) ? pathname.slice(basePath.length) : undefined;
+}
+
+export { loadCompatHeaders, resolveCompatHeaders, appPathname };