@wular/pnext 0.1.5 → 0.1.7

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-5gyr4emz.js

@@ -0,0 +1,107 @@
+// @bun
+import {
+  onExtensionHostReset
+} from "./index-zqpqyg8p.js";
+import {
+  __require
+} from "./index-rt9qq1va.js";
+
+// src/runtime/fetch-host.ts
+var installed = false;
+var upstreamAborts = new WeakMap;
+function isHostKey(key) {
+  return typeof key === "string" && key.length === 4 && key.toLowerCase() === "host";
+}
+function hasHost(headers) {
+  if (headers instanceof Headers)
+    return headers.has("host");
+  if (Array.isArray(headers)) {
+    for (const entry of headers)
+      if (isHostKey(entry?.[0]))
+        return true;
+    return false;
+  }
+  for (const key in headers)
+    if (isHostKey(key))
+      return true;
+  return false;
+}
+function withoutHost(headers) {
+  const next = new Headers(headers);
+  next.delete("host");
+  return next;
+}
+function installFetchHostNormalization() {
+  if (installed)
+    return;
+  installed = true;
+  const original = globalThis.fetch.bind(globalThis);
+  globalThis.fetch = function fetch(input, init) {
+    const source = init?.headers ?? (input instanceof Request ? input.headers : undefined);
+    const normalized = source !== undefined && hasHost(source) ? { ...init, headers: withoutHost(source) } : init;
+    return trackUpstream(original, input, normalized);
+  };
+}
+function trackUpstream(original, input, init) {
+  const controller = new AbortController;
+  const caller = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+  const signal = caller ? AbortSignal.any([caller, controller.signal]) : controller.signal;
+  return original(input, { ...init, signal }).then((response) => {
+    if (response.body)
+      upstreamAborts.set(response.body, controller);
+    return response;
+  });
+}
+function abortUpstreamFetchOnDisconnect(body, signal) {
+  if (!body || !signal || !upstreamAborts.has(body))
+    return;
+  const abort = () => {
+    const controller = upstreamAborts.get(body);
+    if (!controller)
+      return;
+    upstreamAborts.delete(body);
+    controller.abort();
+  };
+  if (signal.aborted)
+    abort();
+  else
+    signal.addEventListener("abort", abort, { once: true });
+}
+
+// src/compat-bootstrap.ts
+function compatEnabled(config) {
+  const compat = config.compat;
+  return Boolean(compat?.next || compat?.react || compat?.reactCompiler);
+}
+var bootRegistration;
+var registration;
+onExtensionHostReset(() => {
+  bootRegistration = undefined;
+  registration = undefined;
+});
+function bootstrapCompatBoot(config) {
+  installFetchHostNormalization();
+  if (!compatEnabled(config))
+    return Promise.resolve();
+  bootRegistration ??= import("./boot-af0mv3dy.js").then((module) => module.registerCompatBootExtensions(config));
+  return bootRegistration;
+}
+function bootstrapCompat(config, options = {}) {
+  installFetchHostNormalization();
+  if (!compatEnabled(config))
+    return Promise.resolve();
+  registration ??= bootstrapCompatBoot(config).then(() => import("./index-ggk2j965.js")).then((module) => module.registerCompatExtensions(config, options));
+  return registration;
+}
+async function generateCompatRouteTypes(config, routes) {
+  if (!config.compat?.next)
+    return;
+  const [{ writeTsconfigDefaults }, { generateTypedRoutes }] = await Promise.all([
+    import("./tsconfig-defaults-1nb3308g.js"),
+    import("./generate-n9sh6hzt.js")
+  ]);
+  await writeTsconfigDefaults(config);
+  await generateTypedRoutes(config, routes);
+}
+
+export { abortUpstreamFetchOnDisconnect, bootstrapCompatBoot, bootstrapCompat, generateCompatRouteTypes };

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

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