@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,311 @@
+// @bun
+import {
+  getNextConfig
+} from "./index-6e4fqv30.js";
+
+// src/compat/bundler/config.ts
+var PREDEFINED_SERVER_EXTERNAL_PACKAGES = [
+  "sharp",
+  "sqlite3",
+  "better-sqlite3",
+  "canvas",
+  "@node-rs/argon2",
+  "@node-rs/bcrypt"
+];
+var NEXT_SERVER_EXTERNAL_PACKAGES = new Set([
+  "@alinea/generated",
+  "@appsignal/nodejs",
+  "@aws-sdk/client-s3",
+  "@aws-sdk/s3-presigned-post",
+  "@blockfrost/blockfrost-js",
+  "@highlight-run/node",
+  "@huggingface/transformers",
+  "@jpg-store/lucid-cardano",
+  "@libsql/client",
+  "@mikro-orm/core",
+  "@mikro-orm/knex",
+  "@node-rs/argon2",
+  "@node-rs/bcrypt",
+  "@prisma/client",
+  "@react-pdf/renderer",
+  "@sentry/profiling-node",
+  "@sparticuz/chromium",
+  "@sparticuz/chromium-min",
+  "@statsig/statsig-node-core",
+  "@swc/core",
+  "@xenova/transformers",
+  "@zenstackhq/runtime",
+  "argon2",
+  "autoprefixer",
+  "aws-crt",
+  "bcrypt",
+  "better-sqlite3",
+  "canvas",
+  "chromadb-default-embed",
+  "config",
+  "cpu-features",
+  "cypress",
+  "dd-trace",
+  "eslint",
+  "express",
+  "firebase-admin",
+  "htmlrewriter",
+  "import-in-the-middle",
+  "isolated-vm",
+  "jest",
+  "jsdom",
+  "keyv",
+  "libsql",
+  "mdx-bundler",
+  "mongodb",
+  "mongoose",
+  "newrelic",
+  "next-mdx-remote",
+  "next-seo",
+  "node-cron",
+  "node-pty",
+  "node-web-audio-api",
+  "onnxruntime-node",
+  "oslo",
+  "pg",
+  "pino",
+  "pino-pretty",
+  "pino-roll",
+  "playwright",
+  "playwright-core",
+  "postcss",
+  "prettier",
+  "prisma",
+  "puppeteer",
+  "puppeteer-core",
+  "ravendb",
+  "require-in-the-middle",
+  "rimraf",
+  "sharp",
+  "shiki",
+  "sqlite3",
+  "thread-stream",
+  "ts-morph",
+  "ts-node",
+  "typescript",
+  "vscode-oniguruma",
+  "webpack",
+  "websocket",
+  "zeromq"
+]);
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function serverExternalPackages() {
+  const config = getNextConfig();
+  return new Set([
+    ...PREDEFINED_SERVER_EXTERNAL_PACKAGES,
+    ...stringArray(config.serverExternalPackages)
+  ]);
+}
+function deploymentId() {
+  const configured = getNextConfig().deploymentId;
+  if (typeof configured === "string" && configured.length > 0)
+    return configured;
+  const fromEnv = process.env.NEXT_DEPLOYMENT_ID;
+  return fromEnv && fromEnv.length > 0 ? fromEnv : undefined;
+}
+function builtInServerExternalPackages() {
+  return NEXT_SERVER_EXTERNAL_PACKAGES;
+}
+function publicRuntimeConfig() {
+  const config = getNextConfig().publicRuntimeConfig;
+  return config && typeof config === "object" ? config : {};
+}
+function transpilePackages() {
+  return stringArray(getNextConfig().transpilePackages);
+}
+function modularizeImports() {
+  const raw = getNextConfig().modularizeImports;
+  if (!raw || typeof raw !== "object")
+    return {};
+  const out = {};
+  for (const [specifier, value] of Object.entries(raw)) {
+    if (value && typeof value === "object" && typeof value.transform === "string") {
+      const rule = value;
+      out[specifier] = {
+        transform: rule.transform,
+        skipDefaultConversion: Boolean(rule.skipDefaultConversion)
+      };
+    }
+  }
+  return out;
+}
+function optimizePackageImports() {
+  const experimental = getNextConfig().experimental;
+  return stringArray(experimental?.optimizePackageImports);
+}
+function relayCompilerConfig() {
+  const compiler = getNextConfig().compiler;
+  const relay = compiler?.relay;
+  if (!relay || typeof relay !== "object" || typeof relay.src !== "string")
+    return;
+  const language = relay.language;
+  return {
+    src: relay.src,
+    artifactDirectory: typeof relay.artifactDirectory === "string" ? relay.artifactDirectory : undefined,
+    language: language === "typescript" || language === "flow" || language === "javascript" ? language : "javascript"
+  };
+}
+function esmExternals() {
+  const experimental = getNextConfig().experimental;
+  return experimental?.esmExternals ?? true;
+}
+function resolveExtensions() {
+  const config = getNextConfig();
+  const turbopack = config.turbopack;
+  const experimental = config.experimental;
+  for (const value of [
+    config.resolveExtensions,
+    turbopack?.resolveExtensions,
+    experimental?.turbo?.resolveExtensions
+  ]) {
+    const list = stringArray(value);
+    if (list.length > 0)
+      return list;
+  }
+  return;
+}
+function tsconfigPath() {
+  const ts = getNextConfig().typescript;
+  return typeof ts?.tsconfigPath === "string" ? ts.tsconfigPath : undefined;
+}
+function normalizeDefineMap(value) {
+  if (!value || typeof value !== "object")
+    return {};
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string")
+      out[key] = JSON.stringify(raw);
+    else if (typeof raw === "number" || typeof raw === "boolean")
+      out[key] = String(raw);
+  }
+  return out;
+}
+function compilerDefines() {
+  const compiler = getNextConfig().compiler;
+  return {
+    define: normalizeDefineMap(compiler?.define),
+    defineServer: normalizeDefineMap(compiler?.defineServer)
+  };
+}
+var CONSOLE_METHODS = [
+  "assert",
+  "clear",
+  "count",
+  "countReset",
+  "debug",
+  "dir",
+  "dirxml",
+  "error",
+  "group",
+  "groupCollapsed",
+  "groupEnd",
+  "info",
+  "log",
+  "table",
+  "time",
+  "timeEnd",
+  "timeLog",
+  "trace",
+  "warn"
+];
+function removeConsoleTargets() {
+  const compiler = getNextConfig().compiler;
+  const removeConsole = compiler?.removeConsole;
+  if (!removeConsole)
+    return;
+  const exclude = new Set(typeof removeConsole === "object" ? stringArray(removeConsole.exclude) : []);
+  return CONSOLE_METHODS.filter((method) => !exclude.has(method)).map((method) => `console.${method}`);
+}
+function cacheComponentsEnabled() {
+  const config = getNextConfig();
+  const experimental = config.experimental;
+  return Boolean(config.cacheComponents ?? experimental?.cacheComponents);
+}
+function swcEnvUsageMode() {
+  const experimental = getNextConfig().experimental;
+  const mode = experimental?.swcEnvOptions?.mode;
+  return mode === "usage" || mode === "entry" ? mode : undefined;
+}
+function reactCompilerEnabled() {
+  const config = getNextConfig();
+  const experimental = config.experimental;
+  return Boolean(config.reactCompiler ?? experimental?.reactCompiler);
+}
+function turbopackLoaderRules() {
+  const config = getNextConfig();
+  const turbopack = config.turbopack;
+  const rules = turbopack?.rules;
+  if (!rules || typeof rules !== "object")
+    return [];
+  const out = [];
+  for (const [glob, raw] of Object.entries(rules))
+    collectLoaderRuleEntries(glob, raw, out);
+  return out;
+}
+function collectLoaderRuleEntries(glob, raw, out) {
+  if (Array.isArray(raw)) {
+    if (raw.every((item) => typeof item === "string")) {
+      const loaders = stringArray(raw);
+      if (loaders.length > 0)
+        out.push({ glob, loaders });
+      return;
+    }
+    for (const item of raw) {
+      if (item && typeof item === "object")
+        pushLoaderRuleObject(glob, item, out);
+    }
+    return;
+  }
+  if (raw && typeof raw === "object")
+    pushLoaderRuleObject(glob, raw, out);
+}
+function pushLoaderRuleObject(glob, entry, out) {
+  const loaders = stringArray(entry.loaders);
+  const as = typeof entry.as === "string" ? entry.as : undefined;
+  const condition = parseRuleCondition(entry.condition);
+  if (loaders.length > 0) {
+    out.push({ glob, loaders, as, ...condition ? { condition } : {} });
+    return;
+  }
+  const assetType = parseAssetRuleType(entry.type);
+  if (assetType)
+    out.push({ glob, loaders: [], as, assetType });
+}
+function parseRuleCondition(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const query = value.query;
+  if (typeof query === "string" || query instanceof RegExp)
+    return { query };
+  return;
+}
+function parseAssetRuleType(value) {
+  if (value === "asset" || value === "asset/resource")
+    return "resource";
+  if (value === "bytes")
+    return "bytes";
+  if (value === "asset/source")
+    return "source";
+  return;
+}
+function turbopackResolveAlias() {
+  const turbopack = getNextConfig().turbopack;
+  const alias = turbopack?.resolveAlias;
+  if (!alias || typeof alias !== "object")
+    return {};
+  const out = {};
+  for (const [key, value] of Object.entries(alias)) {
+    if (typeof value === "string")
+      out[key] = value;
+  }
+  return out;
+}
+
+export { serverExternalPackages, deploymentId, builtInServerExternalPackages, publicRuntimeConfig, transpilePackages, modularizeImports, optimizePackageImports, relayCompilerConfig, esmExternals, resolveExtensions, tsconfigPath, compilerDefines, removeConsoleTargets, cacheComponentsEnabled, swcEnvUsageMode, reactCompilerEnabled, turbopackLoaderRules, turbopackResolveAlias };

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

@@ -0,0 +1,199 @@
+// @bun
+// src/compat/next/og.ts
+import { createRequire } from "module";
+import path from "path";
+var DEFAULT_WIDTH = 1200;
+var DEFAULT_HEIGHT = 630;
+var MAX_DIMENSION = 4096;
+var MAX_RAW_IMAGE_BYTES = 3 * 1024 * 1024;
+var PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+var crcTable;
+
+class ImageResponse extends Response {
+  static displayName = "ImageResponse";
+  constructor(element, options = {}) {
+    dimension(options.width, DEFAULT_WIDTH, "width");
+    dimension(options.height, DEFAULT_HEIGHT, "height");
+    const headers = new Headers(options.headers);
+    headers.set("content-type", "image/png");
+    if (!headers.has("cache-control")) {
+      headers.set("cache-control", "public, immutable, no-transform, max-age=31536000");
+    }
+    super(pngStream(element, options), {
+      status: options.status,
+      statusText: options.statusText,
+      headers
+    });
+  }
+}
+function pngStream(element, options) {
+  return new ReadableStream({
+    async start(controller) {
+      let bytes;
+      try {
+        bytes = await renderWithVercelOg(element, options) ?? await renderWithSatori(element, options) ?? createFallbackPng(options);
+      } catch {
+        bytes = createFallbackPng(options);
+      }
+      controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+async function renderWithVercelOg(element, options) {
+  const og = await loadFromAppRoot("@vercel/og");
+  if (!og?.ImageResponse)
+    return;
+  const width = dimension(options.width, DEFAULT_WIDTH, "width");
+  const height = dimension(options.height, DEFAULT_HEIGHT, "height");
+  const response = new og.ImageResponse(element, {
+    width,
+    height,
+    ...options.fonts === undefined ? {} : { fonts: options.fonts },
+    ...options.debug === undefined ? {} : { debug: options.debug },
+    ...options.emoji === undefined ? {} : { emoji: options.emoji }
+  });
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  return bytes.length > 0 ? bytes : undefined;
+}
+async function renderWithSatori(element, options) {
+  const fonts = normalizeFonts(options.fonts);
+  if (fonts.length === 0)
+    return;
+  const satori = await loadOptional("satori");
+  const resvg = await loadOptional("@resvg/resvg-js");
+  if (!satori || !resvg)
+    return;
+  const width = dimension(options.width, DEFAULT_WIDTH, "width");
+  const height = dimension(options.height, DEFAULT_HEIGHT, "height");
+  const svg = await satori.default(element, {
+    width,
+    height,
+    fonts,
+    ...options.debug === undefined ? {} : { debug: options.debug },
+    ...options.emoji === undefined ? {} : { emoji: options.emoji }
+  });
+  const renderer = new resvg.Resvg(svg, {
+    fitTo: { mode: "width", value: width }
+  });
+  return renderer.render().asPng();
+}
+function normalizeFonts(fonts) {
+  if (!fonts)
+    return [];
+  return fonts.map((font) => ({
+    name: font.name,
+    data: font.data,
+    ...font.weight === undefined ? {} : { weight: font.weight },
+    ...font.style === undefined ? {} : { style: font.style }
+  }));
+}
+async function loadOptional(name) {
+  try {
+    const specifier = name;
+    return await import(specifier);
+  } catch {
+    return;
+  }
+}
+async function loadFromAppRoot(name) {
+  try {
+    const resolveFrom = createRequire(path.join(process.cwd(), "pnext-og-resolve.cjs"));
+    const resolved = resolveFrom.resolve(name);
+    return await import(resolved);
+  } catch {
+    return;
+  }
+}
+function createFallbackPng(options) {
+  const width = dimension(options.width, DEFAULT_WIDTH, "width");
+  const height = dimension(options.height, DEFAULT_HEIGHT, "height");
+  const rowBytes = Math.ceil(width / 8) + 1;
+  const rawBytes = rowBytes * height;
+  if (rawBytes > MAX_RAW_IMAGE_BYTES) {
+    throw new RangeError(`ImageResponse dimensions ${width}x${height} exceed the lightweight PNG limit.`);
+  }
+  const ihdr = new Uint8Array(13);
+  const ihdrView = new DataView(ihdr.buffer);
+  ihdrView.setUint32(0, width);
+  ihdrView.setUint32(4, height);
+  ihdr[8] = 1;
+  return concat(PNG_SIGNATURE, chunk("IHDR", ihdr), chunk("IDAT", zlibStoreZeros(rawBytes)), chunk("IEND", new Uint8Array));
+}
+function dimension(value, fallback, name) {
+  if (value === undefined)
+    return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`ImageResponse ${name} must be a positive finite number.`);
+  }
+  const rounded = Math.floor(value);
+  if (rounded > MAX_DIMENSION) {
+    throw new RangeError(`ImageResponse ${name} must be ${MAX_DIMENSION} pixels or less.`);
+  }
+  return rounded;
+}
+function zlibStoreZeros(length) {
+  const blockCount = Math.max(1, Math.ceil(length / 65535));
+  const output = new Uint8Array(2 + blockCount * 5 + length + 4);
+  output[0] = 120;
+  output[1] = 1;
+  let offset = 2;
+  let remaining = length;
+  while (remaining > 0 || offset === 2) {
+    const blockLength = Math.min(remaining, 65535);
+    remaining -= blockLength;
+    output[offset++] = remaining === 0 ? 1 : 0;
+    output[offset++] = blockLength & 255;
+    output[offset++] = blockLength >> 8 & 255;
+    const inverse = 65535 - blockLength;
+    output[offset++] = inverse & 255;
+    output[offset++] = inverse >> 8 & 255;
+    offset += blockLength;
+  }
+  const adler = length % 65521 << 16 | 1;
+  new DataView(output.buffer).setUint32(output.length - 4, adler);
+  return output;
+}
+function chunk(type, data) {
+  const output = new Uint8Array(12 + data.length);
+  const view = new DataView(output.buffer);
+  view.setUint32(0, data.length);
+  for (let index = 0;index < 4; index += 1) {
+    output[4 + index] = type.charCodeAt(index);
+  }
+  output.set(data, 8);
+  view.setUint32(output.length - 4, crc32(output.subarray(4, output.length - 4)));
+  return output;
+}
+function crc32(bytes) {
+  const table = crcTable ?? createCrcTable();
+  crcTable = table;
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc = table[(crc ^ byte) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function createCrcTable() {
+  const table = new Uint32Array(256);
+  for (let index = 0;index < table.length; index += 1) {
+    let value = index;
+    for (let bit = 0;bit < 8; bit += 1) {
+      value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+}
+function concat(...parts) {
+  const length = parts.reduce((total, part) => total + part.length, 0);
+  const output = new Uint8Array(length);
+  let offset = 0;
+  for (const part of parts) {
+    output.set(part, offset);
+    offset += part.length;
+  }
+  return output;
+}
+
+export { ImageResponse };

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 };