@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,445 @@
+// @bun
+import {
+  PostponeError,
+  isPostpone
+} from "./index-e3a6yx84.js";
+
+// src/render/ppr.ts
+import { AsyncLocalStorage } from "async_hooks";
+var PRERENDER_STORAGE = Symbol.for("pnext.prerenderStorage");
+var prerenderStorage = globalThis[PRERENDER_STORAGE] ??= new AsyncLocalStorage;
+var CSR_BAILOUT_STORAGE = Symbol.for("pnext.csrBailoutStorage");
+var csrBailoutStorage = globalThis[CSR_BAILOUT_STORAGE] ??= new AsyncLocalStorage;
+var prerenderDynamicTrackerStorage = new AsyncLocalStorage;
+async function trackPrerenderDynamic(callback) {
+  const tracker = { dynamic: false };
+  const value = await prerenderDynamicTrackerStorage.run(tracker, callback);
+  return { value, dynamic: tracker.dynamic };
+}
+function markPrerenderDynamic() {
+  const tracker = prerenderDynamicTrackerStorage.getStore();
+  if (tracker)
+    tracker.dynamic = true;
+}
+var SHELL_SOURCES = Symbol.for("pnext.shellDynamicSources");
+function shellSourceState() {
+  const root = globalThis;
+  return root[SHELL_SOURCES] ??= {
+    active: false,
+    cacheIO: false,
+    nonParamsRequest: false
+  };
+}
+function beginShellSourceTracking() {
+  const state = shellSourceState();
+  state.active = true;
+  state.cacheIO = false;
+  state.nonParamsRequest = false;
+}
+function endShellSourceTracking() {
+  const state = shellSourceState();
+  const result = { cacheIO: state.cacheIO, nonParamsRequest: state.nonParamsRequest };
+  state.active = false;
+  return result;
+}
+function recordShellRequestApi(api) {
+  const state = shellSourceState();
+  if (state.active && api !== "params")
+    state.nonParamsRequest = true;
+}
+function recordShellCacheIO() {
+  const state = shellSourceState();
+  if (state.active)
+    state.cacheIO = true;
+}
+function runInPrerender(callback, options = {}) {
+  const controller = new AbortController;
+  activePrerenderControllers().add(controller);
+  const scope = {
+    signal: controller.signal,
+    abort: () => controller.abort(),
+    ...options.runtimePrefetch ? { runtimePrefetch: true, awaitedRuntimeApi: false } : {},
+    ...options.prefetchShell ? { prefetchShell: true } : {},
+    ...options.taskBoundary ? { taskBoundary: true } : {}
+  };
+  return prerenderStorage.run(scope, callback);
+}
+var ACTIVE_PRERENDER_CONTROLLERS = Symbol.for("pnext.activePrerenderControllers");
+function activePrerenderControllers() {
+  const root = globalThis;
+  return root[ACTIVE_PRERENDER_CONTROLLERS] ??= new Set;
+}
+function abortActivePrerenderScopes() {
+  const controllers = activePrerenderControllers();
+  for (const controller of controllers)
+    controller.abort();
+  controllers.clear();
+}
+function isPrerendering() {
+  return prerenderStorage.getStore() !== undefined;
+}
+function runWithCsrBailout(callback) {
+  return csrBailoutStorage.run(true, callback);
+}
+function isCsrBailoutPrerender() {
+  return csrBailoutStorage.getStore() === true;
+}
+function isRuntimePrefetchPrerender() {
+  return prerenderStorage.getStore()?.runtimePrefetch === true;
+}
+function currentPrerenderScope() {
+  return prerenderStorage.getStore();
+}
+function completePrerender(scope) {
+  if (!scope)
+    return;
+  scope.abort();
+}
+var taskPostponeSymbol = Symbol.for("pnext.taskPostpone");
+function isTaskPostpone(error) {
+  return isPostpone(error) && taskPostponeSymbol in error;
+}
+function taskPostponeError() {
+  const error = new PostponeError("task");
+  Object.defineProperty(error, taskPostponeSymbol, { value: true });
+  return error;
+}
+function isTaskBoundaryPrerender() {
+  return prerenderStorage.getStore()?.taskBoundary === true;
+}
+var taskBoundaryArmedStorage = new AsyncLocalStorage;
+var taskBoundarySuspendedStorage = new AsyncLocalStorage;
+function runWithTaskBoundaryArmed(callback) {
+  return taskBoundaryArmedStorage.run(true, callback);
+}
+function runWithTaskBoundarySuspended(callback) {
+  return taskBoundarySuspendedStorage.run(true, callback);
+}
+var useCacheWrapperSymbol = Symbol.for("pnext.compat.useCacheWrapper");
+var useCacheMemoWrappedSymbol = Symbol.for("pnext.compat.useCacheMemoWrapped");
+function isCachedComponent(component) {
+  if (typeof component !== "function")
+    return false;
+  const tagged = component;
+  return tagged[useCacheWrapperSymbol] === true || tagged[useCacheMemoWrappedSymbol] === true;
+}
+function awaitAtTaskBoundary(value) {
+  if (!isTaskBoundaryPrerender())
+    return value;
+  if (taskBoundaryArmedStorage.getStore() !== true)
+    return value;
+  if (taskBoundarySuspendedStorage.getStore() === true)
+    return value;
+  if (typeof value?.then !== "function")
+    return value;
+  const deadline = taskDeadline();
+  return Promise.race([value, deadline.promise]).finally(deadline.cancel);
+}
+var MAX_CACHE_FILL_DEFERRALS = 50;
+var CACHE_FILL_STATE = Symbol.for("pnext.prerenderCacheFills");
+function cacheFillState() {
+  const root = globalThis;
+  return root[CACHE_FILL_STATE] ??= { pending: 0, waiters: [] };
+}
+function trackPrerenderCacheFill(fill) {
+  recordShellCacheIO();
+  const state = cacheFillState();
+  state.pending += 1;
+  const settled = () => {
+    state.pending -= 1;
+    if (state.pending > 0)
+      return;
+    const waiters = state.waiters;
+    state.waiters = [];
+    for (const waiter of waiters)
+      waiter();
+  };
+  fill.then(settled, settled);
+  return fill;
+}
+var MICROTASK_DRAIN_TURNS = 1000;
+function taskDeadline() {
+  let cancelled = false;
+  const promise = new Promise((_resolve, reject) => {
+    let deferrals = 0;
+    const drain = (remaining) => {
+      if (cancelled)
+        return;
+      if (remaining === 0) {
+        const state = cacheFillState();
+        if (state.pending > 0 && deferrals < MAX_CACHE_FILL_DEFERRALS) {
+          deferrals += 1;
+          state.waiters.push(() => drain(MICROTASK_DRAIN_TURNS));
+          return;
+        }
+        reject(taskPostponeError());
+        return;
+      }
+      const next = () => void Promise.resolve().then(() => drain(remaining - 1));
+      if (typeof process?.nextTick === "function")
+        process.nextTick(next);
+      else
+        next();
+    };
+    drain(MICROTASK_DRAIN_TURNS);
+  });
+  promise.catch(() => {
+    return;
+  });
+  return {
+    promise,
+    cancel: () => {
+      cancelled = true;
+    }
+  };
+}
+function prerenderCompleteError(api) {
+  const message = `During prerendering, \`${api}\` rejects when the prerender is complete.`;
+  const error = new Error(message);
+  Object.defineProperty(error, Symbol.for("nodejs.util.inspect.custom"), {
+    value: () => {
+      const stackTail = (error.stack ?? "").split(`
+`).slice(1).join(`
+`);
+      return stackTail ? `Error: ${message}
+${stackTail}` : `Error: ${message}`;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  return error;
+}
+var HANGING_PROMISE = Symbol.for("pnext.hangingPromise");
+function isHangingPromise(value) {
+  return typeof value === "object" && value !== null && value[HANGING_PROMISE] === true;
+}
+function hangingPromise(api) {
+  const scope = prerenderStorage.getStore();
+  if (!scope) {
+    const stray = Promise.reject(new PostponeError(api));
+    stray.catch(() => {
+      return;
+    });
+    return stray;
+  }
+  let settle;
+  const promise = new Promise((_resolve, reject) => {
+    settle = (error) => reject(error);
+  });
+  const rejectAwaited = () => settle?.(new PostponeError(api));
+  if (scope.signal.aborted) {
+    settle?.(prerenderCompleteError(api));
+  } else {
+    scope.signal.addEventListener("abort", () => settle?.(prerenderCompleteError(api)), {
+      once: true
+    });
+  }
+  promise.catch(() => {
+    return;
+  });
+  return new Proxy(promise, {
+    get(target, property) {
+      if (property === HANGING_PROMISE)
+        return true;
+      if (property === "then") {
+        return (...args) => {
+          if (typeof args[0] === "function")
+            rejectAwaited();
+          markPrerenderDynamic();
+          recordShellRequestApi(api);
+          return target.then(...args);
+        };
+      }
+      if (property === "catch") {
+        return (...args) => {
+          markPrerenderDynamic();
+          recordShellRequestApi(api);
+          return target.catch(...args);
+        };
+      }
+      if (property === "finally") {
+        return (...args) => {
+          markPrerenderDynamic();
+          recordShellRequestApi(api);
+          return target.finally(...args);
+        };
+      }
+      const value = Reflect.get(target, property, target);
+      return value;
+    }
+  });
+}
+var CACHE_COMPONENTS = Symbol.for("pnext.cacheComponents");
+function setCacheComponents(enabled) {
+  globalThis[CACHE_COMPONENTS] = enabled;
+}
+function cacheComponents() {
+  return globalThis[CACHE_COMPONENTS] === true;
+}
+var REAL_NOW = Symbol.for("pnext.realNow");
+function realNow() {
+  const stored = globalThis[REAL_NOW];
+  return typeof stored === "function" ? stored() : Date.now();
+}
+var USE_CACHE_SCOPE_STORAGE = Symbol.for("pnext.compat.useCacheScopeStorage");
+function insideUseCacheScope() {
+  const storage = globalThis[USE_CACHE_SCOPE_STORAGE];
+  return storage?.getStore() !== undefined;
+}
+async function runWithPrerenderDeterminism(fn) {
+  if (!cacheComponents())
+    return fn();
+  const deterministicTime = 1;
+  const realRandom = Math.random;
+  const RealDate = Date;
+  globalThis[REAL_NOW] = RealDate.now.bind(RealDate);
+  let counter = 0;
+  Math.random = () => {
+    counter = counter * 1103515245 + 12345 & 2147483647;
+    return counter % 1e6 / 1e6;
+  };
+  const PatchedDate = function(...args) {
+    if (!new.target)
+      return new RealDate(deterministicTime).toString();
+    if (args.length === 0)
+      return new RealDate(deterministicTime);
+    return Reflect.construct(RealDate, args);
+  };
+  Object.setPrototypeOf(PatchedDate, RealDate);
+  Object.defineProperty(PatchedDate, "prototype", { value: RealDate.prototype });
+  PatchedDate.now = () => deterministicTime;
+  Date = PatchedDate;
+  try {
+    return await fn();
+  } finally {
+    Math.random = realRandom;
+    Date = RealDate;
+  }
+}
+function markRuntimeApiOnAwait(promise) {
+  const scope = prerenderStorage.getStore();
+  if (scope?.runtimePrefetch !== true)
+    return promise;
+  return new Proxy(promise, {
+    get(target, property) {
+      if (property === "then") {
+        return (...args) => {
+          if (typeof args[0] === "function")
+            scope.awaitedRuntimeApi = true;
+          return target.then(...args);
+        };
+      }
+      return Reflect.get(target, property, target);
+    }
+  });
+}
+function abortOnSynchronousPlatformIOAccess() {
+  const scope = prerenderStorage.getStore();
+  if (scope?.runtimePrefetch !== true || scope.awaitedRuntimeApi !== true)
+    return;
+  if (insideUseCacheScope())
+    return;
+  throw new PostponeError("sync IO");
+}
+function patchMethod(owner, key, value) {
+  const hadOwn = Object.prototype.hasOwnProperty.call(owner, key);
+  const descriptor = Object.getOwnPropertyDescriptor(owner, key);
+  try {
+    Object.defineProperty(owner, key, {
+      value,
+      configurable: true,
+      writable: true,
+      enumerable: descriptor?.enumerable ?? false
+    });
+  } catch {
+    return () => {
+      return;
+    };
+  }
+  return () => {
+    try {
+      if (hadOwn && descriptor)
+        Object.defineProperty(owner, key, descriptor);
+      else
+        delete owner[key];
+    } catch {}
+  };
+}
+var SYNC_IO_SHIMS = Symbol.for("pnext.runtimePrefetchSyncIoShims");
+function syncIoShimState() {
+  const root = globalThis;
+  return root[SYNC_IO_SHIMS] ??= { depth: 0, restore: [] };
+}
+function installSyncIoShims() {
+  const state = syncIoShimState();
+  if (++state.depth > 1)
+    return;
+  const root = globalThis;
+  const RealDate = Date;
+  const realRandom = Math.random;
+  const previousRealNow = root[REAL_NOW];
+  root[REAL_NOW] = RealDate.now.bind(RealDate);
+  const PatchedDate = function(...args) {
+    if (!new.target) {
+      abortOnSynchronousPlatformIOAccess();
+      return new RealDate().toString();
+    }
+    if (args.length === 0) {
+      abortOnSynchronousPlatformIOAccess();
+      return new RealDate;
+    }
+    return Reflect.construct(RealDate, args);
+  };
+  Object.setPrototypeOf(PatchedDate, RealDate);
+  Object.defineProperty(PatchedDate, "prototype", { value: RealDate.prototype });
+  PatchedDate.now = () => {
+    abortOnSynchronousPlatformIOAccess();
+    return RealDate.now();
+  };
+  Date = PatchedDate;
+  Math.random = () => {
+    abortOnSynchronousPlatformIOAccess();
+    return realRandom();
+  };
+  state.restore.push(() => {
+    Date = RealDate;
+    Math.random = realRandom;
+    root[REAL_NOW] = previousRealNow;
+  });
+  const perf = globalThis.performance;
+  if (perf) {
+    const realPerfNow = perf.now.bind(perf);
+    state.restore.push(patchMethod(perf, "now", () => {
+      abortOnSynchronousPlatformIOAccess();
+      return realPerfNow();
+    }));
+  }
+  const webCrypto = globalThis.crypto;
+  if (typeof webCrypto?.getRandomValues === "function") {
+    const realGetRandomValues = webCrypto.getRandomValues.bind(webCrypto);
+    state.restore.push(patchMethod(webCrypto, "getRandomValues", (array) => {
+      abortOnSynchronousPlatformIOAccess();
+      return realGetRandomValues(array);
+    }));
+  }
+}
+function restoreSyncIoShims() {
+  const state = syncIoShimState();
+  if (--state.depth > 0)
+    return;
+  state.depth = 0;
+  const restore = state.restore;
+  state.restore = [];
+  for (const undo of restore)
+    undo();
+}
+async function runWithRuntimePrefetchSyncIoAbort(fn) {
+  installSyncIoShims();
+  try {
+    return await fn();
+  } finally {
+    restoreSyncIoShims();
+  }
+}
+
+export { trackPrerenderDynamic, beginShellSourceTracking, endShellSourceTracking, runInPrerender, abortActivePrerenderScopes, isPrerendering, runWithCsrBailout, isCsrBailoutPrerender, isRuntimePrefetchPrerender, currentPrerenderScope, completePrerender, isTaskPostpone, isTaskBoundaryPrerender, runWithTaskBoundaryArmed, runWithTaskBoundarySuspended, isCachedComponent, awaitAtTaskBoundary, trackPrerenderCacheFill, isHangingPromise, hangingPromise, setCacheComponents, cacheComponents, realNow, runWithPrerenderDeterminism, markRuntimeApiOnAwait, runWithRuntimePrefetchSyncIoAbort };

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

@@ -0,0 +1,31 @@
+// @bun
+// src/compat/client/base-path.ts
+function basePath() {
+  if (typeof window !== "undefined")
+    return window.__PNEXT_BASE_PATH__ ?? "";
+  return globalThis.__PNEXT_BASE_PATH__ ?? "";
+}
+function addBasePath(path) {
+  const base = basePath();
+  if (!base)
+    return path;
+  if (!path.startsWith("/") || path.startsWith("//"))
+    return path;
+  if (path === "/")
+    return base;
+  if (path === base || path.startsWith(`${base}/`))
+    return path;
+  return `${base}${path}`;
+}
+function stripBasePath(path) {
+  const base = basePath();
+  if (!base)
+    return path;
+  if (path === base)
+    return "/";
+  if (path.startsWith(`${base}/`))
+    return path.slice(base.length);
+  return path;
+}
+
+export { addBasePath, stripBasePath };

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

@@ -0,0 +1,11 @@
+// @bun
+// src/dev/client-actions.ts
+var bundler;
+function setClientActionBundler(next) {
+  bundler = next;
+}
+function getClientActionBundler() {
+  return bundler;
+}
+
+export { setClientActionBundler, getClientActionBundler };

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

@@ -0,0 +1,17 @@
+// @bun
+import {
+  loadNextConfig
+} from "./index-6e4fqv30.js";
+import {
+  registerConfigSource
+} from "./index-x93hv0sc.js";
+
+// src/compat/register/config.ts
+function registerConfigSource2() {
+  registerConfigSource(async (root, options) => {
+    const { overrides } = await loadNextConfig(root, options);
+    return overrides;
+  });
+}
+
+export { registerConfigSource2 as registerConfigSource };

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

@@ -0,0 +1,57 @@
+// @bun
+// src/compat/react/server-inserted-html.ts
+import { h, Fragment } from "preact";
+import renderToString from "preact-render-to-string";
+var collectorKey = Symbol.for("pnext.serverInsertedHTML");
+var SCOPE_GETTER_KEY = Symbol.for("pnext.serverInsertedHTMLScope");
+function setServerInsertedHTMLScope(getter) {
+  globalThis[SCOPE_GETTER_KEY] = getter;
+}
+function requestScope() {
+  const getter = globalThis[SCOPE_GETTER_KEY];
+  return getter?.();
+}
+function collector() {
+  const scope = requestScope();
+  if (scope) {
+    return {
+      callbacks: scope[collectorKey] ??= [],
+      scoped: true
+    };
+  }
+  const holder = globalThis;
+  holder.__PNEXT_SERVER_INSERTED_HTML__ ??= [];
+  return { callbacks: holder.__PNEXT_SERVER_INSERTED_HTML__, scoped: false };
+}
+var isServer = typeof document === "undefined";
+function useServerInsertedHTML(callback) {
+  if (!isServer)
+    return;
+  collector().callbacks.push(callback);
+}
+function renderServerInsertedHTML() {
+  const { callbacks, scoped } = collector();
+  if (!scoped)
+    globalThis.__PNEXT_SERVER_INSERTED_HTML__ = [];
+  if (callbacks.length === 0)
+    return "";
+  const parts = [];
+  for (const callback of callbacks) {
+    try {
+      const node = callback();
+      if (node == null || node === false)
+        continue;
+      parts.push(renderToString(h(Fragment, null, node)));
+    } catch {}
+  }
+  return parts.join("");
+}
+function clearServerInsertedHTML() {
+  const scope = requestScope();
+  if (scope)
+    scope[collectorKey] = [];
+  else
+    globalThis.__PNEXT_SERVER_INSERTED_HTML__ = [];
+}
+
+export { setServerInsertedHTMLScope, useServerInsertedHTML, renderServerInsertedHTML, clearServerInsertedHTML };