@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,185 @@
+// @bun
+import {
+  assertDraftModeToggleAllowedInAfter,
+  assertRequestApiAllowedInAfter,
+  lifecycleError
+} from "./index-2vz0wzdn.js";
+import {
+  withSyncAccess
+} from "./index-y4d02znn.js";
+import {
+  assertNoDynamicApiInsideCache,
+  currentRenderCacheMeta
+} from "./index-akkrvjn6.js";
+import {
+  currentRequest,
+  currentResponseHeaders,
+  getWorkUnit,
+  legacyRequestAPIs,
+  requestApiPromise,
+  requireRequest
+} from "./index-grta8ap3.js";
+
+// src/compat/next/headers.ts
+var COOKIE_MUTATION_ERROR = "Cookies can only be modified in a Server Action or Route Handler. " + "Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options";
+function assertCookieMutationAllowed() {
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  if (unit.phase === "action")
+    return;
+  if (unit.phase !== "after" && unit.routeKind === "route-handler")
+    return;
+  throw new Error(COOKIE_MUTATION_ERROR);
+}
+var HEADERS_MUTATION_ERROR = "Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers";
+function readonlyHeaders(source) {
+  return new Proxy(source, {
+    get(target, prop) {
+      if (prop === "append" || prop === "set" || prop === "delete") {
+        return () => {
+          throw new Error(HEADERS_MUTATION_ERROR);
+        };
+      }
+      if (prop === "getSetCookie")
+        return () => [];
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function headers() {
+  assertRequestApiAllowedInAfter("headers()");
+  assertDynamicErrorRequestApi("headers()");
+  assertNoDynamicApiInsideCache("headers()");
+  const produce = () => readonlyHeaders(new Headers(requireRequest("headers()").headers));
+  const promise = requestApiPromise("headers()", produce);
+  return legacyRequestAPIs() ? withSyncAccess(promise, "headers", produce) : promise;
+}
+function cookies() {
+  assertRequestApiAllowedInAfter("cookies()");
+  assertDynamicErrorRequestApi("cookies()");
+  assertNoDynamicApiInsideCache("cookies()");
+  const produce = () => wrapCookieJar(requireRequest("cookies()").cookies);
+  const promise = requestApiPromise("cookies()", produce);
+  return legacyRequestAPIs() ? withSyncAccess(promise, "cookies", produce) : promise;
+}
+function assertDynamicErrorRequestApi(api) {
+  const meta = currentRenderCacheMeta();
+  if (!meta?.dynamicError)
+    return;
+  throw lifecycleError(`Route ${meta.route ?? ""} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${api}\`.`);
+}
+function wrapCookieJar(jar) {
+  return {
+    get: (name) => jar.get(cookieName(name)),
+    getAll: (name) => name === undefined ? jar.getAll() : jar.getAll(cookieName(name)),
+    has: (name) => jar.has(cookieName(name)),
+    get size() {
+      return jar.getAll().length;
+    },
+    [Symbol.iterator]() {
+      return jar.getAll().map((cookie) => [cookie.name, cookie])[Symbol.iterator]();
+    },
+    set(nameOrOptions, value, options) {
+      assertCookieMutationAllowed();
+      const parsed = normalizeSetArgs(nameOrOptions, value, options);
+      jar.set(parsed.name, parsed.value);
+      currentResponseHeaders()?.append("set-cookie", serializeSetCookie(parsed));
+      return this;
+    },
+    delete(name) {
+      assertCookieMutationAllowed();
+      const resolved = cookieName(name);
+      const existed = jar.delete(resolved);
+      currentResponseHeaders()?.append("set-cookie", serializeSetCookie({ name: resolved, value: "", path: "/", maxAge: 0 }));
+      return existed;
+    },
+    clear() {
+      for (const cookie of jar.getAll())
+        this.delete(cookie.name);
+      return this;
+    },
+    toString() {
+      return jar.getAll().map((cookie) => `${cookie.name}=${encodeURIComponent(cookie.value)}`).join("; ");
+    }
+  };
+}
+function cookieName(arg) {
+  if (typeof arg === "string")
+    return arg;
+  return typeof arg?.name === "string" ? arg.name : "";
+}
+function normalizeSetArgs(nameOrOptions, value, options) {
+  if (typeof nameOrOptions === "string") {
+    return { ...options ?? {}, name: nameOrOptions, value: stringifyCookieValue(value) };
+  }
+  return {
+    ...nameOrOptions,
+    name: String(nameOrOptions.name ?? ""),
+    value: String(nameOrOptions.value ?? "")
+  };
+}
+function stringifyCookieValue(raw) {
+  if (raw === undefined || raw === null)
+    return "";
+  if (typeof raw === "string")
+    return raw;
+  if (typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint") {
+    return String(raw);
+  }
+  return JSON.stringify(raw) ?? "";
+}
+function serializeSetCookie(cookie) {
+  const parts = [`${cookie.name}=${encodeURIComponent(cookie.value)}`];
+  parts.push(`Path=${cookie.path ?? "/"}`);
+  if (cookie.maxAge !== undefined)
+    parts.push(`Max-Age=${cookie.maxAge}`);
+  if (cookie.expires !== undefined) {
+    const date = cookie.expires instanceof Date ? cookie.expires : new Date(cookie.expires);
+    parts.push(`Expires=${date.toUTCString()}`);
+  }
+  if (cookie.domain)
+    parts.push(`Domain=${cookie.domain}`);
+  if (cookie.httpOnly)
+    parts.push("HttpOnly");
+  if (cookie.secure)
+    parts.push("Secure");
+  if (cookie.sameSite) {
+    const value = cookie.sameSite === true ? "Strict" : capitalize(cookie.sameSite);
+    parts.push(`SameSite=${value}`);
+  }
+  return parts.join("; ");
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+var draftCookieName = "__prerender_bypass";
+function draftMode() {
+  const request = currentRequest();
+  const requestCookies = request?.cookies;
+  const draft = {
+    get isEnabled() {
+      return requestCookies?.has(draftCookieName) ?? false;
+    },
+    enable() {
+      assertDraftModeToggleAllowedInAfter("enable");
+      const cookies2 = requireRequest("draftMode().enable()").cookies;
+      const value = cookies2.get(draftCookieName)?.value || bypassToken();
+      cookies2.set(draftCookieName, value);
+      currentResponseHeaders()?.append("set-cookie", `${draftCookieName}=${value}; Path=/; HttpOnly; SameSite=None; Secure`);
+    },
+    disable() {
+      assertDraftModeToggleAllowedInAfter("disable");
+      requireRequest("draftMode().disable()").cookies.delete(draftCookieName);
+      currentResponseHeaders()?.append("set-cookie", `${draftCookieName}=; Path=/; Max-Age=0; HttpOnly; SameSite=None; Secure`);
+    }
+  };
+  const promise = Promise.resolve(draft);
+  return legacyRequestAPIs() ? withSyncAccess(promise, "draftMode", () => draft) : promise;
+}
+function bypassToken() {
+  return globalThis.crypto?.randomUUID?.().replace(/-/g, "") ?? Math.random().toString(36).slice(2);
+}
+
+export { headers, cookies, assertDynamicErrorRequestApi, draftMode };

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

@@ -0,0 +1,18 @@
+// @bun
+// src/render/postpone.ts
+var postponeSymbol = Symbol.for("pnext.postpone");
+
+class PostponeError extends Error {
+  api;
+  [postponeSymbol] = true;
+  constructor(api) {
+    super(`${api} postponed for partial prerendering`);
+    this.api = api;
+    this.name = "PostponeError";
+  }
+}
+function isPostpone(error) {
+  return typeof error === "object" && error !== null && postponeSymbol in error;
+}
+
+export { PostponeError, isPostpone };

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

@@ -0,0 +1,45 @@
+// @bun
+// src/compat/react/internals.ts
+var ReactSharedInternals = {
+  ReactCurrentDispatcher: { current: null },
+  ReactCurrentBatchConfig: { transition: null },
+  ReactCurrentOwner: { current: null },
+  ReactCurrentActQueue: { current: null, isBatchingLegacy: false, didScheduleLegacyUpdate: false },
+  ReactDebugCurrentFrame: { getCurrentStack: null }
+};
+var ReactClientInternals = {
+  H: null,
+  A: null,
+  T: null,
+  S: null,
+  actQueue: null,
+  asyncTransitions: 0,
+  isBatchingLegacy: false,
+  didScheduleLegacyUpdate: false,
+  didUsePromise: false,
+  thrownErrors: [],
+  getCurrentStack: null,
+  recentlyCreatedOwnerStacks: 0
+};
+var ReactDOMSharedInternals = {
+  usingClientEntryPoint: false,
+  Events: null,
+  d: {},
+  p: 0,
+  findDOMNode: null
+};
+var REACT_18_KEY = "__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED";
+var REACT_19_KEY = "__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE";
+function attachReactInternals(target) {
+  const slots = target;
+  if (slots[REACT_18_KEY])
+    Object.assign(ReactSharedInternals, slots[REACT_18_KEY]);
+  if (slots[REACT_19_KEY])
+    Object.assign(ReactClientInternals, slots[REACT_19_KEY]);
+  return Object.assign(target, {
+    [REACT_18_KEY]: ReactSharedInternals,
+    [REACT_19_KEY]: ReactClientInternals
+  });
+}
+
+export { ReactSharedInternals, ReactClientInternals, ReactDOMSharedInternals, attachReactInternals };

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

@@ -0,0 +1,22 @@
+// @bun
+import {
+  getWorkUnit
+} from "./index-grta8ap3.js";
+
+// src/compat/next/canonical-url.ts
+var CANONICAL_URL_KEY = Symbol.for("pnext.compat.navigation.canonicalUrl");
+function recordCanonicalUrl(from) {
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  const compat = unit.compat ??= {};
+  if (typeof compat[CANONICAL_URL_KEY] === "string")
+    return;
+  compat[CANONICAL_URL_KEY] = from.href;
+}
+function canonicalUrlHref() {
+  const value = getWorkUnit()?.compat?.[CANONICAL_URL_KEY];
+  return typeof value === "string" ? value : undefined;
+}
+
+export { recordCanonicalUrl, canonicalUrlHref };

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

@@ -0,0 +1,28 @@
+// @bun
+import {
+  insideDataCacheProducer
+} from "./index-akkrvjn6.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 };

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

@@ -0,0 +1,57 @@
+// @bun
+import {
+  pnextVersionRange
+} from "./index-4da76t62.js";
+import {
+  bold,
+  cyan,
+  dim
+} from "./index-6kp9r0d9.js";
+
+// src/utils/registry.ts
+var REGISTRY_URL = "https://registry.npmjs.org/@wular%2Fpnext";
+var TIMEOUT_MS = 2000;
+async function fetchLatestPublishedVersion() {
+  const response = await fetch(REGISTRY_URL, {
+    signal: AbortSignal.timeout(TIMEOUT_MS),
+    headers: { accept: "application/vnd.npm.install-v1+json" }
+  });
+  if (!response.ok)
+    return;
+  const body = await response.json();
+  return body["dist-tags"]?.latest;
+}
+var fetchLatestVersion = fetchLatestPublishedVersion;
+async function latestPnextVersionRange(command) {
+  const running = pnextVersionRange().slice(1);
+  const latest = await fetchLatestVersion().catch(() => {
+    return;
+  });
+  if (!latest)
+    return `^${running}`;
+  if (isNewer(latest, running))
+    warnStaleCli(command, running, latest);
+  return `^${latest}`;
+}
+function warnStaleCli(command, running, latest) {
+  console.error(`
+${bold("\u26A0 Your pnext CLI is out of date")} \u2014 running ${running}, latest is ${latest}.
+` + dim(`  bunx reused a cached copy. This project depends on ^${latest}, but ${command} ran with ${running}.
+`) + `  Re-run with: ${cyan(`bunx @wular/pnext@latest ${command}`)}
+`);
+}
+function isNewer(candidate, current) {
+  const parts = (value) => value.split("-")[0].split(".").map(Number);
+  const [a, b] = [parts(candidate), parts(current)];
+  for (let index = 0;index < 3; index += 1) {
+    const left = a[index] ?? 0;
+    const right = b[index] ?? 0;
+    if (!Number.isFinite(left) || !Number.isFinite(right))
+      return false;
+    if (left !== right)
+      return left > right;
+  }
+  return false;
+}
+
+export { latestPnextVersionRange };

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

@@ -0,0 +1,88 @@
+// @bun
+import {
+  readSourceSync
+} from "./index-fp8r0sqs.js";
+
+// src/compat/next/usage.ts
+import { existsSync, readdirSync } from "fs";
+import path from "path";
+var skipDirs = new Set(["node_modules", "dist", "build", "out", "coverage", "public", "target"]);
+var sourceFile = /\.(?:[cm]?[jt]sx?|mdx)$/;
+var imageApi = /next\/(?:legacy\/)?image|getImageProps|unstable_getImgProps/;
+var literalBlur = /\bplaceholder\s*[=:]\s*\{?\s*['"`]blur['"`]/;
+var opaquePlaceholder = /\bplaceholder\s*[=:]\s*(?!\{?\s*['"`])/;
+var opaqueProps = /\{\s*\.\.\.|export\s[^;]*from\s*['"]next\/(?:legacy\/)?image/;
+var cache = new Map;
+function scanRoots(root) {
+  const roots = [root];
+  for (let dir = path.dirname(root);dir !== path.dirname(dir); dir = path.dirname(dir)) {
+    if (!existsSync(path.join(dir, "pnpm-workspace.yaml")) && !existsSync(path.join(dir, "lerna.json"))) {
+      continue;
+    }
+    const packages = path.join(dir, "packages");
+    if (existsSync(packages))
+      roots.push(packages);
+    break;
+  }
+  return roots;
+}
+function appUsesBlurPlaceholder(root) {
+  const cached = cache.get(root);
+  if (cached !== undefined)
+    return cached;
+  const used = scanFirstPartySource(root, blurSource);
+  cache.set(root, used);
+  return used;
+}
+function blurSource(source) {
+  if (!imageApi.test(source))
+    return false;
+  return literalBlur.test(source) || opaquePlaceholder.test(source) || opaqueProps.test(source);
+}
+function scanFirstPartySource(root, match) {
+  return scanRoots(root).some((dir) => scan(dir, match));
+}
+function scan(dir, match) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith("."))
+      continue;
+    const file = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (skipDirs.has(entry.name))
+        continue;
+      if (scan(file, match))
+        return true;
+      continue;
+    }
+    if (!sourceFile.test(entry.name))
+      continue;
+    let source;
+    try {
+      source = readSourceSync(file);
+    } catch {
+      continue;
+    }
+    if (match(source))
+      return true;
+  }
+  return false;
+}
+var legacyProp = /\blegacyBehavior\b/;
+var reexportedLink = /export\s[^;]*from\s*['"]next\/link['"]/;
+var legacyLinkCache = new Map;
+function appUsesLegacyLink(root) {
+  const cached = legacyLinkCache.get(root);
+  if (cached !== undefined)
+    return cached;
+  const used = scanFirstPartySource(root, (source) => legacyProp.test(source) || reexportedLink.test(source));
+  legacyLinkCache.set(root, used);
+  return used;
+}
+
+export { appUsesBlurPlaceholder, scanFirstPartySource, appUsesLegacyLink };