@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,130 @@
+// @bun
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+import {
+  setResourceHintListener
+} from "./index-yhxkxghe.js";
+import {
+  getWorkUnit
+} from "./index-grta8ap3.js";
+import {
+  registerResponseFinalizers
+} from "./index-zqpqyg8p.js";
+
+// src/compat/next/resource-hints.ts
+var RESOURCE_HINTS_KEY = Symbol.for("pnext.compat.resourceHints");
+var DEFAULT_REACT_MAX_HEADERS_LENGTH = 6000;
+var resourceHintHeadersEnabled = true;
+function enableResourceHintHeaders(enabled) {
+  resourceHintHeadersEnabled = enabled;
+}
+function registerResourceHintFinalizer() {
+  registerResponseFinalizers(resourceHintResponseFinalizer);
+  setResourceHintListener((hint) => recordResourceHint(hint));
+}
+function recordResourceHint(hint) {
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  const existing = unit.compat?.[RESOURCE_HINTS_KEY] ?? [];
+  if (!unit.compat)
+    unit.compat = {};
+  unit.compat[RESOURCE_HINTS_KEY] = dedupeResourceHints([...existing, hint]);
+}
+function takeResourceHintsForResponse() {
+  const unit = getWorkUnit();
+  const compat = unit?.compat;
+  if (!compat)
+    return [];
+  const hints = compat[RESOURCE_HINTS_KEY] ?? [];
+  compat[RESOURCE_HINTS_KEY] = undefined;
+  return hints;
+}
+var ALLOWED_ROUTE_KINDS = new Set(["html", "data"]);
+function resourceHintResponseFinalizer(ctx) {
+  if (!shouldEmitResourceHintsHeader())
+    return;
+  if (ctx.hints?.runtime === "edge")
+    return;
+  if (!ALLOWED_ROUTE_KINDS.has(ctx.routeKind))
+    return;
+  const value = takeResourceHintHeader();
+  if (value === undefined)
+    return;
+  const existing = ctx.headers.get("link");
+  ctx.headers.set("link", existing ? `${existing}, ${value}` : value);
+}
+function shouldEmitResourceHintsHeader() {
+  return resourceHintHeadersEnabled;
+}
+function getReactMaxHeadersLength() {
+  const configValue = getNextConfig().reactMaxHeadersLength;
+  if (typeof configValue === "number" && Number.isFinite(configValue) && configValue >= 0) {
+    return Math.floor(configValue);
+  }
+  const envValue = process.env.TEST_REACT_MAX_HEADERS_LENGTH;
+  if (typeof envValue === "string" && envValue.trim() !== "") {
+    const parsed = Number.parseInt(envValue, 10);
+    if (Number.isFinite(parsed) && parsed >= 0)
+      return Math.floor(parsed);
+  }
+  return DEFAULT_REACT_MAX_HEADERS_LENGTH;
+}
+function takeResourceHintHeader() {
+  const hints = takeResourceHintsForResponse();
+  if (hints.length === 0)
+    return;
+  const maxLength = getReactMaxHeadersLength();
+  if (!(maxLength > 0))
+    return;
+  const entries = hints.map((hint) => formatLinkHeaderEntry(hint)).filter(Boolean);
+  if (entries.length === 0)
+    return;
+  const values = [];
+  for (const entry of entries) {
+    const candidate = values.length > 0 ? `${values.join(", ")}, ${entry}` : entry;
+    if (candidate.length > maxLength)
+      break;
+    values.push(entry);
+  }
+  return values.length === 0 ? undefined : values.join(", ");
+}
+function formatLinkHeaderEntry(hint) {
+  const parts = [`<${hint.url}>`, `rel=${hint.rel}`];
+  if (hint.as)
+    parts.push(`as="${hint.as}"`);
+  if (hint.crossOrigin !== undefined)
+    parts.push(`crossorigin="${hint.crossOrigin === "anonymous" ? "" : hint.crossOrigin}"`);
+  if (hint.type)
+    parts.push(`type="${hint.type}"`);
+  if (hint.media)
+    parts.push(`media="${hint.media}"`);
+  if (hint.sizes)
+    parts.push(`sizes="${hint.sizes}"`);
+  if (hint.title)
+    parts.push(`title="${hint.title}"`);
+  if (hint.hrefLang)
+    parts.push(`hreflang="${hint.hrefLang}"`);
+  if (hint.fetchPriority)
+    parts.push(`fetchpriority="${hint.fetchPriority}"`);
+  if (hint.nonce)
+    parts.push(`nonce="${hint.nonce}"`);
+  return parts.join("; ");
+}
+function dedupeResourceHints(hints) {
+  if (hints.length <= 1)
+    return hints;
+  const seen = new Set;
+  const next = [];
+  for (const hint of hints) {
+    const key = formatLinkHeaderEntry(hint);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    next.push(hint);
+  }
+  return next;
+}
+
+export { enableResourceHintHeaders, registerResourceHintFinalizer, recordResourceHint, takeResourceHintsForResponse, takeResourceHintHeader };

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

@@ -0,0 +1,125 @@
+// @bun
+import {
+  use
+} from "./index-h4xy648y.js";
+import {
+  useActionState
+} from "./index-68m3mwbd.js";
+import {
+  setSuspenseParity
+} from "./index-w6h8m6vp.js";
+import {
+  useOptimistic,
+  useTransition
+} from "./index-j2zrcp1k.js";
+
+// src/compat/react/preact.ts
+import ReactCompat from "preact/compat";
+setSuspenseParity({
+  beforeThrowSafety: applyAsyncClientComponent,
+  afterThrowSafety: applyThenableChildren
+});
+function applyThenableChildren(vnode) {
+  const props = vnode.props;
+  const children = props.children;
+  const resolved = thenableChildren(children);
+  if (resolved !== children)
+    props.children = resolved;
+}
+function thenableChildren(value) {
+  if (value && typeof value.then === "function") {
+    return ReactCompat.createElement(ReactCompat.Suspense, { fallback: null }, ReactCompat.createElement(ThenableChild, {
+      value
+    }));
+  }
+  if (!Array.isArray(value))
+    return value;
+  let changed = false;
+  const children = value.map((child) => {
+    const resolved = thenableChildren(child);
+    if (resolved !== child)
+      changed = true;
+    return resolved;
+  });
+  return changed ? children : value;
+}
+function ThenableChild({ value }) {
+  return use(value);
+}
+var asyncClientComponents = new WeakMap;
+function applyAsyncClientComponent(vnode) {
+  if (typeof window === "undefined" || typeof vnode.type !== "function")
+    return;
+  const component = vnode.type;
+  if (component.constructor.name !== "AsyncFunction")
+    return;
+  const renderComponent = component;
+  let wrapper = asyncClientComponents.get(component);
+  if (!wrapper) {
+    wrapper = (props) => {
+      const [result] = ReactCompat.useState(() => Promise.resolve(renderComponent(props)));
+      return ReactCompat.createElement(ReactCompat.Suspense, { fallback: null }, ReactCompat.createElement(ThenableChild, { value: result }));
+    };
+    asyncClientComponents.set(component, wrapper);
+  }
+  vnode.type = wrapper;
+}
+var preactUseSyncExternalStore = ReactCompat.useSyncExternalStore;
+function serverSnapshotAware(subscribe, getSnapshot, getServerSnapshot) {
+  if (typeof window === "undefined") {
+    if (!getServerSnapshot)
+      throw new Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering.");
+    return getServerSnapshot();
+  }
+  return preactUseSyncExternalStore(subscribe, getSnapshot);
+}
+var useSyncExternalStore = serverSnapshotAware;
+var preact_default = Object.assign(ReactCompat, { use, useActionState, useOptimistic, useTransition });
+if (true)
+  ReactCompat.useSyncExternalStore = useSyncExternalStore;
+var Children = ReactCompat.Children;
+var Component = ReactCompat.Component;
+var Fragment = ReactCompat.Fragment;
+var PureComponent = ReactCompat.PureComponent;
+var StrictMode = ReactCompat.StrictMode;
+var Suspense = ReactCompat.Suspense;
+var SuspenseList = ReactCompat.SuspenseList;
+var cloneElement = ReactCompat.cloneElement;
+var createContext = ReactCompat.createContext;
+var createElement = ReactCompat.createElement;
+var createFactory = ReactCompat.createFactory;
+var createPortal = ReactCompat.createPortal;
+var createRef = ReactCompat.createRef;
+var findDOMNode = ReactCompat.findDOMNode;
+var flushSync = ReactCompat.flushSync;
+var forwardRef = ReactCompat.forwardRef;
+var hydrate = ReactCompat.hydrate;
+var isFragment = ReactCompat.isFragment;
+var isMemo = ReactCompat.isMemo;
+var isValidElement = ReactCompat.isValidElement;
+var lazy = (loader) => {
+  const component = ReactCompat.lazy(loader);
+  component[Symbol.for("pnext.lazy")] = true;
+  return component;
+};
+var memo = ReactCompat.memo;
+var render = ReactCompat.render;
+var startTransition = ReactCompat.startTransition;
+var unmountComponentAtNode = ReactCompat.unmountComponentAtNode;
+var unstable_batchedUpdates = ReactCompat.unstable_batchedUpdates;
+var useCallback = ReactCompat.useCallback;
+var useContext = ReactCompat.useContext;
+var useDebugValue = ReactCompat.useDebugValue;
+var useDeferredValue = ReactCompat.useDeferredValue;
+var useEffect = ReactCompat.useEffect;
+var useId = ReactCompat.useId;
+var useImperativeHandle = ReactCompat.useImperativeHandle;
+var useInsertionEffect = ReactCompat.useInsertionEffect;
+var useLayoutEffect = ReactCompat.useLayoutEffect;
+var useMemo = ReactCompat.useMemo;
+var useReducer = ReactCompat.useReducer;
+var useRef = ReactCompat.useRef;
+var useState = ReactCompat.useState;
+var version = ReactCompat.version;
+
+export { useSyncExternalStore, preact_default, Children, Component, Fragment, PureComponent, StrictMode, Suspense, SuspenseList, cloneElement, createContext, createElement, createFactory, createPortal, createRef, findDOMNode, flushSync, forwardRef, hydrate, isFragment, isMemo, isValidElement, lazy, memo, render, startTransition, unmountComponentAtNode, unstable_batchedUpdates, useCallback, useContext, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, version };

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

@@ -0,0 +1,74 @@
+// @bun
+// src/compat/next/image/patterns.ts
+function makePathnameRegex(pathname) {
+  let source = "";
+  const escaped = pathname.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  source = escaped.replace(/\/\*\*/g, "(?:/.*)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+  return new RegExp(`^${source}$`);
+}
+function hasLocalMatch(localPatterns, url) {
+  if (localPatterns === undefined)
+    return true;
+  return localPatterns.some((pattern) => {
+    if (pattern.pathname !== undefined && !makePathnameRegex(pattern.pathname).test(url.pathname)) {
+      return false;
+    }
+    if (pattern.search !== undefined && pattern.search !== url.search)
+      return false;
+    return true;
+  });
+}
+function hasRemoteMatch(domains, remotePatterns, url) {
+  if (domains.includes(url.hostname))
+    return true;
+  return remotePatterns.some((pattern) => {
+    if (pattern.protocol !== undefined && pattern.protocol !== url.protocol.replace(/:$/, "")) {
+      return false;
+    }
+    if (pattern.hostname !== undefined && !matchHostname(pattern.hostname, url.hostname)) {
+      return false;
+    }
+    if (pattern.port !== undefined && pattern.port !== "" && pattern.port !== url.port) {
+      return false;
+    }
+    if (pattern.pathname !== undefined && !makePathnameRegex(pattern.pathname).test(url.pathname)) {
+      return false;
+    }
+    if (pattern.search !== undefined && pattern.search !== "" && pattern.search !== url.search) {
+      return false;
+    }
+    return true;
+  });
+}
+function matchHostname(pattern, hostname) {
+  if (pattern.startsWith("**.")) {
+    const suffix = pattern.slice(2);
+    return hostname.endsWith(suffix) && hostname.length > suffix.length;
+  }
+  if (pattern.startsWith("*.")) {
+    const suffix = pattern.slice(1);
+    if (!hostname.endsWith(suffix))
+      return false;
+    const sub = hostname.slice(0, -suffix.length);
+    return sub.length > 0 && !sub.includes(".");
+  }
+  return pattern === hostname;
+}
+function manifestLocalPatterns(localPatterns) {
+  const patterns = localPatterns ?? [{ pathname: undefined, search: "" }];
+  const entries = patterns.map((pattern) => ({
+    pathname: compileLocalPathname(pattern.pathname),
+    search: pattern.search ?? ""
+  }));
+  return entries;
+}
+function compileLocalPathname(pathname) {
+  if (pathname === undefined || pathname === "**") {
+    return "^(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$))(?:(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$)).)*?)\\/?)$";
+  }
+  const base = pathname.replace(/\/\*\*$/, "");
+  const escaped = base.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "\\/");
+  return `^(?:${escaped}(?:\\/(?!\\.{1,2}(?:\\/|$))(?:(?:(?!(?:^|\\/)\\.{1,2}(?:\\/|$)).)*?)|$))$`;
+}
+
+export { hasLocalMatch, hasRemoteMatch, manifestLocalPatterns };

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

@@ -0,0 +1,51 @@
+// @bun
+import {
+  traceEnabled
+} from "./index-vz0km5qk.js";
+
+// src/cli/boot/trace.ts
+import { loadavg, cpus, arch, platform } from "os";
+import { readdirSync } from "fs";
+import path from "path";
+var enabled = traceEnabled("boot");
+var marks = [];
+var cacheAtStart = enabled ? cacheState() : "cold";
+function cacheState() {
+  return countTopLevel(path.join(".pnext", "dev", "cache")) > 0 ? "warm" : "cold";
+}
+var rss = () => typeof process.memoryUsage.rss === "function" ? process.memoryUsage.rss() : process.memoryUsage().rss;
+function markBoot(name) {
+  if (enabled)
+    marks.push([name, performance.now(), rss()]);
+}
+function traceHeader() {
+  const load = loadavg().map((value) => value.toFixed(1)).join(" ");
+  const packages = countTopLevel("node_modules");
+  return [
+    `  runtime          ${typeof Bun !== "undefined" ? `bun ${Bun.version}` : `node ${process.version}`} \xB7 ${platform()} ${arch()} \xB7 ${cpus().length} cpus \xB7 load ${load}`,
+    `  app              ${packages} node_modules entries \xB7 .pnext/dev cache ${cacheAtStart}`
+  ];
+}
+function countTopLevel(dir) {
+  try {
+    return readdirSync(path.resolve(dir)).length;
+  } catch {
+    return 0;
+  }
+}
+function printBootTrace() {
+  if (!enabled || marks.length === 0)
+    return;
+  const lines = ["boot trace (ms since process start):", ...traceHeader()];
+  let previous = 0;
+  for (const [name, at, rss2] of marks) {
+    const mb = (rss2 / 1048576).toFixed(0).padStart(5);
+    lines.push(`  ${name.padEnd(16)} +${(at - previous).toFixed(1).padStart(7)}  @${at.toFixed(1)}  rss ${mb} MB`);
+    previous = at;
+  }
+  lines.push(`  total            @${performance.now().toFixed(1)}`);
+  console.log(lines.join(`
+`));
+}
+
+export { markBoot, printBootTrace };

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

@@ -0,0 +1,107 @@
+// @bun
+import {
+  onExtensionHostReset
+} from "./index-zqpqyg8p.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/runtime/fetch-host.ts
+var installed = false;
+var upstreamAborts = new WeakMap;
+function isHostKey(key) {
+  return typeof key === "string" && key.length === 4 && key.toLowerCase() === "host";
+}
+function hasHost(headers) {
+  if (headers instanceof Headers)
+    return headers.has("host");
+  if (Array.isArray(headers)) {
+    for (const entry of headers)
+      if (isHostKey(entry?.[0]))
+        return true;
+    return false;
+  }
+  for (const key in headers)
+    if (isHostKey(key))
+      return true;
+  return false;
+}
+function withoutHost(headers) {
+  const next = new Headers(headers);
+  next.delete("host");
+  return next;
+}
+function installFetchHostNormalization() {
+  if (installed)
+    return;
+  installed = true;
+  const original = globalThis.fetch.bind(globalThis);
+  globalThis.fetch = function fetch(input, init) {
+    const source = init?.headers ?? (input instanceof Request ? input.headers : undefined);
+    const normalized = source !== undefined && hasHost(source) ? { ...init, headers: withoutHost(source) } : init;
+    return trackUpstream(original, input, normalized);
+  };
+}
+function trackUpstream(original, input, init) {
+  const controller = new AbortController;
+  const caller = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+  const signal = caller ? AbortSignal.any([caller, controller.signal]) : controller.signal;
+  return original(input, { ...init, signal }).then((response) => {
+    if (response.body)
+      upstreamAborts.set(response.body, controller);
+    return response;
+  });
+}
+function abortUpstreamFetchOnDisconnect(body, signal) {
+  if (!body || !signal || !upstreamAborts.has(body))
+    return;
+  const abort = () => {
+    const controller = upstreamAborts.get(body);
+    if (!controller)
+      return;
+    upstreamAborts.delete(body);
+    controller.abort();
+  };
+  if (signal.aborted)
+    abort();
+  else
+    signal.addEventListener("abort", abort, { once: true });
+}
+
+// src/compat-bootstrap.ts
+function compatEnabled(config) {
+  const compat = config.compat;
+  return Boolean(compat?.next || compat?.react || compat?.reactCompiler);
+}
+var bootRegistration;
+var registration;
+onExtensionHostReset(() => {
+  bootRegistration = undefined;
+  registration = undefined;
+});
+function bootstrapCompatBoot(config) {
+  installFetchHostNormalization();
+  if (!compatEnabled(config))
+    return Promise.resolve();
+  bootRegistration ??= import("./boot-bhemypxz.js").then((module) => module.registerCompatBootExtensions(config));
+  return bootRegistration;
+}
+function bootstrapCompat(config, options = {}) {
+  installFetchHostNormalization();
+  if (!compatEnabled(config))
+    return Promise.resolve();
+  registration ??= bootstrapCompatBoot(config).then(() => import("./index-dgr390q7.js")).then((module) => module.registerCompatExtensions(config, options));
+  return registration;
+}
+async function generateCompatRouteTypes(config, routes) {
+  if (!config.compat?.next)
+    return;
+  const [{ writeTsconfigDefaults }, { generateTypedRoutes }] = await Promise.all([
+    import("./tsconfig-defaults-bcn34eqb.js"),
+    import("./generate-myw9hef7.js")
+  ]);
+  await writeTsconfigDefaults(config);
+  await generateTypedRoutes(config, routes);
+}
+
+export { abortUpstreamFetchOnDisconnect, bootstrapCompatBoot, bootstrapCompat, generateCompatRouteTypes };