@wular/pnext 0.1.6 → 0.1.8

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-38xpdxwd.js

@@ -0,0 +1,194 @@
+// @bun
+import {
+  scanRoutes
+} from "./index-jn9rbhrx.js";
+import {
+  ensureDir,
+  includeTypes,
+  toPosixPath,
+  writeFileAtomic
+} from "./index-4da76t62.js";
+import {
+  bootstrapCompatBoot,
+  generateCompatRouteTypes
+} from "./index-tq3b39a5.js";
+import {
+  loadConfig
+} from "./index-71885zaq.js";
+
+// src/cli/typegen.ts
+import { existsSync } from "fs";
+import { readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+async function typegenProject(root) {
+  const config = await loadConfig(root);
+  await bootstrapCompatBoot(config);
+  const routes = await scanRoutes(config.appPath, config.workspaceRoot);
+  const result = await writeTypegen(config, routes);
+  await generateCompatRouteTypes(config, routes);
+  return result;
+}
+async function writeTypegen(config, allRoutes) {
+  const routes = allRoutes.filter((route) => !route.interception && !route.synthetic);
+  const file = path.join(config.typesPath, "pnext.gen.d.ts");
+  const source = typegenSource(routes);
+  await writeIfChanged(file, source);
+  await writeCoreEnv(config, file, allRoutes);
+  const aliases = await writeRouteAliases(config, routes);
+  const checks = await writeChecks(config, routes);
+  return { file, routes: routes.length, checks, aliases };
+}
+function typegenSource(routes) {
+  const entries = routes.map((route) => routeEntry(route)).join(`
+`);
+  return `// This file is generated by PNext. Do not edit.
+import '@wular/pnext';
+
+declare module '@wular/pnext' {
+  interface PNextRoutes {
+${entries}
+  }
+}
+`;
+}
+function routeEntry(route) {
+  return `    '${routeKey(route.route)}': {
+      kind: '${route.kind}';
+      params: ${paramsType(route)};
+      mode: '${route.mode}';
+      hydrated: ${route.client ? "true" : "false"};
+    };`;
+}
+async function writeChecks(config, routes) {
+  const checksDir = config.checksPath;
+  await rm(path.join(config.typesPath, "checks"), { recursive: true, force: true });
+  await rm(checksDir, { recursive: true, force: true });
+  await ensureDir(checksDir);
+  const checked = routes.filter((route) => !route.metadataRoute);
+  await Promise.all(checked.map((route) => {
+    const file = path.join(checksDir, `${route.id}.check.ts`);
+    return writeIfChanged(file, checkSource(checksDir, route));
+  }));
+  return checked.length;
+}
+async function writeRouteAliases(config, routes) {
+  const aliasesDir = path.join(config.typesPath, "app");
+  await rm(aliasesDir, { recursive: true, force: true });
+  await ensureDir(aliasesDir);
+  await Promise.all(routes.map((route) => {
+    const file = path.join(aliasesDir, `${routeAliasPath(config, route)}.d.ts`);
+    return writeIfChanged(file, routeAliasSource(route));
+  }));
+  return routes.length;
+}
+function routeAliasSource(route) {
+  const routeType = routeKey(route.route);
+  return `// This file is generated by PNext. Do not edit.
+import type {
+  PageProps as PNextPageProps,
+  RouteContext as PNextRouteContext,
+  RouteParams as PNextRouteParams,
+  StaticParams as PNextStaticParams,
+} from '@wular/pnext';
+
+export type Params = PNextRouteParams<'${routeType}'>;
+export type PageProps = PNextPageProps<'${routeType}'>;
+export type RouteContext = PNextRouteContext<'${routeType}'>;
+export type StaticParams = PNextStaticParams<'${routeType}'>;
+`;
+}
+function routeAliasPath(config, route) {
+  const relative = toPosixPath(path.relative(config.appPath, route.file));
+  const extension = path.extname(relative);
+  return relative.slice(0, -extension.length);
+}
+function checkSource(checksDir, route) {
+  const routeImport = routeImportPath(checksDir, route.file);
+  const routeType = routeKey(route.route);
+  const moduleType = route.kind === "page" ? `PNextPageModule<'${routeType}'>` : `PNextRouteHandlerModule<'${routeType}'>`;
+  return `// This file is generated by PNext. Do not edit.
+import type { PNextPageModule, PNextRouteHandlerModule } from '@wular/pnext/internal';
+import * as routeModule from '${routeImport}';
+
+const check: ${moduleType} = routeModule;
+void check;
+`;
+}
+function routeImportPath(fromDir, file) {
+  const extension = path.extname(file);
+  const withoutExtension = file.slice(0, -extension.length);
+  const relative = toPosixPath(path.relative(fromDir, withoutExtension));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function routeKey(route) {
+  return route.replace(/:([a-zA-Z0-9_]+)\*/g, "[...$1]").replace(/:([a-zA-Z0-9_]+)/g, "[$1]");
+}
+function paramsType(route) {
+  const entries = route.params.map((param) => `${JSON.stringify(param)}: string`);
+  if (route.catchAll)
+    entries.push(`${JSON.stringify(route.catchAll)}: string[]`);
+  return entries.length > 0 ? `{ ${entries.join("; ")} }` : "Record<string, never>";
+}
+async function writeIfChanged(file, source) {
+  try {
+    if (existsSync(file) && await readFile(file, "utf8") === source)
+      return;
+  } catch {}
+  await ensureDir(path.dirname(file));
+  await writeFile(file, source);
+}
+async function writeCoreEnv(config, typesFile, routes) {
+  if (config.compat?.next)
+    return;
+  const file = path.join(config.root, "tsconfig.json");
+  const exists = existsSync(file);
+  if (!exists && !routes.some((route) => route.sourceFiles.some((file2) => /\.[cm]?tsx?$/.test(file2))))
+    return;
+  const reference = toPosixPath(path.relative(config.root, typesFile));
+  await writeIfChanged(path.join(config.root, "pnext-env.d.ts"), `/// <reference types="@wular/pnext" />
+/// <reference path="${reference}" />
+
+// This file is generated by PNext. Do not edit.
+`);
+  if (!exists)
+    return;
+  let source;
+  let tsconfig;
+  try {
+    source = await readFile(file, "utf8");
+    tsconfig = Bun.JSONC.parse(source);
+  } catch {
+    return;
+  }
+  if (!tsconfig || !Array.isArray(tsconfig.include))
+    return;
+  const typesGlob = `${toPosixPath(path.relative(config.root, config.typesPath))}/**/*.ts`;
+  const added = includeTypes(tsconfig, ["pnext-env.d.ts", typesGlob], []);
+  if (added.length)
+    await writeFileAtomic(file, updateTypeSelection(source, added));
+}
+function updateTypeSelection(source, added) {
+  const tokens = [
+    ...source.matchAll(/"(?:\\[\s\S]|[^"\\])*"|\/\/[^\r\n]*|\/\*[\s\S]*?\*\/|[^\s]/g)
+  ].filter((token) => !token[0].startsWith("//") && !token[0].startsWith("/*"));
+  let depth = 0;
+  for (let index = 0;index < tokens.length; index++) {
+    const token = tokens[index];
+    if (depth === 1 && token[0].startsWith('"') && JSON.parse(token[0]) === "include" && tokens[index + 1]?.[0] === ":") {
+      let end = index + 3;
+      while (tokens[end]?.[0] !== "]")
+        end++;
+      const close = tokens[end];
+      const previous = tokens[end - 1][0];
+      const insertion = `${previous === "[" || previous === "," ? "" : ","} ${added.map((value) => JSON.stringify(value)).join(", ")}`;
+      return source.slice(0, close.index) + insertion + source.slice(close.index);
+    }
+    if (token[0] === "[" || token[0] === "{")
+      depth++;
+    if (token[0] === "]" || token[0] === "}")
+      depth--;
+  }
+  return source;
+}
+
+export { typegenProject, writeTypegen };

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

@@ -0,0 +1,128 @@
+// @bun
+import {
+  findProxyFile
+} from "./index-3ycf5ckv.js";
+import {
+  loadNative
+} from "./index-7wc9n8be.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/routing/proxy-config.ts
+import { readFileSync } from "fs";
+import path from "path";
+var parseSync = (...args) => loadNative(() => __require("oxc-parser")).parseSync(...args);
+function releasedProxy(config) {
+  const file = findProxyFile(config);
+  if (!file)
+    return;
+  try {
+    return { file, config: staticProxyConfig(file, readFileSync(file, "utf8")) };
+  } catch {
+    return { file };
+  }
+}
+function staticProxyConfig(file, source) {
+  const result = parseSync(file, source, { lang: parserLang(file) });
+  if (result.errors.length > 0)
+    return;
+  for (const statement of result.program.body) {
+    if (statement.type !== "ExportNamedDeclaration")
+      continue;
+    const declaration = statement.declaration;
+    if (declaration?.type !== "VariableDeclaration")
+      continue;
+    for (const declarator of declaration.declarations ?? []) {
+      if (declarator.id?.type !== "Identifier" || declarator.id.name !== "config")
+        continue;
+      const value = staticValue(declarator.init);
+      return isProxyConfigShape(value) ? value : undefined;
+    }
+  }
+  return;
+}
+function parserLang(file) {
+  const ext = path.extname(file);
+  if (ext === ".tsx")
+    return "tsx";
+  if (ext === ".jsx")
+    return "jsx";
+  return ext === ".js" || ext === ".mjs" ? "js" : "ts";
+}
+function staticValue(node) {
+  if (!node)
+    return;
+  switch (node.type) {
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+      return staticValue(node.expression);
+    case "Literal":
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+      return node.value === null ? undefined : node.value;
+    case "TemplateLiteral":
+      return node.expressions?.length === 0 ? node.quasis?.[0]?.value?.cooked ?? undefined : undefined;
+    case "ArrayExpression": {
+      const items = [];
+      for (const element of node.elements ?? []) {
+        const value = staticValue(element);
+        if (value === undefined)
+          return;
+        items.push(value);
+      }
+      return items;
+    }
+    case "ObjectExpression": {
+      const object = {};
+      for (const property of node.properties ?? []) {
+        if (property.type !== "Property" && property.type !== "ObjectProperty")
+          return;
+        if (property.computed)
+          return;
+        const key = property.key?.type === "Identifier" ? property.key.name : property.key?.value;
+        if (typeof key !== "string")
+          return;
+        const value = staticValue(property.value);
+        if (value === undefined)
+          return;
+        object[key] = value;
+      }
+      return object;
+    }
+    default:
+      return;
+  }
+}
+function isProxyConfigShape(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const matcher = value.matcher;
+  if (matcher === undefined)
+    return true;
+  const items = Array.isArray(matcher) ? matcher : [matcher];
+  return items.every((item) => {
+    if (typeof item === "string")
+      return true;
+    if (typeof item !== "object" || item === null)
+      return false;
+    const { source, has, missing } = item;
+    if (typeof source !== "string")
+      return false;
+    return [has, missing].every((list) => list === undefined || Array.isArray(list) && list.every(isConditionShape));
+  });
+}
+function isConditionShape(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const { type, key, value: expected } = value;
+  if (type !== "header" && type !== "query" && type !== "cookie" && type !== "host")
+    return false;
+  if (key !== undefined && typeof key !== "string")
+    return false;
+  return expected === undefined || typeof expected === "string";
+}
+
+export { releasedProxy, staticProxyConfig };