@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-2vz0wzdn.js

@@ -0,0 +1,59 @@
+// @bun
+import {
+  currentRequest,
+  getWorkUnit
+} from "./index-grta8ap3.js";
+
+// src/compat/lifecycle/after-scope.ts
+import { AsyncLocalStorage } from "async_hooks";
+var REQUEST_PATH_KEY = Symbol.for("pnext.requestPath");
+var INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
+var requestApiScope = new AsyncLocalStorage;
+function runWithAfterRequestApiScope(allowed, callback) {
+  return requestApiScope.run(allowed, callback);
+}
+function afterRequestApisAllowed() {
+  return requestApiScope.getStore() === true;
+}
+function recordRequestPath(pathname) {
+  const unit = getWorkUnit();
+  if (unit)
+    (unit.compat ??= {})[REQUEST_PATH_KEY] = pathname;
+}
+function currentRoutePath() {
+  const recorded = getWorkUnit()?.compat?.[REQUEST_PATH_KEY];
+  if (recorded)
+    return recorded;
+  try {
+    const request = currentRequest();
+    return request ? new URL(request.url).pathname : "";
+  } catch {
+    return "";
+  }
+}
+function lifecycleError(message) {
+  const formatted = `Error: ${message}`;
+  return {
+    name: "Error",
+    message,
+    stack: formatted,
+    toString: () => formatted,
+    [INSPECT_CUSTOM]: () => formatted
+  };
+}
+function assertRequestApiAllowedInAfter(api) {
+  const unit = getWorkUnit();
+  if (unit?.phase !== "after")
+    return;
+  if (afterRequestApisAllowed() && currentRequest())
+    return;
+  const suffix = api === "connection()" ? "" : " This is not supported.";
+  throw lifecycleError(`Route ${currentRoutePath()} used \`${api}\` inside \`after()\`.${suffix}`);
+}
+function assertDraftModeToggleAllowedInAfter(method) {
+  if (getWorkUnit()?.phase !== "after")
+    return;
+  throw lifecycleError(`Route ${currentRoutePath()} used "draftMode().${method}()" inside \`after()\``);
+}
+
+export { runWithAfterRequestApiScope, afterRequestApisAllowed, recordRequestPath, lifecycleError, assertRequestApiAllowedInAfter, assertDraftModeToggleAllowedInAfter };

package/dist/server/_chunks/index-2wfv4kvx.js

@@ -0,0 +1,182 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  currentRequest,
+  getWorkUnit
+} from "./index-grta8ap3.js";
+
+// src/compat/lifecycle/testmode.ts
+import { PassThrough } from "stream";
+import { createRequire } from "module";
+var requireNode = createRequire(Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/compat/lifecycle/testmode.ts").href);
+var TEST_PROXY_KEY = Symbol.for("pnext.testProxy");
+function readTestProxyInfo(headers) {
+  const portHeader = headers.get("next-test-proxy-port");
+  if (!portHeader)
+    return;
+  return { proxyPort: Number(portHeader), testData: headers.get("next-test-data") ?? "" };
+}
+function activateTestProxy(headers) {
+  const info = readTestProxyInfo(headers);
+  if (!info)
+    return;
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  (unit.compat ??= {})[TEST_PROXY_KEY] = info;
+}
+function currentTestProxyInfo() {
+  const workUnitInfo = getWorkUnit()?.compat?.[TEST_PROXY_KEY];
+  if (workUnitInfo)
+    return workUnitInfo;
+  const request = currentRequest();
+  if (!request)
+    return;
+  return readTestProxyInfo(request.headers);
+}
+async function buildProxyRequest(testData, request) {
+  return {
+    testData,
+    api: "fetch",
+    request: {
+      url: request.url,
+      method: request.method,
+      headers: [...Array.from(request.headers), ["next-test-stack", getTestStack()]],
+      body: request.body ? Buffer.from(await request.arrayBuffer()).toString("base64") : null,
+      cache: request.cache,
+      credentials: request.credentials,
+      integrity: request.integrity,
+      mode: request.mode === "navigate" ? "cors" : request.mode,
+      redirect: request.redirect,
+      referrer: request.referrer,
+      referrerPolicy: request.referrerPolicy
+    }
+  };
+}
+function getTestStack() {
+  let stack = (new Error().stack ?? "").split(`
+`);
+  for (let i = 1;i < stack.length; i++) {
+    const line = stack[i];
+    if (line && line.length > 0) {
+      stack = stack.slice(i);
+      break;
+    }
+  }
+  stack = stack.filter((item) => !item.includes("/next/dist/"));
+  stack = stack.slice(0, 5);
+  stack = stack.map((line) => line.replace("webpack-internal:///(rsc)/", "").trim());
+  return stack.join("    ");
+}
+async function handleProxiedFetch(originalFetch, info, request) {
+  const proxyRequest = await buildProxyRequest(info.testData, request);
+  const resp = await originalFetch(`http://localhost:${info.proxyPort}`, {
+    method: "POST",
+    body: JSON.stringify(proxyRequest),
+    next: { internal: true }
+  });
+  if (!resp.ok)
+    throw new Error(`Proxy request failed: ${resp.status}`);
+  const proxyResponse = await resp.json();
+  switch (proxyResponse.api) {
+    case "continue":
+      return originalFetch(request);
+    case "fetch": {
+      const r = proxyResponse.response;
+      return new Response(r.body ? Buffer.from(r.body, "base64") : null, {
+        status: r.status,
+        headers: new Headers(r.headers)
+      });
+    }
+    default:
+      throw new Error(`Proxy request aborted [${request.method} ${request.url}]`);
+  }
+}
+function buildResponseMessage(responsePromise, callback) {
+  const stream = new PassThrough;
+  const message = stream;
+  responsePromise.then(async (response) => {
+    const headers = {};
+    const rawHeaders = [];
+    for (const [name, value] of response.headers) {
+      headers[name.toLowerCase()] = value;
+      rawHeaders.push(name, value);
+    }
+    message.statusCode = response.status;
+    message.statusMessage = response.statusText;
+    message.headers = headers;
+    message.rawHeaders = rawHeaders;
+    message.complete = true;
+    callback?.(message);
+    const body = await response.arrayBuffer();
+    stream.end(Buffer.from(body));
+  }).catch((error) => {
+    stream.emit("error", error);
+    stream.end();
+  });
+  return message;
+}
+function getStringForGetInput(input) {
+  if (typeof input === "string" || input instanceof URL)
+    return input.toString();
+  const candidate = input;
+  if (typeof candidate.href === "string" && /^[a-z][a-z\d+.-]*:\/\//i.test(candidate.href))
+    return candidate.href;
+  const protocol = typeof candidate.protocol === "string" ? candidate.protocol : "http:";
+  const host = typeof candidate.host === "string" ? candidate.host : typeof candidate.hostname === "string" ? candidate.hostname : undefined;
+  if (!host)
+    return;
+  const port = typeof candidate.port === "number" ? `:${candidate.port}` : typeof candidate.port === "string" ? `:${candidate.port}` : "";
+  const path = typeof candidate.path === "string" ? candidate.path : typeof candidate.pathname === "string" ? candidate.pathname : "/";
+  const search = typeof candidate.search === "string" ? candidate.search : "";
+  return `${protocol}//${host}${port}${path}${search}`;
+}
+function patchableGet(originalGet, originalFetch) {
+  return (input, options) => {
+    const callback = typeof options === "function" ? options : undefined;
+    const url = getStringForGetInput(input);
+    const info = currentTestProxyInfo();
+    if (!url || !info) {
+      if (typeof options === "function") {
+        return originalGet(input, options);
+      }
+      if (options === undefined) {
+        return originalGet(input);
+      }
+      return originalGet(input, options);
+    }
+    const request = new Request(url, {
+      method: typeof options === "object" && options && "method" in options && typeof options.method === "string" ? options.method : "GET",
+      headers: typeof options === "object" && options && "headers" in options ? options.headers : undefined
+    });
+    return buildResponseMessage(handleProxiedFetch(originalFetch, info, request), callback);
+  };
+}
+var patched = false;
+function installTestProxyFetch() {
+  if (patched)
+    return;
+  patched = true;
+  const originalFetch = globalThis.fetch.bind(globalThis);
+  const testFetch = function testFetch2(input, init) {
+    const nextInit = init?.next;
+    if (nextInit?.internal) {
+      return originalFetch(input, init);
+    }
+    const info = currentTestProxyInfo();
+    if (!info)
+      return originalFetch(input, init);
+    return handleProxiedFetch(originalFetch, info, new Request(input, init));
+  };
+  testFetch.preconnect = originalFetch.preconnect?.bind(originalFetch);
+  globalThis.fetch = testFetch;
+  const httpModule = requireNode("node:http");
+  const httpsModule = requireNode("node:https");
+  const originalHttpGet = httpModule.get;
+  const originalHttpsGet = httpsModule.get;
+  httpModule.get = patchableGet(originalHttpGet, originalFetch);
+  httpsModule.get = patchableGet(originalHttpsGet, originalFetch);
+}
+
+export { activateTestProxy, installTestProxyFetch };

package/dist/server/_chunks/index-357na4a8.js

@@ -0,0 +1,109 @@
+// @bun
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+
+// src/compat/next/image/config.ts
+var DEFAULTS = {
+  deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+  imageSizes: [32, 48, 64, 96, 128, 256, 384],
+  path: "/_next/image",
+  loader: "default",
+  loaderFile: "",
+  domains: [],
+  disableStaticImages: false,
+  minimumCacheTTL: 14400,
+  formats: ["image/webp"],
+  maximumRedirects: 3,
+  maximumResponseBody: 50000000,
+  dangerouslyAllowLocalIP: false,
+  dangerouslyAllowSVG: false,
+  contentSecurityPolicy: `script-src 'none'; frame-src 'none'; sandbox;`,
+  contentDispositionType: "attachment",
+  localPatterns: undefined,
+  remotePatterns: [],
+  qualities: [75],
+  unoptimized: false,
+  customCacheHandler: false
+};
+var cached;
+function asNumberArray(value, fallback) {
+  if (!Array.isArray(value))
+    return fallback;
+  const nums = value.filter((v) => typeof v === "number");
+  return nums.length > 0 ? nums : fallback;
+}
+function getImagesConfig() {
+  const raw = getNextConfig().images;
+  if (cached && cached.key === raw)
+    return cached.value;
+  const images = raw && typeof raw === "object" ? raw : {};
+  const deviceSizes = asNumberArray(images.deviceSizes, [...DEFAULTS.deviceSizes]).sort((a, b) => a - b);
+  const imageSizes = asNumberArray(images.imageSizes, [...DEFAULTS.imageSizes]).sort((a, b) => a - b);
+  const qualities = images.qualities === undefined ? [...DEFAULTS.qualities ?? []] : asNumberArray(images.qualities, [...DEFAULTS.qualities ?? []]).sort((a, b) => a - b);
+  const value = {
+    deviceSizes,
+    imageSizes,
+    allSizes: [...deviceSizes, ...imageSizes].sort((a, b) => a - b),
+    qualities,
+    formats: Array.isArray(images.formats) ? images.formats : [...DEFAULTS.formats],
+    path: typeof images.path === "string" ? images.path : DEFAULTS.path,
+    loader: typeof images.loader === "string" ? images.loader : DEFAULTS.loader,
+    loaderFile: typeof images.loaderFile === "string" ? images.loaderFile : DEFAULTS.loaderFile,
+    domains: Array.isArray(images.domains) ? images.domains : [...DEFAULTS.domains],
+    disableStaticImages: typeof images.disableStaticImages === "boolean" ? images.disableStaticImages : DEFAULTS.disableStaticImages,
+    minimumCacheTTL: typeof images.minimumCacheTTL === "number" ? images.minimumCacheTTL : DEFAULTS.minimumCacheTTL,
+    maximumRedirects: typeof images.maximumRedirects === "number" ? images.maximumRedirects : DEFAULTS.maximumRedirects,
+    maximumResponseBody: typeof images.maximumResponseBody === "number" ? images.maximumResponseBody : DEFAULTS.maximumResponseBody,
+    dangerouslyAllowLocalIP: typeof images.dangerouslyAllowLocalIP === "boolean" ? images.dangerouslyAllowLocalIP : DEFAULTS.dangerouslyAllowLocalIP,
+    dangerouslyAllowSVG: typeof images.dangerouslyAllowSVG === "boolean" ? images.dangerouslyAllowSVG : DEFAULTS.dangerouslyAllowSVG,
+    contentSecurityPolicy: typeof images.contentSecurityPolicy === "string" ? images.contentSecurityPolicy : DEFAULTS.contentSecurityPolicy,
+    contentDispositionType: typeof images.contentDispositionType === "string" ? images.contentDispositionType : DEFAULTS.contentDispositionType,
+    localPatterns: normalizeLocalPatterns(images.localPatterns),
+    remotePatterns: normalizeRemotePatterns(images.remotePatterns),
+    unoptimized: typeof images.unoptimized === "boolean" ? images.unoptimized : DEFAULTS.unoptimized,
+    customCacheHandler: Boolean(images.customCacheHandler)
+  };
+  cached = { key: raw, value };
+  return value;
+}
+function normalizeLocalPatterns(value) {
+  if (!Array.isArray(value))
+    return;
+  const patterns = value.map((entry) => {
+    if (typeof entry === "string")
+      return { pathname: entry, search: "" };
+    const obj = entry ?? {};
+    return {
+      pathname: typeof obj.pathname === "string" ? obj.pathname : undefined,
+      search: typeof obj.search === "string" ? obj.search : undefined
+    };
+  });
+  patterns.push({ pathname: "/_next/static/media/**", search: "" }, { pathname: "/_next/static/immutable/media/**", search: "" });
+  return patterns;
+}
+function normalizeRemotePatterns(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.map((entry) => {
+    if (entry instanceof URL) {
+      return {
+        protocol: entry.protocol.replace(/:$/, ""),
+        hostname: entry.hostname,
+        ...entry.port ? { port: entry.port } : {},
+        pathname: entry.pathname,
+        search: entry.search
+      };
+    }
+    const obj = entry ?? {};
+    return {
+      protocol: typeof obj.protocol === "string" ? obj.protocol : undefined,
+      hostname: typeof obj.hostname === "string" ? obj.hostname : undefined,
+      port: typeof obj.port === "string" ? obj.port : undefined,
+      pathname: typeof obj.pathname === "string" ? obj.pathname : undefined,
+      search: typeof obj.search === "string" ? obj.search : undefined
+    };
+  });
+}
+
+export { getImagesConfig };

package/dist/server/_chunks/index-3b3at80h.js

@@ -0,0 +1,109 @@
+// @bun
+import {
+  restartCacheEnabled
+} from "./index-knp0s912.js";
+import {
+  frameworkFingerprint
+} from "./index-c0g2wf3z.js";
+import {
+  writeFileAtomic
+} from "./index-20ppawv7.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(config.outPath, "cache", "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 };