@wular/pnext 0.1.6 → 0.1.8

package/dist/server/_chunks/index-68m3mwbd.js

@@ -0,0 +1,84 @@
+// @bun
+import {
+  hooksUsable
+} from "./index-j2zrcp1k.js";
+
+// src/compat/react/action-state.ts
+import { useCallback, useRef, useState } from "preact/hooks";
+function useActionState(action, initialState, _permalink) {
+  if (!hooksUsable()) {
+    const staticInitial = (consumeActionStateOverride() ?? { value: initialState }).value;
+    const staticDispatch = (payload) => void Promise.resolve(action(staticInitial, payload));
+    tagFormStateDispatch(staticDispatch, action, staticInitial, _permalink);
+    return [staticInitial, staticDispatch, false];
+  }
+  const initialRef = useRef(null);
+  if (!initialRef.current) {
+    initialRef.current = {
+      value: (consumeActionStateOverride() ?? { value: initialState }).value
+    };
+  }
+  const [state, setState] = useState(initialRef.current.value);
+  const [pending, setPending] = useState(0);
+  const lastSettled = useRef(initialRef.current.value);
+  const chain = useRef(Promise.resolve());
+  const pendingError = useRef(null);
+  const [, forceRender] = useState(0);
+  const dispatch = useCallback((payload) => {
+    setPending((count) => count + 1);
+    chain.current = chain.current.then(async () => {
+      try {
+        const redirectsBefore = actionRedirectCount();
+        const next = await action(lastSettled.current, payload);
+        if (next === undefined && actionRedirectCount() !== redirectsBefore) {
+          lastSettled.current = initialRef.current.value;
+          setState(() => initialRef.current.value);
+          return;
+        }
+        lastSettled.current = next;
+        setState(() => next);
+      } finally {
+        setPending((count) => count - 1);
+      }
+    });
+    chain.current = chain.current.catch((error) => {
+      if (typeof window === "undefined")
+        return;
+      pendingError.current = { error };
+      forceRender((count) => count + 1);
+    });
+  }, [action]);
+  if (pendingError.current) {
+    const { error } = pendingError.current;
+    pendingError.current = null;
+    throw error;
+  }
+  tagFormStateDispatch(dispatch, action, state, _permalink);
+  return [state, dispatch, pending > 0];
+}
+function tagFormStateDispatch(dispatch, action, state, permalink) {
+  dispatch.$$pnextFormState = {
+    action,
+    state,
+    ...permalink !== undefined ? { permalink } : {}
+  };
+}
+function actionRedirectCount() {
+  return globalThis.__pnextActionRedirects ?? 0;
+}
+function consumeActionStateOverride() {
+  const holder = globalThis;
+  if (!("__PNEXT_ACTION_STATE__" in holder))
+    return;
+  const override = holder.__PNEXT_ACTION_STATE__;
+  if (override !== null && typeof override === "object" && "skip" in override && typeof override.skip === "number" && override.skip > 0) {
+    override.skip--;
+    return;
+  }
+  delete holder.__PNEXT_ACTION_STATE__;
+  return {
+    value: override !== null && typeof override === "object" && "value" in override ? override.value : override
+  };
+}
+
+export { useActionState, consumeActionStateOverride };

package/dist/server/_chunks/index-6b009mt0.js

@@ -0,0 +1,56 @@
+// @bun
+// src/compat/next/telemetry.ts
+var EVENT_CLI_SESSION_STARTED = "NEXT_CLI_SESSION_STARTED";
+var EVENT_BUILD_FEATURE_USAGE = "NEXT_BUILD_FEATURE_USAGE";
+var emitted = false;
+var featureUsageEmitted = false;
+function configuredStaleTimes(config) {
+  const experimental = config.experimental;
+  if (!experimental || typeof experimental !== "object")
+    return {};
+  const staleTimes = experimental.staleTimes;
+  if (!staleTimes || typeof staleTimes !== "object")
+    return {};
+  const value = staleTimes;
+  return {
+    ...typeof value.static === "number" ? { static: value.static } : {},
+    ...typeof value.dynamic === "number" ? { dynamic: value.dynamic } : {}
+  };
+}
+function emitSessionStartedTelemetry(config) {
+  if (emitted)
+    return;
+  if (!process.env.NEXT_TELEMETRY_DEBUG)
+    return;
+  emitted = true;
+  const staleTimes = configuredStaleTimes(config);
+  const event = {
+    eventName: EVENT_CLI_SESSION_STARTED,
+    payload: {
+      nodeVersion: process.version,
+      cliCommand: process.argv[2] ?? "unknown",
+      staticStaleTime: staleTimes.static ?? null,
+      dynamicStaleTime: staleTimes.dynamic ?? null
+    }
+  };
+  console.log(`[telemetry] ${JSON.stringify(event, null, 2)}`);
+}
+function emitBuildFeatureUsageTelemetry(config) {
+  if (featureUsageEmitted)
+    return;
+  if (!process.env.NEXT_TELEMETRY_DEBUG)
+    return;
+  if ((process.argv[2] ?? "") !== "build")
+    return;
+  featureUsageEmitted = true;
+  const experimental = config.experimental;
+  const esmExternals = experimental && typeof experimental === "object" ? experimental.esmExternals : undefined;
+  if (esmExternals !== undefined && esmExternals !== true) {
+    console.log(`[telemetry] ${JSON.stringify({
+      eventName: EVENT_BUILD_FEATURE_USAGE,
+      payload: { featureName: "esmExternals", invocationCount: 1 }
+    }, null, 2)}`);
+  }
+}
+
+export { emitSessionStartedTelemetry, emitBuildFeatureUsageTelemetry };

package/dist/server/_chunks/index-6gex3pfa.js

@@ -0,0 +1,15 @@
+// @bun
+// src/compat/actions/unrecognized-error.ts
+class UnrecognizedActionError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.name = "UnrecognizedActionError";
+  }
+}
+function isUnrecognizedActionError(error) {
+  if (error instanceof UnrecognizedActionError)
+    return true;
+  return error instanceof Error && (error.name === "UnrecognizedActionError" || / was not found on the server\.?$/.test(error.message));
+}
+
+export { isUnrecognizedActionError };

package/dist/server/_chunks/index-6kp9r0d9.js

@@ -0,0 +1,11 @@
+// @bun
+// src/utils/ansi.ts
+function color(open, close) {
+  return (value) => process.stdout.isTTY && !process.env.NO_COLOR ? `${open}${value}${close}` : value;
+}
+var dim = color("\x1B[38;5;244m", "\x1B[39m");
+var bold = color("\x1B[1m", "\x1B[22m");
+var cyan = color("\x1B[36m", "\x1B[39m");
+var green = color("\x1B[32m", "\x1B[39m");
+
+export { dim, bold, cyan, green };

package/dist/server/_chunks/index-6q7zvrap.js

@@ -0,0 +1,134 @@
+// @bun
+// src/compat/actions/ids.ts
+import { createHash } from "crypto";
+import path from "path";
+function actionId(filePath, exportName, root) {
+  const key = workspaceRelative(filePath, root);
+  return createHash("sha256").update(key).update("\x00").update(exportName).digest("hex").slice(0, 12);
+}
+function workspaceRelative(filePath, root) {
+  const rel = root ? path.relative(root, filePath) : filePath;
+  return toPosix(rel);
+}
+function toPosix(value) {
+  return value.split(path.sep).join("/");
+}
+
+// src/compat/actions/detect.ts
+var DIRECTIVE = /^(['"])use server\1\s*;?$/;
+var CACHE_DIRECTIVE = /^(['"])use cache\1\s*;?$/;
+function moduleLevelUseServer(source) {
+  const first = firstStatementText(stripLeading(source));
+  return first !== undefined && DIRECTIVE.test(first.trim());
+}
+function moduleLevelUseCache(source) {
+  const first = firstStatementText(stripLeading(source));
+  return first !== undefined && CACHE_DIRECTIVE.test(first.trim());
+}
+function inlineUseServerFunctions(source) {
+  const found = [];
+  const seen = new Set;
+  const fnDecl = /(\bexport\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{\s*(['"])use server\3\s*;?/g;
+  collect(fnDecl, source, found, seen, { nameGroup: 2, exportGroup: 1, dirGroup: 3 });
+  const arrowOrExpr = /(\bexport\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[A-Za-z_$][\w$]*|function\s*\*?\s*\([^)]*\))\s*(?:=>\s*)?\{\s*(['"])use server\3\s*;?/g;
+  collect(arrowOrExpr, source, found, seen, { nameGroup: 2, exportGroup: 1, dirGroup: 3 });
+  return found.sort((a, b) => a.start - b.start);
+}
+function collect(pattern, source, out, seen, groups) {
+  let match;
+  while (match = pattern.exec(source)) {
+    const name = match[groups.nameGroup];
+    if (!name || seen.has(name))
+      continue;
+    seen.add(name);
+    out.push({
+      name,
+      exported: Boolean(match[groups.exportGroup]),
+      start: match.index,
+      directiveEnd: match.index + match[0].length
+    });
+  }
+}
+function moduleActionExports(source) {
+  const names = new Set;
+  const declRe = /\bexport\s+(?:async\s+)?(?:function\s*\*?\s+|const\s+|let\s+|var\s+|class\s+)([A-Za-z_$][\w$]*)/g;
+  for (let m;m = declRe.exec(source); )
+    if (m[1])
+      names.add(m[1]);
+  if (/\bexport\s+default\b/.test(source))
+    names.add("default");
+  const listRe = /\bexport\s+(?!type\b)\{([^}]*)\}/g;
+  for (let m;m = listRe.exec(source); ) {
+    for (const part of (m[1] ?? "").split(",")) {
+      const trimmed = part.trim();
+      if (!trimmed || trimmed.startsWith("type "))
+        continue;
+      const exportedName = /\bas\s+([A-Za-z_$][\w$]*)\s*$/.exec(trimmed)?.[1];
+      const name = exportedName ?? trimmed;
+      if (/^[A-Za-z_$][\w$]*$/.test(name))
+        names.add(name);
+    }
+  }
+  return [...names];
+}
+function stripLeading(source) {
+  let s = source.replace(/^\uFEFF/, "");
+  if (s.startsWith("#!")) {
+    const nl = s.indexOf(`
+`);
+    s = nl === -1 ? "" : s.slice(nl + 1);
+  }
+  return s;
+}
+function firstStatementText(source) {
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const ch = source[i];
+    if (ch === " " || ch === "\t" || ch === "\r" || ch === `
+`) {
+      i++;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "/") {
+      const nl = source.indexOf(`
+`, i);
+      if (nl === -1)
+        return;
+      i = nl + 1;
+      continue;
+    }
+    if (ch === "/" && source[i + 1] === "*") {
+      const end2 = source.indexOf("*/", i + 2);
+      if (end2 === -1)
+        return;
+      i = end2 + 2;
+      continue;
+    }
+    break;
+  }
+  if (i >= n)
+    return;
+  let j = i;
+  while (j < n && source[j] !== `
+` && source[j] !== ";")
+    j++;
+  const end = source[j] === ";" ? j + 1 : j;
+  return source.slice(i, end);
+}
+function opensWithUseServerDirective(fn) {
+  if (typeof fn !== "function")
+    return false;
+  let source;
+  try {
+    source = String(fn);
+  } catch {
+    return false;
+  }
+  const body = source.indexOf("{", source.indexOf(")") + 1);
+  if (body === -1)
+    return false;
+  return /^\s*(['"])use server\1/.test(source.slice(body + 1));
+}
+
+export { actionId, workspaceRelative, moduleLevelUseServer, moduleLevelUseCache, inlineUseServerFunctions, moduleActionExports, opensWithUseServerDirective };

package/dist/server/_chunks/index-71885zaq.js

@@ -0,0 +1,284 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  standaloneOutSegment
+} from "./index-bzd2ef7t.js";
+import {
+  attachRelease,
+  buildIndexFile,
+  linkStandaloneOrigins,
+  readBuildIndex,
+  releaseConfig,
+  releaseSourceRoot,
+  servingReleaseDir
+} from "./index-hdbwtdv2.js";
+import {
+  setLegacyRequestAPIs
+} from "./index-grta8ap3.js";
+import {
+  setCacheComponents
+} from "./index-kresp2n8.js";
+import {
+  findWorkspaceRoot
+} from "./index-pym1cezq.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/config.ts
+import { existsSync, realpathSync } from "fs";
+import { fileURLToPath, pathToFileURL } from "url";
+import path2 from "path";
+
+// src/env.ts
+import { readFile, stat } from "fs/promises";
+import path from "path";
+import { parse } from "dotenv";
+async function loadEnv(root, options = {}) {
+  const nodeEnvKey = "NODE_ENV";
+  const env = process.env;
+  if (!env[nodeEnvKey])
+    env[nodeEnvKey] = options.dev ? "development" : "production";
+  const mode = process.env[nodeEnvKey] ?? "production";
+  const loadedEnvFiles = [];
+  for (const file of envFilesForMode(mode)) {
+    const filePath = path.join(root, file);
+    if (!await isEnvFile(filePath))
+      continue;
+    const parsed = parse(await readFile(filePath, "utf8"));
+    const env2 = expandEnv(parsed);
+    for (const [key, value] of Object.entries(env2)) {
+      if (process.env[key] === undefined)
+        process.env[key] = value;
+    }
+    loadedEnvFiles.push({ path: file, env: env2 });
+  }
+  return { mode, loadedEnvFiles };
+}
+function envFilesForMode(mode) {
+  return [
+    `.env.${mode}.local`,
+    mode === "test" ? undefined : ".env.local",
+    `.env.${mode}`,
+    ".env"
+  ].filter((file) => Boolean(file));
+}
+async function isEnvFile(file) {
+  try {
+    const info = await stat(file);
+    return info.isFile();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function expandEnv(parsed) {
+  const env = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    env[key] = expandValue(value, { ...parsed, ...env });
+  }
+  return env;
+}
+function expandValue(value, parsed) {
+  let result = value;
+  for (let index = searchLastEnvReference(result), attempts = 0;index !== -1 && attempts < 100; index = searchLastEnvReference(result), attempts += 1) {
+    const match = result.slice(index).match(/^\$({?)([\w]+)(?::-([^}]*))?}?/);
+    if (!match)
+      break;
+    const token = match[0] ?? "";
+    const braced = match[1] ?? "";
+    const key = match[2] ?? "";
+    const fallback = match[3] ?? "";
+    const hasClosingBrace = braced ? token.endsWith("}") : true;
+    if (!hasClosingBrace)
+      break;
+    const replacement = process.env[key] || fallback || parsed[key] || "";
+    result = `${result.slice(0, index)}${replacement}${result.slice(index + token.length)}`;
+  }
+  return result.replace(/\\\$/g, "$");
+}
+function searchLastEnvReference(value) {
+  const matches = [...value.matchAll(/(?<!\\)\$/g)];
+  return matches.length > 0 ? matches.at(-1)?.index ?? -1 : -1;
+}
+
+// src/types.ts
+var PREFETCH_MODES = ["visible", "intent", "load", false];
+
+// src/config.ts
+var DEFAULT_OUT_DIR = ".pnext";
+var defaultConfig = {
+  outDir: DEFAULT_OUT_DIR,
+  basePath: ""
+};
+var configSource;
+function registerConfigSource(source) {
+  configSource = source;
+}
+async function resolveConfigSource(config, root, options) {
+  if (!config.compat?.next)
+    return {};
+  if (!configSource) {
+    await import("./config-0tvz03a6.js").then((module) => module.registerConfigSource());
+  }
+  if (!configSource)
+    return {};
+  return configSource(root, options);
+}
+async function loadConfig(rootInput = process.cwd(), options = {}) {
+  const root = canonicalRoot(path2.resolve(rootInput));
+  const released = options.serve ? servingReleaseDir() : undefined;
+  if (released)
+    return loadReleasedConfig(root, released, options);
+  await loadEnv(root, options);
+  const configPath = path2.join(root, "pnext.config.ts");
+  const loadedConfig = existsSync(configPath) ? await import(pathToFileHref(configPath)) : {};
+  const config = {
+    ...loadedConfig.default ?? {},
+    ...process.env.PNEXT_COMPAT === "next" ? {
+      compat: {
+        ...loadedConfig.default?.compat ?? {},
+        next: loadedConfig.default?.compat?.next || true
+      }
+    } : {}
+  };
+  validateConfig(config);
+  setLegacyRequestAPIs(typeof config.compat?.next === "object" && config.compat.next.legacyRequestAPIs === true);
+  setCacheComponents(false);
+  const sourceOverrides = stripUndefined(await resolveConfigSource(config, root, options));
+  const merged = { ...defaultConfig, ...config, ...sourceOverrides };
+  const outRootPath = path2.resolve(root, merged.outDir);
+  const release = path2.join(outRootPath, standaloneOutSegment);
+  if (options.serve && existsSync(buildIndexFile(release))) {
+    return loadReleasedConfig(root, release, { ...options, warnings: false });
+  }
+  const appPath = await resolveAppPath(root, config, options.dev ? undefined : path2.join(outRootPath, "pnext-pages-compat"));
+  const workspaceRoot = canonicalRoot(config.workspaceRoot ? path2.resolve(root, config.workspaceRoot) : findWorkspaceRoot(root) ?? root);
+  return {
+    ...config,
+    trailingSlash: merged.trailingSlash ?? config.trailingSlash,
+    productionBrowserSourceMaps: merged.productionBrowserSourceMaps ?? config.productionBrowserSourceMaps,
+    skipTrailingSlashRedirect: merged.skipTrailingSlashRedirect ?? config.skipTrailingSlashRedirect,
+    appDir: path2.relative(root, appPath),
+    publicDir: "public",
+    outDir: merged.outDir,
+    basePath: merged.basePath,
+    assetPrefix: merged.assetPrefix ?? merged.basePath,
+    root,
+    workspaceRoot,
+    appPath,
+    publicPath: path2.resolve(root, "public"),
+    outPath: path2.join(outRootPath, options.dev ? devOutSegment : standaloneOutSegment),
+    outRootPath,
+    typesPath: path2.join(outRootPath, "types"),
+    checksPath: path2.join(outRootPath, "typecheck", "checks")
+  };
+}
+async function loadReleasedConfig(root, outPath, options) {
+  const index = readBuildIndex(outPath);
+  linkStandaloneOrigins(outPath);
+  const sourceRoot = releaseSourceRoot(outPath, index.config.outPath);
+  const config = releaseConfig(index.config, sourceRoot, outPath);
+  await loadEnv(root, options);
+  setLegacyRequestAPIs(typeof config.compat?.next === "object" && config.compat.next.legacyRequestAPIs === true);
+  setCacheComponents(false);
+  await resolveConfigSource(config, root, {
+    ...options,
+    bundle: index.nextConfig ? path2.resolve(outPath, index.nextConfig) : null,
+    handlers: Object.fromEntries(Object.entries(index.compat?.cacheHandlers ?? {}).map(([name, file]) => [
+      name,
+      path2.resolve(outPath, file)
+    ]))
+  });
+  attachRelease(config, index);
+  return config;
+}
+var enumFields = [
+  ["prefetch", PREFETCH_MODES]
+];
+function validateConfig(config) {
+  for (const [field, allowed] of enumFields) {
+    const value = config[field];
+    if (value === undefined || allowed.includes(value))
+      continue;
+    const list = allowed.map((v) => typeof v === "string" ? `'${v}'` : String(v)).join(", ");
+    throw new Error(`Invalid pnext config: '${field}' must be one of ${list} (received ${JSON.stringify(value)}).`);
+  }
+}
+var devOutSegment = "dev";
+function canonicalRoot(dir) {
+  try {
+    return realpathSync(dir);
+  } catch {
+    return dir;
+  }
+}
+function stripUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}
+function pathToFileHref(filePath) {
+  return pathToFileURL(path2.resolve(filePath)).href;
+}
+function publicEnvDefines() {
+  const publicEnv = Object.fromEntries([
+    ["NODE_ENV", "production"],
+    ...Object.entries(process.env).filter(([key]) => key.startsWith("NEXT_PUBLIC_") || key.startsWith("PNEXT_PUBLIC_"))
+  ]);
+  return {
+    "process.env": JSON.stringify(publicEnv),
+    ...Object.fromEntries(Object.entries(publicEnv).map(([key, value]) => [
+      `process.env.${key}`,
+      JSON.stringify(value)
+    ]))
+  };
+}
+var frameworkRuntimeAliases;
+function frameworkRuntimeAliasEntries() {
+  frameworkRuntimeAliases ??= {
+    preact: resolveRuntimeModule("preact"),
+    "preact/hooks": resolveRuntimeModule("preact/hooks"),
+    "preact/compat": resolveRuntimeModule("preact/compat"),
+    "preact/compat/client": resolveRuntimeModule("preact/compat/client"),
+    "preact/jsx-runtime": resolveRuntimeModule("preact/jsx-runtime"),
+    "preact/jsx-dev-runtime": resolveRuntimeModule("preact/jsx-dev-runtime"),
+    "react-compiler-runtime": resolveRuntimeModule("react-compiler-runtime")
+  };
+  return frameworkRuntimeAliases;
+}
+var frameworkRuntimeSpecifiers = () => Object.keys(frameworkRuntimeAliasEntries());
+function resolveRuntimeModule(specifier) {
+  return fileURLToPath(import.meta.resolve(specifier));
+}
+function pnextAliases(target) {
+  if (target !== "client")
+    return {};
+  return {
+    "@wular/pnext/cache": path2.resolve(__PNEXT_PACKAGE_ROOT__ + "/src", "api/client-cache.ts")
+  };
+}
+async function resolveAppPath(root, config, pagesBase) {
+  const rootApp = path2.join(root, "app");
+  if (config.compat?.next) {
+    const pagesPath = path2.join(root, "pages");
+    const hasPages = existsSync(pagesPath);
+    if (existsSync(rootApp)) {
+      if (hasPages) {
+        const { materializePagesApp: materializePagesApp2 } = await import("./router-xnrva921.js");
+        const hybrid = await materializePagesApp2(root, pagesBase);
+        if (hybrid)
+          return hybrid;
+      }
+      return rootApp;
+    }
+    const { materializePagesApp } = await import("./router-xnrva921.js");
+    const pagesApp = await materializePagesApp(root, pagesBase);
+    if (pagesApp)
+      return pagesApp;
+  } else if (existsSync(rootApp))
+    return rootApp;
+  return path2.join(root, "src", "app");
+}
+
+export { DEFAULT_OUT_DIR, registerConfigSource, loadConfig, devOutSegment, pathToFileHref, publicEnvDefines, frameworkRuntimeAliasEntries, frameworkRuntimeSpecifiers, pnextAliases };

package/dist/server/_chunks/index-73z4esab.js

@@ -0,0 +1,38 @@
+// @bun
+import {
+  dim
+} from "./index-6kp9r0d9.js";
+
+// src/utils/verbose.ts
+function createVerboseLogger(enabled, scope) {
+  const prefix = dim(`pnext ${scope}`);
+  const write = (message) => console.log(`${prefix} ${dim(`@${(performance.now() / 1000).toFixed(2)}s`)} ${message}`);
+  return {
+    enabled,
+    log(message) {
+      if (enabled)
+        write(message);
+    },
+    async step(label, task) {
+      if (!enabled)
+        return task();
+      write(label);
+      const start = performance.now();
+      try {
+        return await task();
+      } finally {
+        write(`  ${dim(`\u21B3 ${label} ${formatDuration(performance.now() - start)}`)}`);
+      }
+    }
+  };
+}
+function formatDuration(durationMs) {
+  const ms = Math.max(0, durationMs);
+  if (ms < 10)
+    return `${ms.toFixed(1)}ms`;
+  if (ms < 1000)
+    return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(ms < 1e4 ? 2 : 1)}s`;
+}
+
+export { createVerboseLogger, formatDuration };

package/dist/server/_chunks/index-79ngvam8.js

@@ -0,0 +1,60 @@
+// @bun
+// src/compat/client/errors/primitive-throw.ts
+var RAW_VALUE = Symbol("pnext.primitiveThrowValue");
+function tagPrimitiveThrow(value) {
+  const error = new Error(String(value));
+  error[RAW_VALUE] = value;
+  return error;
+}
+function isTaggedPrimitiveThrow(error) {
+  return error instanceof Error && RAW_VALUE in error;
+}
+function untagPrimitiveThrow(error) {
+  return isTaggedPrimitiveThrow(error) ? error[RAW_VALUE] : error;
+}
+function crashesPreactThenCheck(value) {
+  return value === null || value === undefined;
+}
+function retagThrow(value) {
+  return crashesPreactThenCheck(value) ? tagPrimitiveThrow(value) : value;
+}
+var wrapped = new WeakMap;
+var ALREADY_WRAPPED = Symbol("pnext.primitiveThrowWrapped");
+function wrapComponentForPrimitiveThrows(type) {
+  if (type[ALREADY_WRAPPED])
+    return type;
+  const cached = wrapped.get(type);
+  if (cached)
+    return cached;
+  if (typeof type !== "function")
+    return type;
+  const Base = type;
+  const result = type.prototype?.render ? class PrimitiveThrowSafe extends Base {
+    render(...args) {
+      try {
+        return super.render(...args);
+      } catch (e) {
+        throw retagThrow(e);
+      }
+    }
+  } : function pnextPrimitiveThrowSafe(...args) {
+    try {
+      return type.apply(this, args);
+    } catch (e) {
+      throw retagThrow(e);
+    }
+  };
+  Object.defineProperty(result, "name", { value: Base.name });
+  for (const key of Reflect.ownKeys(Base)) {
+    if (key === "length" || key === "name" || key === "prototype")
+      continue;
+    const descriptor = Object.getOwnPropertyDescriptor(Base, key);
+    if (descriptor)
+      Object.defineProperty(result, key, descriptor);
+  }
+  Object.defineProperty(result, ALREADY_WRAPPED, { value: true });
+  wrapped.set(type, result);
+  return result;
+}
+
+export { tagPrimitiveThrow, isTaggedPrimitiveThrow, untagPrimitiveThrow, wrapComponentForPrimitiveThrows };