@wular/pnext 0.1.5 → 0.1.7

package/dist/server/_chunks/index-8kcxdfya.js

@@ -0,0 +1,206 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+// src/compat/next/custom-server.ts
+import { existsSync, lstatSync, readFileSync } from "fs";
+import { mkdir, rm, writeFile } from "fs/promises";
+import path from "path";
+var SERVER_ENTRY_NAMES = ["server.js", "server.mjs", "server.cjs", "server.ts"];
+var SHIM_VERSION = "0.0.0-pnext-custom-server";
+function hasCustomServerEntry(root) {
+  for (const name of SERVER_ENTRY_NAMES) {
+    const file = path.join(root, name);
+    if (!existsSync(file))
+      continue;
+    try {
+      const source = readFileSync(file, "utf8");
+      if (/(?:require\(\s*['"]next['"]\s*\)|from\s+['"]next['"])/.test(source))
+        return true;
+    } catch {}
+  }
+  return false;
+}
+async function emitCustomServerShim(config) {
+  if (!hasCustomServerEntry(config.root))
+    return;
+  const target = path.join(config.root, "node_modules", "next");
+  try {
+    const stat = lstatSync(target);
+    if (!stat.isSymbolicLink() && !isEmittedShim(target))
+      return;
+    await rm(target, { recursive: true, force: true });
+  } catch {}
+  await mkdir(target, { recursive: true });
+  await writeFile(path.join(target, "package.json"), `${JSON.stringify({ name: "next", version: SHIM_VERSION, main: "index.cjs" }, null, 2)}
+`);
+  await writeFile(path.join(target, "index.cjs"), customServerShimSource());
+}
+function isEmittedShim(target) {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(target, "package.json"), "utf8"));
+    return pkg.version === SHIM_VERSION;
+  } catch {
+    return false;
+  }
+}
+function customServerShimSource() {
+  const cliPath = path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/compat/next", "..", "..", "cli", "index.ts");
+  return `'use strict';
+// pnext custom-server shim for require('next') / import next from 'next'.
+// Generated by pnext build; see src/compat/next/custom-server.ts.
+const { spawn } = require('node:child_process');
+
+const PNEXT_CLI = ${JSON.stringify(cliPath)};
+const HOP_BY_HOP = new Set([
+  'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization',
+  'te', 'trailer', 'transfer-encoding', 'upgrade', 'host', 'accept-encoding',
+]);
+
+function createServer(options = {}) {
+  const dev = Boolean(options.dev);
+  const hostname = options.hostname || 'localhost';
+  const port = options.port || 3000;
+  let child;
+  let childExited;
+  let internalPort;
+
+  async function prepare() {
+    if (internalPort) return;
+    child = spawn(
+      'bun',
+      ['--conditions=react-server', PNEXT_CLI, dev ? 'dev' : 'start', '--port', '0', '--hostname', '127.0.0.1'],
+      {
+        cwd: process.cwd(),
+        env: { ...process.env, BROWSER: 'none', NODE_ENV: dev ? 'development' : 'production' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }
+    );
+    childExited = new Promise((resolve) => child.once('exit', resolve));
+    internalPort = await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error('pnext custom-server: timed out waiting for the pnext server to start')),
+        60000
+      );
+      let buffer = '';
+      // Echo the child's logs line by line, relabelling its "- Local: <internal>"
+      // ready banner: log scanners on THIS process's stdout (the Next e2e harness
+      // parses that exact line for the app URL) must not pick up the internal
+      // port, or every request would bypass the custom server. Line buffering
+      // keeps a coalesced/split chunk from slipping the raw banner through.
+      const echoLines = (out) => {
+        let tail = '';
+        const write = (text) => {
+          const merged = tail + text;
+          const cut = merged.lastIndexOf('\\n') + 1;
+          tail = merged.slice(cut);
+          if (cut === 0) return;
+          out.write(merged.slice(0, cut).replace(/-(\\s*)(Local|Network):/g, '[pnext internal]$1$2:'));
+        };
+        child.once('exit', () => { if (tail) { const rest = tail; tail = ''; out.write(rest); } });
+        return write;
+      };
+      const echoOut = echoLines(process.stdout);
+      const echoErr = echoLines(process.stderr);
+      const scan = (chunk, echo) => {
+        const text = chunk.toString('utf8');
+        echo(text);
+        if (internalPort) return;
+        buffer = (buffer + text).slice(-4096);
+        const match = /-\\s*Local:\\s+https?:\\/\\/[^:\\s]+:(\\d+)/.exec(buffer);
+        if (match) {
+          clearTimeout(timer);
+          resolve(Number(match[1]));
+        }
+      };
+      child.stdout.on('data', (chunk) => scan(chunk, echoOut));
+      child.stderr.on('data', (chunk) => scan(chunk, echoErr));
+      child.once('exit', (code) => {
+        clearTimeout(timer);
+        reject(new Error('pnext custom-server: the pnext server exited during startup (code ' + code + ')'));
+      });
+    });
+  }
+
+  async function handleRequest(req, res) {
+    if (!internalPort) throw new Error('pnext custom-server: prepare() must complete before handling requests');
+    const target = new URL(req.url || '/', 'http://127.0.0.1:' + internalPort);
+    const headers = {};
+    for (const [name, value] of Object.entries(req.headers)) {
+      if (value === undefined || HOP_BY_HOP.has(name)) continue;
+      headers[name] = Array.isArray(value) ? value.join(', ') : value;
+    }
+    if (req.headers.host) headers['x-forwarded-host'] = req.headers.host;
+    headers['x-forwarded-proto'] = 'http';
+    const method = (req.method || 'GET').toUpperCase();
+    const hasBody = method !== 'GET' && method !== 'HEAD';
+    const response = await fetch(target, {
+      method,
+      headers,
+      body: hasBody ? req : undefined,
+      duplex: hasBody ? 'half' : undefined,
+      redirect: 'manual',
+    });
+    res.statusCode = response.status;
+    for (const [name, value] of response.headers) {
+      if (['content-encoding', 'content-length', 'transfer-encoding', 'set-cookie'].includes(name)) continue;
+      if (name === 'location') {
+        // Rewrite child-origin absolute redirects back to a relative target so
+        // the browser stays on the custom server's host/port.
+        try {
+          const url = new URL(value);
+          if (url.hostname === '127.0.0.1' && Number(url.port) === internalPort) {
+            res.setHeader(name, url.pathname + url.search + url.hash);
+            continue;
+          }
+        } catch {}
+      }
+      res.setHeader(name, value);
+    }
+    const setCookies = typeof response.headers.getSetCookie === 'function' ? response.headers.getSetCookie() : [];
+    if (setCookies.length > 0) {
+      const existing = res.getHeader('set-cookie');
+      const merged = existing === undefined ? setCookies : [].concat(existing, setCookies);
+      res.setHeader('set-cookie', merged);
+    }
+    if (response.body) {
+      for await (const chunk of response.body) res.write(chunk);
+    }
+    res.end();
+  }
+
+  async function close() {
+    if (!child || child.exitCode !== null) return;
+    // Graceful: the pnext server stops accepting connections, drains pending
+    // after() callbacks, then exits 0. Escalate to SIGKILL only on a hang.
+    child.kill('SIGTERM');
+    await Promise.race([
+      childExited,
+      new Promise((resolve) => setTimeout(resolve, 15000).unref()),
+    ]);
+    if (child.exitCode === null) child.kill('SIGKILL');
+  }
+
+  return {
+    hostname,
+    port,
+    prepare,
+    close,
+    getRequestHandler: () => (req, res) => handleRequest(req, res).catch((error) => {
+      console.error('pnext custom-server: request failed:', error);
+      if (!res.headersSent) res.statusCode = 500;
+      res.end('Internal Server Error');
+    }),
+    getUpgradeHandler: () => (_req, socket) => { socket.destroy(); },
+    setAssetPrefix: () => {},
+    logError: (...args) => console.error(...args),
+    render: async (req, res) => { await handleRequest(req, res); },
+    renderToHTML: async () => { throw new Error('renderToHTML is not supported by the pnext custom server'); },
+  };
+}
+
+module.exports = createServer;
+module.exports.default = createServer;
+`;
+}
+
+export { hasCustomServerEntry, emitCustomServerShim };

package/dist/server/_chunks/index-91x12ykq.js

@@ -0,0 +1,274 @@
+// @bun
+import {
+  clientReferenceId
+} from "./index-ras0sdab.js";
+import {
+  dynamicCallFacts,
+  rewriteFacts
+} from "./index-z4z9zv3b.js";
+
+// src/resolve/dynamic.ts
+function sourceHasDynamicImport(source) {
+  return source.includes("@wular/pnext") || source.includes("next/dynamic");
+}
+function pnextDynamicImportNames(source, file = "module.tsx") {
+  const names = new Set;
+  if (!sourceHasDynamicImport(source))
+    return names;
+  for (const statement of rewriteFacts(file, source).imports) {
+    const { specifier } = statement;
+    const pnext = specifier === "@wular/pnext" || specifier === "@wular/pnext/dynamic";
+    const nextDynamic = specifier === "next/dynamic" || /compat\/next\/dynamic(?:\.tsx)?$/.test(specifier);
+    if (!pnext && !nextDynamic)
+      continue;
+    for (const binding of statement.bindings) {
+      if (binding.type)
+        continue;
+      if (pnext ? binding.imported === "dynamic" : binding.imported === "default") {
+        names.add(binding.local);
+      }
+    }
+  }
+  return names;
+}
+function dynamicCallsFromSource(source, dynamicNames) {
+  const calls = [];
+  if (dynamicNames.size === 0)
+    return calls;
+  let index = 0;
+  while ((index = nextDynamicCallIndex(source, dynamicNames, index)) !== -1) {
+    const name = dynamicNameAt(source, dynamicNames, index);
+    if (!name) {
+      index += 1;
+      continue;
+    }
+    const before = source[index - 1];
+    const after = source[index + name.length];
+    if (before && /[\w$]/.test(before) || after && /[\w$]/.test(after)) {
+      index += name.length;
+      continue;
+    }
+    const open = source.indexOf("(", index + name.length);
+    if (open === -1 || source.slice(index + name.length, open).trim()) {
+      index += name.length;
+      continue;
+    }
+    const close = matchingParen(source, open);
+    if (close === -1) {
+      index = open + 1;
+      continue;
+    }
+    calls.push({
+      index,
+      name,
+      open,
+      close,
+      source: source.slice(index, close + 1)
+    });
+    index = close + 1;
+  }
+  return calls;
+}
+function rewriteLiteralDynamicCalls(source, file) {
+  const dynamicNames = pnextDynamicImportNames(source, file);
+  if (dynamicNames.size === 0)
+    return source;
+  const facts = dynamicCallFacts(source, file);
+  const edits = [];
+  for (const call of dynamicCallsFromSource(source, dynamicNames)) {
+    const fact = factForCall(facts, call);
+    if (!fact?.literal)
+      continue;
+    edits.push({
+      start: fact.specifierStart,
+      end: fact.specifierEnd,
+      value: `() => import(${source.slice(fact.specifierStart, fact.specifierEnd)})`
+    });
+  }
+  if (edits.length === 0)
+    return source;
+  let next = source;
+  for (const edit of edits.reverse()) {
+    next = `${next.slice(0, edit.start)}${edit.value}${next.slice(edit.end)}`;
+  }
+  return next;
+}
+function rewriteDynamicCallTargets(source, resolve, file) {
+  const dynamicNames = pnextDynamicImportNames(source, file);
+  if (dynamicNames.size === 0)
+    return source;
+  const facts = dynamicCallFacts(source, file);
+  const edits = [];
+  for (const call of dynamicCallsFromSource(source, dynamicNames)) {
+    const target = loaderImportTargetForCall(call, facts);
+    if (!target)
+      continue;
+    const file2 = resolve(target.specifier);
+    if (!file2)
+      continue;
+    const args = source.slice(call.open + 1, call.close);
+    const argCount = topLevelArgCount(args);
+    if (argCount < 1 || argCount > 2)
+      continue;
+    const id = `c-${clientReferenceId(file2, target.exportName)}`;
+    const literal = JSON.stringify({ file: file2, exportName: target.exportName, id });
+    const separator = /,\s*$/.test(args) ? "" : ", ";
+    edits.push({
+      at: call.close,
+      value: `${separator}${argCount === 1 ? "undefined, " : ""}${literal}`
+    });
+  }
+  if (edits.length === 0)
+    return source;
+  let next = source;
+  for (const edit of edits.reverse()) {
+    next = `${next.slice(0, edit.at)}${edit.value}${next.slice(edit.at)}`;
+  }
+  return next;
+}
+function factForCall(facts, call) {
+  return facts.find((fact) => fact.start === call.index);
+}
+function loaderImportTargetForCall(call, facts) {
+  const fact = factForCall(facts, call);
+  return fact && !fact.literal ? fact : undefined;
+}
+function devDynamicSplitEnabled() {
+  return process.env.PNEXT_DYNAMIC_SPLIT !== "0";
+}
+function rewriteDeferredDynamicImports(source, file, resolve, href) {
+  const dynamicNames = pnextDynamicImportNames(source, file);
+  if (dynamicNames.size === 0)
+    return source;
+  const deferred = deferredDynamicImportSpecifiers(source, file);
+  if (deferred.size === 0)
+    return source;
+  const facts = dynamicCallFacts(source, file);
+  const edits = [];
+  for (const call of dynamicCallsFromSource(source, dynamicNames)) {
+    const target = loaderImportTargetForCall(call, facts);
+    if (!target || !deferred.has(target.specifier))
+      continue;
+    const resolved = resolve(target.specifier);
+    if (!resolved)
+      continue;
+    const url = href({ file: resolved, exportName: target.exportName });
+    if (!url)
+      continue;
+    edits.push({ start: target.specifierStart + 1, end: target.specifierEnd - 1, value: url });
+  }
+  if (edits.length === 0)
+    return source;
+  let next = source;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    next = `${next.slice(0, edit.start)}${edit.value}${next.slice(edit.end)}`;
+  }
+  return next;
+}
+function deferredDynamicImportSpecifiers(source, file) {
+  const deferred = new Set;
+  const dynamicNames = pnextDynamicImportNames(source, file);
+  if (dynamicNames.size === 0)
+    return deferred;
+  const optionConsts = new Map;
+  const constPattern = /const\s+([A-Za-z_$][\w$]*)\s*=\s*({[\s\S]*?})\s*(?:as\s+const\s*)?;/g;
+  let constMatch;
+  while (constMatch = constPattern.exec(source)) {
+    if (constMatch[1] && constMatch[2])
+      optionConsts.set(constMatch[1], constMatch[2]);
+  }
+  const facts = dynamicCallFacts(source, file);
+  for (const call of dynamicCallsFromSource(source, dynamicNames)) {
+    const target = loaderImportTargetForCall(call, facts);
+    if (!target)
+      continue;
+    const tail = source.slice(target.loaderEnd, call.close);
+    let options = tail;
+    for (const identifier of tail.match(/[A-Za-z_$][\w$]*/g) ?? []) {
+      const named = optionConsts.get(identifier);
+      if (named)
+        options += `
+${named}`;
+    }
+    const ssrFalse = /\bssr\s*:\s*false\b/.test(options);
+    const visible = /\bload\s*:\s*['"]visible['"]/.test(options) && !/\bssr\s*:\s*true\b/.test(options);
+    if (ssrFalse || visible)
+      deferred.add(target.specifier);
+  }
+  return deferred;
+}
+function topLevelArgCount(args) {
+  let count = 0;
+  let depth = 0;
+  let quote = null;
+  let sawArg = false;
+  for (let index = 0;index < args.length; index += 1) {
+    const char = args[index];
+    if (quote) {
+      if (char === quote && args[index - 1] !== "\\")
+        quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      sawArg = true;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{")
+      depth += 1;
+    if (char === ")" || char === "]" || char === "}")
+      depth -= 1;
+    if (char === "," && depth === 0) {
+      if (sawArg)
+        count += 1;
+      sawArg = false;
+      continue;
+    }
+    if (!/\s/.test(char ?? ""))
+      sawArg = true;
+  }
+  return sawArg ? count + 1 : count;
+}
+function matchingParen(source, open) {
+  let depth = 0;
+  let quote = null;
+  for (let index = open;index < source.length; index += 1) {
+    const char = source[index];
+    const previous = source[index - 1];
+    if (quote) {
+      if (char === quote && previous !== "\\")
+        quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(")
+      depth += 1;
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0)
+        return index;
+    }
+  }
+  return -1;
+}
+function nextDynamicCallIndex(source, dynamicNames, fromIndex) {
+  let next = -1;
+  for (const name of dynamicNames) {
+    const index = source.indexOf(name, fromIndex);
+    if (index !== -1 && (next === -1 || index < next))
+      next = index;
+  }
+  return next;
+}
+function dynamicNameAt(source, dynamicNames, index) {
+  for (const name of dynamicNames) {
+    if (source.startsWith(name, index))
+      return name;
+  }
+  return;
+}
+
+export { sourceHasDynamicImport, pnextDynamicImportNames, dynamicCallsFromSource, rewriteLiteralDynamicCalls, rewriteDynamicCallTargets, devDynamicSplitEnabled, rewriteDeferredDynamicImports, deferredDynamicImportSpecifiers };

package/dist/server/_chunks/index-9ch50vtq.js

@@ -0,0 +1,18 @@
+// @bun
+// src/compat/react/view-transition.ts
+import { Fragment, h } from "preact";
+function ViewTransition({ children }) {
+  return h(Fragment, null, children);
+}
+ViewTransition.displayName = "ViewTransition";
+var pendingTransitionTypes = [];
+function addTransitionType(type) {
+  if (typeof type !== "string" || pendingTransitionTypes.includes(type))
+    return;
+  pendingTransitionTypes.push(type);
+}
+function takeTransitionTypes() {
+  return pendingTransitionTypes.splice(0, pendingTransitionTypes.length);
+}
+
+export { ViewTransition, addTransitionType, takeTransitionTypes };

package/dist/server/_chunks/index-9hx2641q.js

@@ -0,0 +1,28 @@
+// @bun
+import {
+  insideDataCacheProducer
+} from "./index-9n2914ww.js";
+import {
+  cacheComponents,
+  hangingPromise,
+  isPrerendering
+} from "./index-kresp2n8.js";
+
+// src/compat/ppr/io.ts
+function resolvedIo() {
+  const promise = Promise.resolve();
+  promise.status = "fulfilled";
+  promise.value = undefined;
+  return promise;
+}
+function io() {
+  if (!cacheComponents())
+    return resolvedIo();
+  if (insideDataCacheProducer())
+    return resolvedIo();
+  if (isPrerendering())
+    return hangingPromise("io()");
+  return resolvedIo();
+}
+
+export { io };