@wular/coder 0.4.3 → 0.4.5

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

@@ -0,0 +1,297 @@
+// @bun
+import { join as __pnextJoin } from "node:path";
+const __PNEXT_PACKAGE_ROOT__ = __pnextJoin(import.meta.dirname, "../../..");
+import {
+  frozenDirListing
+} from "./index-hdbwtdv2.js";
+
+// src/utils/fs.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { mkdir, readdir, rename, rm, stat, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var atomicWriteSequence = 0;
+async function writeFileAtomic(file, contents, tempDirectory) {
+  const suffix = `${process.pid.toString(36)}.${(++atomicWriteSequence).toString(36)}.tmp`;
+  let temp = tempDirectory ? path.join(tempDirectory, `.${path.basename(path.dirname(file))}-${path.basename(file)}.${suffix}`) : `${file}.${suffix}`;
+  try {
+    await writeFile(temp, contents);
+  } catch (error) {
+    if (!tempDirectory)
+      throw error;
+    temp = `${file}.${suffix}`;
+    await writeFile(temp, contents);
+  }
+  try {
+    await rename(temp, file);
+  } catch (error) {
+    if (!existsSync(file))
+      throw error;
+  }
+}
+async function listFiles(root) {
+  if (!existsSync(root))
+    return [];
+  const entries = await readdir(root, { withFileTypes: true });
+  const branches = await Promise.all(entries.map((entry) => {
+    const entryPath = path.join(root, entry.name);
+    if (entry.isDirectory())
+      return listFiles(entryPath);
+    return Promise.resolve(entry.isFile() ? [entryPath] : []);
+  }));
+  return branches.flat();
+}
+var dirListings;
+function withDirCache(run) {
+  if (dirListings)
+    return run();
+  dirListings = new Map;
+  try {
+    return run();
+  } finally {
+    dirListings = undefined;
+  }
+}
+function readDirListing(dir) {
+  const frozen = frozenDirListing(dir);
+  if (frozen)
+    return frozen;
+  const cached = dirListings?.get(dir);
+  if (cached)
+    return cached;
+  let listing;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    listing = {
+      files: new Set(entries.filter((entry) => !entry.isDirectory()).map((entry) => entry.name)),
+      dirs: entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
+    };
+  } catch {
+    listing = { files: new Set, dirs: [] };
+  }
+  dirListings?.set(dir, listing);
+  return listing;
+}
+var maxExactNameMisses = 1024;
+function exactNameIndex(dir) {
+  let entries = [];
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {}
+  const entry = entries.find((item) => !item.isSymbolicLink() && hasCase(item.name));
+  const probe = entry ? path.join(dir, entry.name) : dir;
+  const name = path.basename(probe);
+  if (!hasCase(name))
+    return;
+  return existsSync(path.join(path.dirname(probe), flipCase(name))) ? { dirs: new Map, misses: new Set } : undefined;
+}
+function flipCase(name) {
+  return name === name.toUpperCase() ? name.toLowerCase() : name.toUpperCase();
+}
+function hasCase(name) {
+  return flipCase(name) !== name;
+}
+function hasExactName(names, root, relative) {
+  let dir = root;
+  for (const name of relative.split(path.sep)) {
+    const file = `${dir}${path.sep}${name}`;
+    const listing = dirNames(names, dir);
+    if (!listing)
+      return false;
+    if (!listing.has(name)) {
+      if (names.misses.has(file))
+        return false;
+      const fresh = dirNames(names, dir, true);
+      if (!fresh?.has(name)) {
+        if (fresh) {
+          if (names.misses.size >= maxExactNameMisses)
+            names.misses.clear();
+          names.misses.add(file);
+        }
+        return false;
+      }
+    }
+    dir = file;
+  }
+  return true;
+}
+function dirNames(names, dir, refresh = false) {
+  let entries = refresh ? undefined : names.dirs.get(dir);
+  if (!entries) {
+    try {
+      entries = new Set(readdirSync(dir));
+    } catch {
+      return;
+    }
+    names.dirs.set(dir, entries);
+  }
+  return entries;
+}
+function listFilesSync(root) {
+  if (!existsSync(root))
+    return [];
+  const out = [];
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    const entryPath = path.join(root, entry.name);
+    if (entry.isDirectory())
+      out.push(...listFilesSync(entryPath));
+    else if (entry.isFile())
+      out.push(entryPath);
+  }
+  return out;
+}
+async function ensureEmptyDir(dir, keep = []) {
+  if (keep.length === 0) {
+    await rm(dir, { recursive: true, force: true });
+    await mkdir(dir, { recursive: true });
+    return;
+  }
+  await mkdir(dir, { recursive: true });
+  const preserved = new Set(keep);
+  const entries = await readdir(dir).catch(() => []);
+  await Promise.all(entries.filter((entry) => !preserved.has(entry)).map((entry) => rm(path.join(dir, entry), { recursive: true, force: true })));
+}
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function writeText(file, value) {
+  await ensureDir(path.dirname(file));
+  await writeFile(file, value);
+}
+async function readText(file) {
+  return readFile(file, "utf8");
+}
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+function cssModuleScopePath(file) {
+  const normalized = toPosixPath(file);
+  const appIndex = normalized.lastIndexOf("/app/");
+  if (appIndex !== -1)
+    return normalized.slice(appIndex + 1);
+  let dir = path.dirname(file);
+  let fallback;
+  while (true) {
+    const packageFile = path.join(dir, "package.json");
+    if (existsSync(packageFile) || existsSync(path.join(dir, "pnext.config.ts")) || existsSync(path.join(dir, "node_modules"))) {
+      const relative = toPosixPath(path.relative(dir, file));
+      try {
+        const { name } = JSON.parse(readFileSync(packageFile, "utf8"));
+        if (typeof name === "string")
+          return `${name}/${relative}`;
+      } catch {}
+      fallback ??= relative;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir)
+      return fallback ?? path.basename(file);
+    dir = parent;
+  }
+}
+function pnextVersionRange() {
+  const pkgPath = fileURLToPath(new URL("../../package.json", Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/utils/fs.ts").href));
+  const { version } = JSON.parse(readFileSync(pkgPath, "utf8"));
+  return `^${version}`;
+}
+function pnextOptionalDependencyRange(name) {
+  const pkgPath = fileURLToPath(new URL("../../package.json", Bun.pathToFileURL(__PNEXT_PACKAGE_ROOT__ + "/src/utils/fs.ts").href));
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  return pkg.optionalDependencies?.[name];
+}
+function includeTypes(config, files, defaults) {
+  if (!("include" in config)) {
+    config.include = [...files, ...defaults];
+    return files;
+  }
+  const include = config.include;
+  if (!Array.isArray(include))
+    return [];
+  const added = files.filter((file) => !include.includes(file));
+  include.push(...added);
+  return added;
+}
+var frameworkRoot = path.resolve(__PNEXT_PACKAGE_ROOT__ + "/src/utils", "..", "..");
+var frameworkPrefix = "pnext:";
+function serializeBuildManifest(data) {
+  const { root, appDir, outDir } = data;
+  const relative = (file) => {
+    const inRoot = toPosixPath(path.relative(root, file));
+    if (!inRoot.startsWith(".."))
+      return inRoot;
+    const inFramework = toPosixPath(path.relative(frameworkRoot, file));
+    return inFramework.startsWith("..") ? inRoot : `${frameworkPrefix}${inFramework}`;
+  };
+  const stored = {
+    ...mapSourcePaths(data, relative),
+    root: toPosixPath(path.relative(outDir, root)) || ".",
+    appDir: toPosixPath(path.relative(root, appDir)),
+    outDir: "."
+  };
+  return `${JSON.stringify(stored, null, 2)}
+`;
+}
+function resolveManifest(data, outPath, root, framework = frameworkRoot) {
+  if (path.isAbsolute(data.root))
+    return data;
+  const absolute = (file) => file.startsWith(frameworkPrefix) ? path.join(framework, file.slice(frameworkPrefix.length)) : path.join(root, file);
+  return {
+    ...mapSourcePaths(data, absolute),
+    root,
+    appDir: absolute(data.appDir),
+    outDir: outPath
+  };
+}
+var sourcePathFields = [
+  "file",
+  "sourceFiles",
+  "cssImports",
+  "templateFiles",
+  "forbiddenFiles",
+  "unauthorizedFiles",
+  "slotDirs",
+  "slotDir",
+  "syntheticSlotDir",
+  "childrenDefault",
+  "serverActionFile",
+  "globalErrorFile"
+];
+function mapSourcePaths(data, map) {
+  function owner(value) {
+    if (!value)
+      return value;
+    const mapped2 = { ...value };
+    for (const key of sourcePathFields) {
+      const field = value[key];
+      if (field !== undefined)
+        mapped2[key] = Array.isArray(field) ? field.map(map) : map(field);
+    }
+    return mapped2;
+  }
+  const mapped = owner(data);
+  mapped.routes = data.routes.map((route) => ({
+    ...owner(route),
+    clientReferences: route.clientReferences.map(owner),
+    ...route.interception && { interception: owner(route.interception) }
+  }));
+  if (data.staticMetadataFiles)
+    mapped.staticMetadataFiles = data.staticMetadataFiles.map(owner);
+  if (data.staticRouteMetadata) {
+    mapped.staticRouteMetadata = Object.fromEntries(Object.entries(data.staticRouteMetadata).map(([route, entry]) => [
+      route,
+      {
+        ...entry,
+        favicon: owner(entry.favicon),
+        manifest: owner(entry.manifest),
+        icons: entry.icons.map(owner),
+        appleIcons: entry.appleIcons.map(owner),
+        rootIcons: entry.rootIcons.map(owner)
+      }
+    ]));
+  }
+  if (data.staticModuleMetadata) {
+    mapped.staticModuleMetadata = Object.fromEntries(Object.entries(data.staticModuleMetadata).map(([file, metadata]) => [map(file), metadata]));
+  }
+  return mapped;
+}
+
+export { writeFileAtomic, listFiles, withDirCache, readDirListing, exactNameIndex, hasExactName, listFilesSync, ensureEmptyDir, ensureDir, writeText, readText, toPosixPath, cssModuleScopePath, pnextVersionRange, pnextOptionalDependencyRange, includeTypes, serializeBuildManifest, resolveManifest };

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

@@ -0,0 +1,10 @@
+// @bun
+// src/compat/next/constants.ts
+var PHASE_EXPORT = "phase-export";
+var PHASE_PRODUCTION_BUILD = "phase-production-build";
+var PHASE_PRODUCTION_SERVER = "phase-production-server";
+var PHASE_DEVELOPMENT_SERVER = "phase-development-server";
+var PHASE_TEST = "phase-test";
+var PHASE_INFO = "phase-info";
+
+export { PHASE_EXPORT, PHASE_PRODUCTION_BUILD, PHASE_PRODUCTION_SERVER, PHASE_DEVELOPMENT_SERVER, PHASE_TEST, PHASE_INFO };

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

@@ -0,0 +1,95 @@
+// @bun
+import {
+  getRequestRuntime
+} from "./index-z88qv16t.js";
+import {
+  getNextConfig
+} from "./index-m63czgq5.js";
+
+// src/compat/next/route-state.ts
+function publicSegments(route) {
+  if (route === "index" || route === "/")
+    return [];
+  return route.split("/").filter(Boolean);
+}
+function isDynamicSegment(segment) {
+  return segment.startsWith(":");
+}
+function staticSiblingNames(routes, pattern) {
+  for (let index = pattern.length - 1;index >= 0; index--) {
+    if (isDynamicSegment(pattern[index]))
+      return staticSiblingNamesAt(routes, pattern, index);
+  }
+  return [];
+}
+function staticSiblingNamesBySegment(routes, pattern) {
+  const result = {};
+  for (let index = 0;index < pattern.length; index++) {
+    if (!isDynamicSegment(pattern[index]))
+      continue;
+    const siblings = staticSiblingNamesAt(routes, pattern, index);
+    result[String(index)] = siblings;
+  }
+  return result;
+}
+function staticSiblingNamesAt(routes, pattern, level) {
+  if (!isDynamicSegment(pattern[level]))
+    return [];
+  const names = new Set;
+  for (const route of routes) {
+    if (route.kind !== "page" || route.interception)
+      continue;
+    const segments = publicSegments(route.route);
+    if (segments.length <= level)
+      continue;
+    let compatible = true;
+    for (let index = 0;index < level; index++) {
+      const own = pattern[index];
+      const other = segments[index];
+      if (isDynamicSegment(own) || isDynamicSegment(other))
+        continue;
+      if (own !== other) {
+        compatible = false;
+        break;
+      }
+    }
+    if (!compatible)
+      continue;
+    const name = segments[level];
+    if (!isDynamicSegment(name))
+      names.add(name);
+  }
+  return [...names].sort();
+}
+function paramsPrerendered(route, params) {
+  const sets = route.prerenderedParams;
+  if (!sets?.length)
+    return false;
+  if (Object.keys(params).length !== (route.params ?? []).length)
+    return false;
+  return sets.some((set) => {
+    const names = Object.keys(set);
+    return names.length === Object.keys(params).length && names.every((name) => String(set[name]) === String(params[name]));
+  });
+}
+function nextClientRouteState(route, state) {
+  const pattern = state.route.split("/").filter(Boolean);
+  const routes = getRequestRuntime()?.routes;
+  if (!routes)
+    return state;
+  const staticChildrenBySegment = staticSiblingNamesBySegment(routes, pattern);
+  const staticChildren = staticSiblingNames(routes, pattern);
+  const globalEager = getNextConfig().partialPrefetching === "unstable_eager";
+  const declared = route.segmentConfig?.prefetch;
+  const partiallyEnumerated = route.stream?.hasLoadingBoundary === true && !paramsPrerendered(route, state.params);
+  const prefetchKind = declared === "unstable_eager" || declared === undefined && (globalEager || route.hasStaticParams && !route.usesRequest && !partiallyEnumerated) ? "eager" : declared === "allow-runtime" || declared === "partial" ? "shell" : undefined;
+  return {
+    ...state,
+    ...staticChildren.length > 0 ? { staticChildren } : {},
+    ...Object.keys(staticChildrenBySegment).length > 0 ? { staticChildrenBySegment } : {},
+    ...prefetchKind ? { prefetchKind } : {},
+    ...declared === "allow-runtime" ? { runtimePrefetch: true } : {}
+  };
+}
+
+export { staticSiblingNames, staticSiblingNamesBySegment, nextClientRouteState };

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

@@ -0,0 +1,70 @@
+// @bun
+// src/routing/forwarded.ts
+var FORWARDED_HOST = "x-forwarded-host";
+var FORWARDED_PORT = "x-forwarded-port";
+var FORWARDED_PROTO = "x-forwarded-proto";
+var FORWARDED_FOR = "x-forwarded-for";
+function withForwardedHeaders(request, peer) {
+  const headers = request.headers;
+  const hasHost = headers.has(FORWARDED_HOST);
+  const hasPort = headers.has(FORWARDED_PORT);
+  const hasProto = headers.has(FORWARDED_PROTO);
+  const hasFor = headers.has(FORWARDED_FOR);
+  if (hasHost && hasPort && hasProto && (hasFor || !peer))
+    return request;
+  let url;
+  try {
+    url = new URL(request.url);
+  } catch {
+    return request;
+  }
+  const host = headers.get("host") ?? url.host;
+  const proto = url.protocol.replace(":", "");
+  const port = url.port;
+  const next = new Headers(headers);
+  if (!hasHost)
+    next.set(FORWARDED_HOST, host);
+  if (!hasPort)
+    next.set(FORWARDED_PORT, port);
+  if (!hasProto)
+    next.set(FORWARDED_PROTO, proto);
+  if (!hasFor && peer) {
+    const address = peer.requestIP(request)?.address;
+    if (address)
+      next.set(FORWARDED_FOR, address);
+  }
+  return new Request(request, { headers: next });
+}
+
+// src/utils/content-type.ts
+import path from "path";
+var contentTypes = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".css": "text/css; charset=utf-8",
+  ".eot": "application/vnd.ms-fontobject",
+  ".gif": "image/gif",
+  ".htm": "text/html; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".otf": "font/otf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function contentType(file) {
+  return contentTypes[path.extname(file).toLowerCase()] ?? "application/octet-stream";
+}
+
+export { withForwardedHeaders, contentType };

package/dist/dash/standalone/node_modules/@wular/pnext/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/dash/standalone/node_modules/@wular/pnext/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/dash/standalone/node_modules/@wular/pnext/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 };