@wular/pnext 0.1.6 → 0.1.8

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

@@ -0,0 +1,138 @@
+// @bun
+import {
+  wrapComponentForPrimitiveThrows
+} from "./index-79ngvam8.js";
+
+// src/compat/react/parity.ts
+import { options } from "preact";
+var reactForwardRefSymbol = Symbol.for("react.forward_ref");
+var react19RefCompatInstalled = Symbol.for("pnext.react19-ref-compat-installed");
+var reactTextSeparatorSymbol = /* @__PURE__ */ Symbol.for("pnext.react-text-separator");
+var reactCompatActive = true;
+function setReactCompatActive(active) {
+  reactCompatActive = active;
+}
+var suspenseParity;
+function setSuspenseParity(pass) {
+  suspenseParity = pass;
+}
+var pnextOptions = options;
+if (!pnextOptions[react19RefCompatInstalled]) {
+  const previousVNode = options.vnode?.bind(options);
+  options.vnode = (vnode) => {
+    previousVNode?.(vnode);
+    if (!reactCompatActive)
+      return;
+    applyReact19RefProp(vnode);
+    suspenseParity?.beforeThrowSafety(vnode);
+    applyPrimitiveThrowSafety(vnode);
+    suspenseParity?.afterThrowSafety(vnode);
+    applyStrayDocumentChildren(vnode);
+    applyReactTextSeparators(vnode);
+  };
+  pnextOptions[react19RefCompatInstalled] = true;
+  if (typeof window !== "undefined" && typeof MessageChannel !== "undefined") {
+    const queue = [];
+    const channel = new MessageChannel;
+    channel.port1.onmessage = () => {
+      for (const callback of queue.splice(0))
+        callback();
+    };
+    options.requestAnimationFrame = (callback) => {
+      queue.push(callback);
+      channel.port2.postMessage(null);
+    };
+  }
+}
+function applyStrayDocumentChildren(vnode) {
+  if (typeof window !== "undefined")
+    return;
+  if (vnode.type !== "html")
+    return;
+  const props = vnode.props;
+  const children = props.children;
+  if (!Array.isArray(children))
+    return;
+  const kept = [];
+  const stray = [];
+  let body;
+  for (const child of children) {
+    const type = isElementVNode(child) ? child.type : undefined;
+    if (type === "body")
+      body = child;
+    if (type === "head" || type === "body" || !mayRenderContent(child)) {
+      kept.push(child);
+      continue;
+    }
+    stray.push(child);
+  }
+  if (!body || stray.length === 0)
+    return;
+  const bodyProps = body.props;
+  const bodyChildren = bodyProps.children;
+  bodyProps.children = [
+    ...stray,
+    ...Array.isArray(bodyChildren) ? bodyChildren : [bodyChildren]
+  ];
+  props.children = kept;
+}
+function isElementVNode(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function mayRenderContent(child) {
+  if (child == null || typeof child === "boolean")
+    return false;
+  return typeof child === "string" ? child.trim() !== "" : true;
+}
+function applyReactTextSeparators(vnode) {
+  if (typeof window !== "undefined")
+    return;
+  const props = vnode.props;
+  const children = props.children;
+  if (!Array.isArray(children) || children.length < 2)
+    return;
+  const values = children;
+  const separated = [];
+  let changed = false;
+  for (let index = 0;index < values.length; index += 1) {
+    const child = values[index];
+    separated.push(child);
+    if (!mayRenderText(child) || !mayRenderText(values[index + 1]))
+      continue;
+    separated.push({
+      type: reactTextSeparatorSymbol,
+      props: { UNSTABLE_comment: " " }
+    });
+    changed = true;
+  }
+  if (changed)
+    props.children = separated;
+}
+function mayRenderText(value) {
+  if (typeof value === "string" || typeof value === "number")
+    return true;
+  if (!value || typeof value !== "object" || !("type" in value))
+    return false;
+  return typeof value.type !== "string";
+}
+function applyPrimitiveThrowSafety(vnode) {
+  if (typeof window === "undefined")
+    return;
+  if (typeof vnode.type !== "function")
+    return;
+  vnode.type = wrapComponentForPrimitiveThrows(vnode.type);
+}
+function applyReact19RefProp(vnode) {
+  if (!vnode.ref || typeof vnode.type !== "function")
+    return;
+  const component = vnode.type;
+  if (component.prototype?.render || component.$$typeof === reactForwardRefSymbol)
+    return;
+  vnode.props = {
+    ...vnode.props,
+    ref: vnode.ref
+  };
+  vnode.ref = null;
+}
+
+export { setReactCompatActive, setSuspenseParity };

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

@@ -0,0 +1,138 @@
+// @bun
+import {
+  restoreWithExtensionHost
+} from "./index-zqpqyg8p.js";
+
+// src/render/hooks.ts
+function nextCompatEnabled(config) {
+  return Boolean(config.compat?.next);
+}
+function reactCompatEnabled(config) {
+  return Boolean(config.compat?.next || config.compat?.react || config.compat?.reactCompiler);
+}
+var fontExtensions = {
+  runWithFontScope: (callback) => callback(),
+  collectFontAssets: () => Promise.resolve({ css: "", preloads: [] }),
+  prewarmFontAssets: () => Promise.resolve(),
+  releaseFonts: () => Promise.resolve({})
+};
+function getFontExtensions() {
+  return fontExtensions;
+}
+function setFontExtensions(overrides) {
+  Object.assign(fontExtensions, overrides);
+}
+var suspenseExtensions = {
+  ensureCompatSuspense: () => Promise.resolve(),
+  compatSuspenseType: () => {
+    return;
+  }
+};
+function getSuspenseExtensions() {
+  return suspenseExtensions;
+}
+function setSuspenseExtensions(overrides) {
+  Object.assign(suspenseExtensions, overrides);
+}
+var streamRouteExtensions = {
+  canStreamRoute: () => true,
+  inlineSuspenseStream: () => false
+};
+function getStreamRouteExtensions() {
+  return streamRouteExtensions;
+}
+function setStreamRouteExtensions(overrides) {
+  Object.assign(streamRouteExtensions, overrides);
+}
+var streamBoundaryExtensions = {
+  onStreamBoundaryError: () => {
+    return;
+  }
+};
+function setStreamBoundaryExtensions(overrides) {
+  Object.assign(streamBoundaryExtensions, overrides);
+}
+function reportStreamBoundaryError(error) {
+  try {
+    const result = streamBoundaryExtensions.onStreamBoundaryError(error);
+    if (isThenable(result)) {
+      Promise.resolve(result).catch((reportError) => {
+        console.error("stream boundary error hook failed:", reportError);
+      });
+    }
+  } catch (reportError) {
+    console.error("stream boundary error hook failed:", reportError);
+  }
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+var metadataExtensions = {};
+function getActiveMetadataExtensions(config) {
+  return metadataExtensions.enabled?.(config) ? metadataExtensions : {};
+}
+function setMetadataExtensions(overrides) {
+  Object.assign(metadataExtensions, overrides);
+}
+var documentScriptExtensions = {
+  stylesheetPrecedence: () => {
+    return;
+  },
+  documentBodyScripts: () => ""
+};
+function getDocumentScriptExtensions() {
+  return documentScriptExtensions;
+}
+function setDocumentScriptExtensions(overrides) {
+  Object.assign(documentScriptExtensions, overrides);
+}
+var staticParamsExtensions = {
+  normalizeModule: (module) => typeof module.params === "function" || typeof module.generateStaticParams !== "function" ? module : { ...module, params: module.generateStaticParams }
+};
+function getStaticParamsExtensions() {
+  return staticParamsExtensions;
+}
+function setStaticParamsExtensions(overrides) {
+  Object.assign(staticParamsExtensions, overrides);
+}
+var actionModuleExtensions = {
+  tagActionModulesForRender: () => Promise.resolve(),
+  tagActionModuleExports: () => {
+    return;
+  }
+};
+function getActionModuleExtensions() {
+  return actionModuleExtensions;
+}
+function setActionModuleExtensions(overrides) {
+  Object.assign(actionModuleExtensions, overrides);
+}
+var renderSpanExtensions = {
+  withRenderBodySpan: (_route, fn) => fn(),
+  withFindPageComponentsSpan: (_route, fn) => fn(),
+  emitResolveSegmentSpan: () => {
+    return;
+  },
+  withRouteHandlerSpan: (_route, fn) => fn()
+};
+function getRenderSpanExtensions() {
+  return renderSpanExtensions;
+}
+function setRenderSpanExtensions(overrides) {
+  Object.assign(renderSpanExtensions, overrides);
+}
+for (const registry of [
+  fontExtensions,
+  suspenseExtensions,
+  streamRouteExtensions,
+  streamBoundaryExtensions,
+  metadataExtensions,
+  documentScriptExtensions,
+  staticParamsExtensions,
+  actionModuleExtensions,
+  renderSpanExtensions
+]) {
+  restoreWithExtensionHost(registry);
+}
+
+export { nextCompatEnabled, reactCompatEnabled, getFontExtensions, setFontExtensions, getSuspenseExtensions, setSuspenseExtensions, getStreamRouteExtensions, setStreamRouteExtensions, setStreamBoundaryExtensions, reportStreamBoundaryError, getActiveMetadataExtensions, setMetadataExtensions, getDocumentScriptExtensions, setDocumentScriptExtensions, getStaticParamsExtensions, setStaticParamsExtensions, getActionModuleExtensions, setActionModuleExtensions, getRenderSpanExtensions, setRenderSpanExtensions };

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

@@ -0,0 +1,311 @@
+// @bun
+import {
+  getNextConfig
+} from "./index-m63czgq5.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 };