@wular/coder 0.4.2 → 0.4.5

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-akkrvjn6.js

@@ -0,0 +1,535 @@
+// @bun
+import {
+  cacheHandlerRevalidateTag
+} from "./index-bcws5eh2.js";
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+import {
+  currentRequest,
+  getWorkUnit
+} from "./index-grta8ap3.js";
+import {
+  realNow,
+  trackPrerenderCacheFill
+} from "./index-kresp2n8.js";
+import {
+  escapeRegex
+} from "./index-qjj6gddn.js";
+
+// src/compat/cache/revalidate.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/compat/cache/modern-handler.ts
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { format } from "util";
+import { fileURLToPath, pathToFileURL } from "url";
+var MODERN_CACHE_HANDLER_STATE = Symbol.for("pnext.compat.modernCacheHandler");
+function state() {
+  const global = globalThis;
+  return global[MODERN_CACHE_HANDLER_STATE] ??= {};
+}
+function installModernCacheHandlers(root) {
+  const configured = defaultCacheHandlerPath();
+  const current = state();
+  if (!configured) {
+    current.handler = undefined;
+    current.installedFor = undefined;
+    return;
+  }
+  const filePath = resolveHandlerPath(configured, root);
+  if (current.installedFor === filePath)
+    return;
+  const loaded = loadHandler(filePath, root);
+  if (!loaded)
+    return;
+  current.handler = loaded;
+  current.installedFor = filePath;
+}
+async function modernCacheUpdateTags(tags, durations) {
+  const handler = state().handler;
+  const updateTags = handler?.updateTags;
+  if (!handler || !updateTags)
+    return;
+  try {
+    await withNodeConsoleFormat(() => updateTags.call(handler, tags, durations));
+  } catch {}
+}
+async function withNodeConsoleFormat(fn) {
+  const original = console.log.bind(console);
+  console.log = (...args) => {
+    original(format(...args));
+  };
+  try {
+    return await fn();
+  } finally {
+    console.log = original;
+  }
+}
+function defaultCacheHandlerPath() {
+  const cacheHandlers = getNextConfig().cacheHandlers;
+  if (!cacheHandlers || typeof cacheHandlers !== "object" || Array.isArray(cacheHandlers))
+    return;
+  const configured = cacheHandlers.default;
+  return typeof configured === "string" && configured.length > 0 ? configured : undefined;
+}
+function resolveHandlerPath(configured, root) {
+  const resolved = configured.startsWith("file:") ? fileURLToPath(configured) : configured;
+  if (path.isAbsolute(resolved))
+    return resolved;
+  return path.resolve(root, resolved);
+}
+function loadHandler(filePath, root) {
+  if (!existsSync(filePath))
+    return;
+  try {
+    const require2 = createRequire(pathToFileURL(`${root}/index.js`).href);
+    try {
+      return pickHandler(require2(filePath));
+    } catch (error) {
+      if (!isNextDistMissing(error))
+        return;
+      return loadCommonJsHandlerWithNextStubs(filePath, require2);
+    }
+  } catch {
+    return;
+  }
+}
+function loadCommonJsHandlerWithNextStubs(filePath, rootRequire) {
+  try {
+    const module = { exports: {} };
+    const localRequire = (specifier) => {
+      if (specifier === "next/dist/server/lib/cache-handlers/default.external") {
+        return { default: createDefaultExternalHandler() };
+      }
+      if (specifier.startsWith("next/dist/"))
+        return {};
+      if (specifier.startsWith("./") || specifier.startsWith("../")) {
+        return rootRequire(path.resolve(path.dirname(filePath), specifier));
+      }
+      return rootRequire(specifier);
+    };
+    const source = readFileSync(filePath, "utf8");
+    const evaluate = new Function("require", "module", "exports", "__filename", "__dirname", source);
+    evaluate(localRequire, module, module.exports, filePath, path.dirname(filePath));
+    return pickHandler(module.exports);
+  } catch {
+    return;
+  }
+}
+function isNextDistMissing(error) {
+  const message = error.message;
+  return typeof message === "string" && message.includes("next/dist/");
+}
+function pickHandler(mod) {
+  const candidate = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+  return candidate && typeof candidate === "object" ? candidate : undefined;
+}
+function createDefaultExternalHandler() {
+  const entries = new Map;
+  const tagExpirations = new Map;
+  return {
+    get(cacheKey) {
+      return entries.get(cacheKey);
+    },
+    async set(cacheKey, pendingEntry) {
+      entries.set(cacheKey, await pendingEntry);
+    },
+    refreshTags() {
+      return;
+    },
+    getExpiration(tags) {
+      let value = 0;
+      for (const tag of tags)
+        value = Math.max(value, tagExpirations.get(tag) ?? 0);
+      return value;
+    },
+    updateTags(tags) {
+      const now = realNow();
+      for (const tag of tags)
+        tagExpirations.set(tag, now);
+    }
+  };
+}
+
+// src/compat/cache/build-prerender-errors.ts
+var PRERENDER_ERROR_GLOBALS = Symbol.for("pnext.compat.prerenderErrorGlobals");
+function state2() {
+  const root = globalThis;
+  return root[PRERENDER_ERROR_GLOBALS] ??= { collected: [], armed: false };
+}
+function beginPrerenderErrorCollection() {
+  const s = state2();
+  s.collected.length = 0;
+  s.armed = true;
+}
+function endPrerenderErrorCollection() {
+  const s = state2();
+  s.armed = false;
+  const out = s.collected.slice();
+  s.collected.length = 0;
+  return out;
+}
+function prerenderErrorCollectionActive() {
+  return state2().armed;
+}
+function recordPrerenderError(error) {
+  const s = state2();
+  if (!s.armed)
+    return;
+  const collected = s.collected;
+  if (collected.some((e) => e.kind === error.kind && e.route === error.route))
+    return;
+  collected.push(error);
+  console.error(error.consoleBlock);
+  if (error.route) {
+    console.error(`Error occurred prerendering page "${error.route}".`);
+  }
+}
+var USE_CACHE_HANGING_MESSAGE = "Filling a cache during prerender timed out, likely because request-specific " + "arguments such as params, searchParams, cookies() or dynamic data were used " + 'inside "use cache".';
+var USE_CACHE_CLOSE_OVER_FUNCTION_MESSAGE = "Functions cannot be passed directly to Client Components unless you " + 'explicitly expose it by marking it with "use server". Or maybe you meant to ' + "call this function rather than return it.";
+var USE_CACHE_CLOSE_OVER_FUNCTION_BLOCK = `
+Error: ${USE_CACHE_CLOSE_OVER_FUNCTION_MESSAGE}` + `
+  [function]` + `
+   ^^^^^^^^`;
+function unstableCacheDynamicApiMessage(route, api) {
+  return `Route ${route} used \`${api}\` inside a function cached with ` + "`unstable_cache()`. Accessing Dynamic data sources inside a cache scope is " + `not supported. If you need this data inside a cached function use \`${api}\` ` + "outside of the cached function and pass the required dynamic data in as an " + "argument. See more info here: " + "https://nextjs.org/docs/app/api-reference/functions/unstable_cache";
+}
+function useCacheDynamicApiMessage(route, api) {
+  return `Route ${route} used \`${api}\` inside "use cache". Accessing Dynamic data ` + "sources inside a cache scope is not supported. If you need this data inside " + `a cached function use \`${api}\` outside of the cached function and pass the ` + "required dynamic data in as an argument. See more info here: " + "https://nextjs.org/docs/messages/next-request-in-use-cache";
+}
+
+// src/compat/cache/revalidate.ts
+function draftModeBypassActive() {
+  return currentRequest()?.cookies?.has("__prerender_bypass") ?? false;
+}
+var REVALIDATE_GLOBALS = Symbol.for("pnext.compat.revalidateGlobals");
+var USE_CACHE_ENTRIES = Symbol.for("pnext.compat.useCacheEntries");
+function revalidateGlobal(name, create) {
+  const root = globalThis;
+  const container = root[REVALIDATE_GLOBALS] ??= {};
+  if (!(name in container))
+    container[name] = create();
+  return container[name];
+}
+var revalidatedPaths = revalidateGlobal("revalidatedPaths", () => new Map);
+var revalidatedPathReasons = revalidateGlobal("revalidatedPathReasons", () => new Map);
+var revalidatedTags = revalidateGlobal("revalidatedTags", () => new Map);
+var counters = revalidateGlobal("counters", () => ({ tagSeq: 0, lastPathAt: 0, events: 0 }));
+var revalidatedTagSeq = revalidateGlobal("revalidatedTagSeq", () => new Map);
+var revalidatedTagReasons = revalidateGlobal("revalidatedTagReasons", () => new Map);
+var staleTags = revalidateGlobal("staleTags", () => new Map);
+var dataCacheInvalidators = revalidateGlobal("dataCacheInvalidators", () => new Set);
+var revalidationInvalidators = revalidateGlobal("revalidationInvalidators", () => new Set);
+function evictUseCacheEntries(invalidation) {
+  const entries = globalThis[USE_CACHE_ENTRIES];
+  if (!entries || invalidation.kind === "tag" && invalidation.stale)
+    return;
+  for (const [key, entry] of entries) {
+    const matches = invalidation.kind === "tag" ? entry.tags.includes(invalidation.tag) : pathScopeRevalidated(entry.route, entry.storedAt);
+    if (matches)
+      entries.delete(key);
+  }
+}
+var revalidatedPatterns = revalidateGlobal("revalidatedPatterns", () => []);
+var revalidatedPatternsLimit = 256;
+function revalidationEventCount() {
+  return counters.events;
+}
+function bumpRevalidationEvent() {
+  counters.events += 1;
+}
+function normalizeRevalidatePath(path2) {
+  let pathname = path2.split("?")[0] ?? path2;
+  try {
+    pathname = decodeURI(pathname);
+  } catch {}
+  const trimmed = pathname.replace(/\/+$/, "");
+  return trimmed === "" ? "/" : trimmed;
+}
+function markPathRevalidated(path2, type) {
+  counters.events += 1;
+  counters.lastPathAt = Date.now();
+  const normalized = normalizeRevalidatePath(path2);
+  modernCacheUpdateTags([`_N_T_${normalized}`]);
+  const reason = getWorkUnit()?.phase === "action" ? "stale" : "on-demand";
+  if (normalized.includes("[") || type === "layout") {
+    const source = normalized.split("/").map((segment) => /^\[?\[\.\.\./.test(segment) ? ".+" : segment.startsWith("[") ? "[^/]+" : escapeRegex(segment)).join("/");
+    const base = normalized === "/" ? "" : source;
+    const regex = type === "layout" ? new RegExp(`^${base}(?:/.*)?$`) : new RegExp(`^${source}$`);
+    revalidatedPatterns.push({ regex, at: Date.now(), reason });
+    if (revalidatedPatterns.length > revalidatedPatternsLimit)
+      revalidatedPatterns.shift();
+    const invalidation2 = { kind: "path", path: normalized };
+    evictUseCacheEntries(invalidation2);
+    notifyRevalidationInvalidators(invalidation2);
+    return;
+  }
+  revalidatedPaths.set(normalized, Date.now());
+  revalidatedPathReasons.set(normalized, reason);
+  const invalidation = { kind: "path", path: normalized };
+  evictUseCacheEntries(invalidation);
+  notifyRevalidationInvalidators(invalidation);
+}
+function markTagRevalidated(tag) {
+  counters.events += 1;
+  revalidatedTags.set(tag, Date.now());
+  revalidatedTagSeq.set(tag, ++counters.tagSeq);
+  revalidatedTagReasons.set(tag, getWorkUnit()?.phase === "action" ? "stale" : "on-demand");
+  cacheHandlerRevalidateTag(tag);
+  modernCacheUpdateTags([tag]);
+  const invalidation = { kind: "tag", tag, stale: false };
+  evictUseCacheEntries(invalidation);
+  notifyRevalidationInvalidators(invalidation);
+}
+function markTagStale(tag) {
+  staleTags.set(tag, Date.now());
+  cacheHandlerRevalidateTag(tag);
+  modernCacheUpdateTags([tag]);
+  notifyRevalidationInvalidators({ kind: "tag", tag, stale: true });
+}
+function markedAfter(at, time) {
+  return at !== undefined && at >= Math.trunc(time) && at > time - 1;
+}
+function pathRevalidatedSince(path2, time) {
+  const normalized = normalizeRevalidatePath(path2);
+  if (markedAfter(revalidatedPaths.get(normalized), time))
+    return true;
+  return revalidatedPatterns.some((pattern) => markedAfter(pattern.at, time) && pattern.regex.test(normalized));
+}
+function pathRevalidationReasonSince(path2, time) {
+  const normalized = normalizeRevalidatePath(path2);
+  if (markedAfter(revalidatedPaths.get(normalized), time)) {
+    return revalidatedPathReasons.get(normalized) ?? "on-demand";
+  }
+  return revalidatedPatterns.find((pattern) => markedAfter(pattern.at, time) && pattern.regex.test(normalized))?.reason;
+}
+function pathScopeRevalidated(route, time) {
+  if (route === undefined)
+    return markedAfter(counters.lastPathAt || undefined, time);
+  return pathRevalidatedSince(route, time);
+}
+function tagsRevalidatedSince(tags, time) {
+  return tags.some((tag) => markedAfter(revalidatedTags.get(tag), time));
+}
+function currentTagRevalidationSeq() {
+  return counters.tagSeq;
+}
+function rdcProcessId() {
+  return revalidateGlobal("rdcProcessId", () => `${process.pid}:${Date.now()}:${Math.random().toString(36).slice(2)}`);
+}
+function rebaseRdcTagSeq(record) {
+  if (record.pid !== rdcProcessId())
+    return 0;
+  return Math.min(record.tagSeq, counters.tagSeq);
+}
+function tagsRevalidatedAfterSeq(tags, seq) {
+  return tags.some((tag) => (revalidatedTagSeq.get(tag) ?? 0) > seq);
+}
+function tagsRevalidationReasonSince(tags, time) {
+  for (const tag of tags) {
+    if (markedAfter(revalidatedTags.get(tag), time)) {
+      return revalidatedTagReasons.get(tag) ?? "on-demand";
+    }
+  }
+  return;
+}
+function tagsStaleSince(tags, time) {
+  return tags.some((tag) => markedAfter(staleTags.get(tag), time));
+}
+var dataCache = revalidateGlobal("dataCache", () => new Map);
+var dataCacheLimit = 1024;
+function dataCacheEntryExpired(entry) {
+  return entry.revalidateSeconds !== undefined && realNow() - entry.storedAt >= entry.revalidateSeconds * 1000;
+}
+function cachedData(key, produce, options = {}) {
+  if (draftModeBypassActive())
+    return produce();
+  const entry = dataCache.get(key);
+  const meta = cacheMetaStorage.getStore();
+  const refresh = meta?.refreshFetches === true && entry?.refreshedIn !== meta && entry !== undefined && (tagsRevalidatedSince(entry.tags, entry.storedAt) || pathScopeRevalidated(entry.route, entry.storedAt) || tagsStaleSince(entry.tags, entry.storedAt) || dataCacheEntryExpired(entry));
+  if (entry && !refresh && !tagsRevalidatedSince(entry.tags, entry.storedAt) && !pathScopeRevalidated(entry.route, entry.storedAt)) {
+    recordCacheTags(entry.tags);
+    if (entry.revalidateSeconds !== undefined) {
+      recordCacheRevalidate(entry.revalidateSeconds);
+    }
+    const tagStale = tagsStaleSince(entry.tags, entry.storedAt);
+    if (!tagStale && !dataCacheEntryExpired(entry))
+      return entry.value;
+    if (cacheMetaStorage.getStore()?.blockingStaleFetches !== true) {
+      if (!entry.refreshing) {
+        entry.refreshing = true;
+        storeDataCacheEntry(key, produce, options, entry);
+      }
+      return entry.value;
+    }
+  }
+  return storeDataCacheEntry(key, produce, options);
+}
+function storeDataCacheEntry(key, produce, options, serveStale) {
+  const parentProducerTags = producerTagsStorage.getStore();
+  const producerTags = new Set(options.tags ?? []);
+  const value = producerTagsStorage.run(producerTags, () => runInsideUnstableCacheProducer(produce));
+  trackPrerenderCacheFill(value);
+  const producingMeta = cacheMetaStorage.getStore();
+  const stored = {
+    value,
+    storedAt: realNow(),
+    tags: options.tags ?? [],
+    revalidateSeconds: options.revalidateSeconds,
+    ...producingMeta !== undefined ? { refreshedIn: producingMeta } : {},
+    ...serveStale?.route !== undefined ? { route: serveStale.route } : producingMeta?.route !== undefined ? { route: producingMeta.route } : {}
+  };
+  const applyInheritedTags = () => {
+    stored.tags = [...producerTags];
+    if (parentProducerTags)
+      for (const tag of producerTags)
+        parentProducerTags.add(tag);
+  };
+  if (serveStale) {
+    value.then(() => {
+      applyInheritedTags();
+      dataCache.set(key, stored);
+    }, () => {
+      serveStale.refreshing = false;
+    });
+    return value;
+  }
+  if (dataCache.size >= dataCacheLimit) {
+    const oldest = dataCache.keys().next().value;
+    if (oldest !== undefined)
+      dataCache.delete(oldest);
+  }
+  dataCache.set(key, stored);
+  value.then(applyInheritedTags, () => {
+    if (dataCache.get(key)?.value === value)
+      dataCache.delete(key);
+  });
+  return value;
+}
+function registerDataCacheInvalidator(invalidate) {
+  dataCacheInvalidators.add(invalidate);
+  return () => {
+    dataCacheInvalidators.delete(invalidate);
+  };
+}
+function registerRevalidationInvalidator(invalidate) {
+  revalidationInvalidators.add(invalidate);
+  return () => {
+    revalidationInvalidators.delete(invalidate);
+  };
+}
+function notifyRevalidationInvalidators(invalidation) {
+  for (const invalidate of revalidationInvalidators)
+    invalidate(invalidation);
+}
+var cacheMetaStorage = revalidateGlobal("cacheMetaStorage", () => new AsyncLocalStorage);
+function currentRenderCacheMeta() {
+  return cacheMetaStorage.getStore();
+}
+function currentRenderIsStaticGeneration() {
+  const meta = cacheMetaStorage.getStore();
+  return meta?.prerender === true || meta?.blockingStaleFetches === true;
+}
+function recordCacheTags(tags) {
+  const producerTags = producerTagsStorage.getStore();
+  if (producerTags)
+    for (const tag of tags)
+      producerTags.add(tag);
+  const meta = cacheMetaStorage.getStore();
+  if (!meta)
+    return;
+  for (const tag of tags)
+    meta.tags.add(tag);
+}
+var useCacheRevalidateSink = revalidateGlobal("useCacheRevalidateSink", () => ({
+  current: undefined
+}));
+function setUseCacheRevalidateSink(sink) {
+  useCacheRevalidateSink.current = sink;
+}
+function recordCacheRevalidate(seconds) {
+  useCacheRevalidateSink.current?.(seconds);
+  const meta = cacheMetaStorage.getStore();
+  if (!meta)
+    return;
+  meta.revalidateSeconds = meta.revalidateSeconds === undefined ? seconds : Math.min(meta.revalidateSeconds, seconds);
+}
+function recordCacheNoStore() {
+  if (insideProducerStorage.getStore())
+    return;
+  const meta = cacheMetaStorage.getStore();
+  if (meta)
+    meta.noStore = true;
+}
+var insideProducerStorage = revalidateGlobal("insideProducerStorage", () => new AsyncLocalStorage);
+var producerKindStorage = revalidateGlobal("producerKindStorage", () => new AsyncLocalStorage);
+var producerTagsStorage = revalidateGlobal("producerTagsStorage", () => new AsyncLocalStorage);
+var insideUnstableCacheStorage = revalidateGlobal("insideUnstableCacheStorage", () => new AsyncLocalStorage);
+function runInsideDataCacheProducer(fn, kind = "use-cache") {
+  return producerKindStorage.run(kind, () => insideProducerStorage.run(true, fn));
+}
+function runInsideUnstableCacheProducer(fn) {
+  return insideUnstableCacheStorage.run(true, () => runInsideDataCacheProducer(fn, "unstable-cache"));
+}
+function insideDataCacheProducer() {
+  return insideProducerStorage.getStore() === true;
+}
+function insideUnstableCacheProducer() {
+  return insideUnstableCacheStorage.getStore() === true;
+}
+function assertNoDynamicApiInsideCache(api) {
+  if (!insideDataCacheProducer())
+    return;
+  const route = cacheMetaStorage.getStore()?.route ?? "";
+  const unstable = insideUnstableCacheProducer();
+  const message = unstable ? unstableCacheDynamicApiMessage(route, api) : useCacheDynamicApiMessage(route, api);
+  if (prerenderErrorCollectionActive()) {
+    recordPrerenderError({
+      kind: unstable ? "unstable-cache-dynamic" : "use-cache-dynamic",
+      route,
+      consoleBlock: `Error: ${message}`
+    });
+  }
+  throw new Error(message);
+}
+async function collectRenderCacheMeta(produce, options = {}) {
+  const meta = {
+    tags: new Set,
+    fetchCache: options.fetchCache,
+    refreshFetches: options.refreshFetches,
+    blockingStaleFetches: options.blockingStaleFetches,
+    route: options.route,
+    prerender: options.prerender,
+    handler: options.handler,
+    dynamicError: options.dynamicError
+  };
+  const value = await cacheMetaStorage.run(meta, produce);
+  await drainStaticAfterTasks(meta);
+  return {
+    value,
+    tags: [...meta.tags],
+    ...meta.revalidateSeconds !== undefined ? { revalidateSeconds: meta.revalidateSeconds } : {},
+    ...meta.expireSeconds !== undefined ? { expireSeconds: meta.expireSeconds } : {},
+    ...meta.staleSeconds !== undefined ? { staleSeconds: meta.staleSeconds } : {},
+    ...meta.noStore ? { noStore: true } : {}
+  };
+}
+async function drainStaticAfterTasks(meta) {
+  while (meta.afterTasks?.length) {
+    const tasks = meta.afterTasks;
+    meta.afterTasks = [];
+    for (const task of tasks) {
+      try {
+        await cacheMetaStorage.run(meta, task);
+      } catch (error) {
+        console.error(`Error occurred prerendering page "${meta.route ?? "/"}". Read more: https://nextjs.org/docs/messages/prerender-error`);
+        throw error;
+      }
+    }
+  }
+}
+
+export { installModernCacheHandlers, beginPrerenderErrorCollection, endPrerenderErrorCollection, draftModeBypassActive, revalidationEventCount, bumpRevalidationEvent, normalizeRevalidatePath, markPathRevalidated, markTagRevalidated, markTagStale, pathRevalidatedSince, pathRevalidationReasonSince, pathScopeRevalidated, tagsRevalidatedSince, currentTagRevalidationSeq, rdcProcessId, rebaseRdcTagSeq, tagsRevalidatedAfterSeq, tagsRevalidationReasonSince, tagsStaleSince, cachedData, registerDataCacheInvalidator, registerRevalidationInvalidator, currentRenderCacheMeta, currentRenderIsStaticGeneration, recordCacheTags, setUseCacheRevalidateSink, recordCacheRevalidate, recordCacheNoStore, insideDataCacheProducer, insideUnstableCacheProducer, assertNoDynamicApiInsideCache, collectRenderCacheMeta };

package/dist/dash/standalone/node_modules/@wular/pnext/dist/server/_chunks/index-b6wtkdp4.js

@@ -0,0 +1,24 @@
+// @bun
+import {
+  withUseThenableState
+} from "./index-h4xy648y.js";
+
+// src/compat/react/server-component-use.ts
+function isThenable(value) {
+  return value != null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function invokeServerComponentWithUse(invoke) {
+  const state = { thenables: [] };
+  const attempt = () => {
+    try {
+      return withUseThenableState(state, invoke);
+    } catch (error) {
+      if (isThenable(error))
+        return Promise.resolve(error).then(attempt, attempt);
+      throw error;
+    }
+  };
+  return attempt();
+}
+
+export { invokeServerComponentWithUse };