@wular/pnext 0.1.5 → 0.1.7

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

package/dist/server/_chunks/index-7wc9n8be.js

@@ -0,0 +1,25 @@
+// @bun
+// src/utils/native-require.ts
+import realProcess from "process";
+function loadNative(load) {
+  const globalObject = globalThis;
+  if (globalObject.process === realProcess)
+    return load();
+  const previous = Object.getOwnPropertyDescriptor(globalObject, "process");
+  Object.defineProperty(globalObject, "process", {
+    configurable: true,
+    enumerable: false,
+    writable: true,
+    value: realProcess
+  });
+  try {
+    return load();
+  } finally {
+    if (previous)
+      Object.defineProperty(globalObject, "process", previous);
+    else
+      delete globalObject.process;
+  }
+}
+
+export { loadNative };