@wular/pnext 0.1.6 → 0.1.8

package/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/server/_chunks/index-4t92hdxd.js

@@ -0,0 +1,172 @@
+// @bun
+import {
+  getImagesConfig,
+  resolveImageProps
+} from "./index-rthrsed5.js";
+
+// src/compat/next/image/client.tsx
+import {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState
+} from "preact/compat";
+import { jsx, jsxs, Fragment } from "preact/jsx-runtime";
+"use client";
+var useSettleEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
+function hydrating() {
+  return typeof window !== "undefined" && !window.__NEXT_HYDRATED;
+}
+function handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete) {
+  if (!img)
+    return;
+  const src = img.src;
+  const marker = img;
+  if (marker["data-loaded-src"] === src)
+    return;
+  marker["data-loaded-src"] = src;
+  const p = "decode" in img ? img.decode() : Promise.resolve();
+  p.catch(() => {
+    return;
+  }).then(() => {
+    if (!img.parentElement || !img.isConnected)
+      return;
+    if (placeholder !== "empty")
+      setBlurComplete(true);
+    if (onLoadRef.current) {
+      const event = new Event("load");
+      Object.defineProperty(event, "target", { writable: false, value: img });
+      let prevented = false;
+      let stopped = false;
+      onLoadRef.current({
+        ...event,
+        nativeEvent: event,
+        currentTarget: img,
+        target: img,
+        isDefaultPrevented: () => prevented,
+        isPropagationStopped: () => stopped,
+        persist: () => {
+          return;
+        },
+        preventDefault: () => {
+          prevented = true;
+          event.preventDefault();
+        },
+        stopPropagation: () => {
+          stopped = true;
+          event.stopPropagation();
+        }
+      });
+    }
+    if (onLoadingCompleteRef.current)
+      onLoadingCompleteRef.current(img);
+  });
+}
+function useMergedRef(refA, refB) {
+  const cleanupA = useRef(null);
+  const cleanupB = useRef(null);
+  return useCallback((current) => {
+    if (current === null) {
+      cleanupA.current?.();
+      cleanupA.current = null;
+      cleanupB.current?.();
+      cleanupB.current = null;
+    } else {
+      if (refA)
+        cleanupA.current = applyRef(refA, current);
+      if (refB)
+        cleanupB.current = applyRef(refB, current);
+    }
+  }, [refA, refB]);
+}
+function applyRef(ref, current) {
+  if (typeof ref === "function") {
+    const cleanup = ref(current);
+    return typeof cleanup === "function" ? cleanup : () => ref(null);
+  }
+  ref.current = current;
+  return () => {
+    ref.current = null;
+  };
+}
+var Image = forwardRef(function Image2({ __pnextConfig, ...imageProps }, forwardedRef) {
+  const config = __pnextConfig ?? getImagesConfig();
+  const [blurComplete, setBlurComplete] = useState(false);
+  const [showAltText, setShowAltText] = useState(false);
+  const { props, meta } = resolveImageProps(imageProps, config, blurComplete, showAltText);
+  const { onLoad, onError, onLoadingComplete } = imageProps;
+  const onLoadRef = useRef(onLoad);
+  useEffect(() => {
+    onLoadRef.current = onLoad;
+  }, [onLoad]);
+  const onLoadingCompleteRef = useRef(onLoadingComplete);
+  useEffect(() => {
+    onLoadingCompleteRef.current = onLoadingComplete;
+  }, [onLoadingComplete]);
+  const placeholder = meta.placeholder;
+  const renderedSrc = typeof props.src === "string" ? props.src : "";
+  const insertedImgRef = useRef(null);
+  const settledSrcRef = useRef(undefined);
+  const swallowErrorRef = useRef(false);
+  useSettleEffect(() => {
+    const img = insertedImgRef.current;
+    if (img === null || settledSrcRef.current === renderedSrc)
+      return;
+    settledSrcRef.current = renderedSrc;
+    if (onError) {
+      if (img.complete) {
+        const currentSrc = img.src;
+        img.src = currentSrc;
+      } else if (hydrating()) {
+        swallowErrorRef.current = true;
+        img.addEventListener("error", () => {
+          swallowErrorRef.current = false;
+          const failedSrc = img.src;
+          img.src = failedSrc;
+        }, { once: true });
+      }
+    }
+    const settle = () => handleLoading(img, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete);
+    if (img.complete)
+      settle();
+  }, [renderedSrc, placeholder, onError]);
+  const ref = useMergedRef(forwardedRef, insertedImgRef);
+  const extra = imageProps;
+  const preloadLink = meta.preload ? /* @__PURE__ */ jsx("link", {
+    rel: "preload",
+    as: "image",
+    href: meta.imgAttributes.srcSet ? undefined : meta.imgAttributes.src,
+    ...{
+      imagesrcset: meta.imgAttributes.srcSet,
+      imagesizes: meta.imgAttributes.sizes,
+      crossOrigin: extra.crossOrigin,
+      referrerPolicy: extra.referrerPolicy,
+      fetchpriority: extra.fetchPriority
+    }
+  }) : null;
+  return /* @__PURE__ */ jsxs(Fragment, {
+    children: [
+      preloadLink,
+      /* @__PURE__ */ jsx("img", {
+        ...props,
+        "data-nimg": meta.fill ? "fill" : "1",
+        ref,
+        onLoad: (event) => {
+          handleLoading(event.currentTarget, placeholder, onLoadRef, onLoadingCompleteRef, setBlurComplete);
+        },
+        onError: (event) => {
+          setShowAltText(true);
+          if (placeholder !== "empty")
+            setBlurComplete(true);
+          if (swallowErrorRef.current)
+            return;
+          onError?.(event);
+        }
+      })
+    ]
+  });
+});
+var client_default = Image;
+export { Image, client_default };

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