@wular/pnext 0.1.5 → 0.1.7

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

@@ -0,0 +1,356 @@
+// @bun
+// src/compat/next/image/props.ts
+var DEFAULT_IMAGES_CONFIG = {
+  deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+  imageSizes: [32, 48, 64, 96, 128, 256, 384],
+  allSizes: [32, 48, 64, 96, 128, 256, 384, 640, 750, 828, 1080, 1200, 1920, 2048, 3840],
+  qualities: [75],
+  formats: ["image/webp"],
+  path: "/_next/image",
+  loader: "default",
+  loaderFile: "",
+  domains: [],
+  disableStaticImages: false,
+  minimumCacheTTL: 14400,
+  maximumRedirects: 3,
+  maximumResponseBody: 50000000,
+  dangerouslyAllowLocalIP: false,
+  dangerouslyAllowSVG: false,
+  contentSecurityPolicy: `script-src 'none'; frame-src 'none'; sandbox;`,
+  contentDispositionType: "attachment",
+  localPatterns: undefined,
+  remotePatterns: [],
+  unoptimized: false,
+  customCacheHandler: false
+};
+var INVALID_BACKGROUND_SIZE = new Set([
+  "-moz-initial",
+  "fill",
+  "none",
+  "scale-down",
+  undefined
+]);
+function unwrapStaticImport(src) {
+  return "default" in src ? src.default : src;
+}
+function toNumber(value) {
+  if (value === undefined)
+    return;
+  if (typeof value === "number")
+    return value;
+  const n = parseInt(value, 10);
+  return Number.isNaN(n) ? undefined : n;
+}
+function getImagesConfig() {
+  return typeof __PNEXT_IMAGE_CONFIG_INLINED__ === "boolean" ? __PNEXT_IMAGE_CONFIG_INLINE__ : globalThis.__PNEXT_IMAGE_CONFIG__ ?? DEFAULT_IMAGES_CONFIG;
+}
+function defaultLoader(config, src, width, quality) {
+  const q = findClosestQuality(config, quality);
+  return `${config.path}?url=${encodeURIComponent(src)}&w=${width}&q=${q}`;
+}
+function findClosestQuality(config, quality) {
+  const qualities = config.qualities;
+  if (!qualities || qualities.length === 0)
+    return quality ?? 75;
+  if (quality === undefined)
+    return closest(qualities, 75);
+  return closest(qualities, quality);
+}
+function closest(values, target) {
+  let best = values[0];
+  let bestDelta = Math.abs(best - target);
+  for (const value of values) {
+    const delta = Math.abs(value - target);
+    if (delta < bestDelta) {
+      best = value;
+      bestDelta = delta;
+    }
+  }
+  return best;
+}
+function getWidths(config, width, sizes) {
+  const { deviceSizes, allSizes } = config;
+  if (sizes) {
+    const viewportWidthRe = /(^|\s)(1?\d?\d)vw/g;
+    const percentSizes = [];
+    for (let match;match = viewportWidthRe.exec(sizes); ) {
+      percentSizes.push(parseInt(match[2], 10));
+    }
+    if (percentSizes.length) {
+      const smallestRatio = Math.min(...percentSizes) * 0.01;
+      return {
+        widths: allSizes.filter((s) => s >= deviceSizes[0] * smallestRatio),
+        kind: "w"
+      };
+    }
+    return { widths: allSizes, kind: "w" };
+  }
+  if (typeof width !== "number")
+    return { widths: deviceSizes, kind: "w" };
+  const widths = [
+    ...new Set([width, width * 2].map((w) => allSizes.find((p) => p >= w) || allSizes[allSizes.length - 1]))
+  ];
+  return { widths, kind: "x" };
+}
+function generateImgAttrs(params) {
+  const { config, src, unoptimized, width, quality, sizes, loader } = params;
+  if (unoptimized)
+    return { src, srcSet: undefined, sizes: undefined };
+  const { widths, kind } = getWidths(config, width, sizes);
+  const last = widths.length - 1;
+  return {
+    sizes: !sizes && kind === "w" ? "100vw" : sizes,
+    srcSet: widths.map((w, i) => `${loader({ config, src, quality, width: w })} ${kind === "w" ? w : i + 1}${kind}`).join(", "),
+    src: loader({ config, src, quality, width: widths[last] })
+  };
+}
+function getImageBlurSvg(params) {
+  const { widthInt, heightInt, blurWidth, blurHeight, blurDataURL, objectFit } = params;
+  const std = 20;
+  const svgWidth = blurWidth ? blurWidth * 40 : widthInt;
+  const svgHeight = blurHeight ? blurHeight * 40 : heightInt;
+  const viewBox = svgWidth && svgHeight ? `viewBox='0 0 ${svgWidth} ${svgHeight}'` : "";
+  const preserveAspectRatio = viewBox ? "none" : objectFit === "contain" ? "xMidYMid" : objectFit === "cover" ? "xMidYMid slice" : "none";
+  return `%3Csvg xmlns='http://www.w3.org/2000/svg' ${viewBox}%3E%3Cfilter id='b' color-interpolation-filters='sRGB'%3E%3CfeGaussianBlur stdDeviation='${std}'/%3E%3CfeColorMatrix values='1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 100 -1' result='s'/%3E%3CfeFlood x='0' y='0' width='100%25' height='100%25'/%3E%3CfeComposite operator='out' in='s'/%3E%3CfeComposite in2='SourceGraphic'/%3E%3CfeGaussianBlur stdDeviation='${std}'/%3E%3C/filter%3E%3Cimage width='100%25' height='100%25' x='0' y='0' preserveAspectRatio='${preserveAspectRatio}' style='filter: url(%23b);' href='${blurDataURL}'/%3E%3C/svg%3E`;
+}
+function getImageProps(imageProps) {
+  const resolved = resolveImageProps(imageProps, getImagesConfig());
+  return { props: resolved.props };
+}
+function unstable_getImgProps(imageProps) {
+  return getImageProps(imageProps);
+}
+function resolveImageProps(imageProps, config, blurComplete = false, showAltText = false) {
+  const {
+    src: rawSrc,
+    alt = "",
+    width: widthProp,
+    height: heightProp,
+    fill: fillProp = false,
+    loader,
+    quality: qualityProp,
+    priority = false,
+    preload = false,
+    loading,
+    placeholder = "empty",
+    blurDataURL: blurDataURLProp,
+    unoptimized: unoptimizedProp,
+    overrideSrc,
+    sizes: sizesProp,
+    fetchPriority,
+    decoding = "async",
+    style: styleProp,
+    layout,
+    objectFit,
+    objectPosition,
+    onLoad: _onLoad,
+    onError: _onError,
+    onLoadingComplete: _onLoadingComplete,
+    ...rest
+  } = imageProps;
+  let fill = fillProp;
+  let sizes = sizesProp;
+  let userStyle = normalizeStyle(styleProp);
+  if (layout) {
+    if (layout === "fill")
+      fill = true;
+    const layoutStyle = layout === "intrinsic" ? { maxWidth: "100%", height: "auto" } : layout === "responsive" ? { width: "100%", height: "auto" } : undefined;
+    if (layoutStyle)
+      userStyle = { ...userStyle, ...layoutStyle };
+    if (!sizes && (layout === "responsive" || layout === "fill"))
+      sizes = "100vw";
+  }
+  const staticData = rawSrc && typeof rawSrc !== "string" ? unwrapStaticImport(rawSrc) : undefined;
+  const src = typeof rawSrc === "string" ? rawSrc : staticData?.src ?? "";
+  let width = toNumber(widthProp);
+  let height = toNumber(heightProp);
+  if (staticData) {
+    if (width === undefined && height === undefined) {
+      width = staticData.width;
+      height = staticData.height;
+    } else if (width !== undefined && height === undefined) {
+      height = Math.round(staticData.height / staticData.width * width);
+    } else if (height !== undefined && width === undefined) {
+      width = Math.round(staticData.width / staticData.height * height);
+    }
+  }
+  const blurDataURL = blurDataURLProp ?? staticData?.blurDataURL;
+  const quality = toNumber(qualityProp);
+  let unoptimized = Boolean(unoptimizedProp ?? config.unoptimized);
+  if (!src || src.startsWith("data:") || src.startsWith("blob:"))
+    unoptimized = true;
+  const isDefaultLoader = !loader && !config.loaderFile;
+  if (isDefaultLoader && !config.dangerouslyAllowSVG && (src.split("?", 1)[0] ?? "").endsWith(".svg")) {
+    unoptimized = true;
+  }
+  if (!unoptimized)
+    validateLocalSrc(config, src);
+  const activeLoader = loader ? ({ src: s, width: w, quality: q }) => loader({ src: s, width: w, quality: q }) : ({ config: c, src: s, width: w, quality: q }) => defaultLoader(c, s, w, q);
+  const imgAttrs = generateImgAttrs({
+    config,
+    src,
+    unoptimized,
+    width: fill ? undefined : width,
+    quality,
+    sizes,
+    loader: activeLoader
+  });
+  const isBlur = placeholder === "blur" && Boolean(blurDataURL);
+  const imgStyle = {
+    ...fill ? { ...fillStyle(), objectFit, objectPosition } : {},
+    ...showAltText ? {} : { color: "transparent" },
+    ...userStyle
+  };
+  const objectFitVal = typeof imgStyle.objectFit === "string" ? imgStyle.objectFit : undefined;
+  const backgroundImage = !blurComplete && placeholder !== "empty" ? placeholder === "blur" ? (typeof __PNEXT_IMAGE_BLUR__ === "boolean" ? __PNEXT_IMAGE_BLUR__ : true) && blurDataURL ? `url("data:image/svg+xml;charset=utf-8,${getImageBlurSvg({
+    widthInt: fill ? undefined : width,
+    heightInt: fill ? undefined : height,
+    blurWidth: staticData?.blurWidth,
+    blurHeight: staticData?.blurHeight,
+    blurDataURL,
+    objectFit: objectFitVal
+  })}")` : undefined : `url("${placeholder}")` : undefined;
+  let backgroundSize = "cover";
+  if (objectFitVal === "fill")
+    backgroundSize = "100% 100%";
+  else if (objectFitVal && !INVALID_BACKGROUND_SIZE.has(objectFitVal))
+    backgroundSize = objectFitVal;
+  const placeholderStyle = backgroundImage ? {
+    backgroundSize,
+    backgroundPosition: imgStyle.objectPosition || "50% 50%",
+    backgroundRepeat: "no-repeat",
+    backgroundImage
+  } : {};
+  const style = serializeStyle({ ...imgStyle, ...placeholderStyle });
+  const resolvedSrc = (overrideSrc ?? imgAttrs.src) || undefined;
+  const props = {
+    ...rest,
+    alt,
+    ...resolvedSrc !== undefined ? { src: resolvedSrc } : {},
+    ...imgAttrs.srcSet ? { srcSet: imgAttrs.srcSet } : {},
+    ...imgAttrs.sizes ? { sizes: imgAttrs.sizes } : {},
+    decoding,
+    style
+  };
+  if (!fill) {
+    if (width !== undefined)
+      props.width = width;
+    if (height !== undefined)
+      props.height = height;
+  }
+  if (loading !== undefined)
+    props.loading = loading;
+  else if (!priority && !preload)
+    props.loading = "lazy";
+  if (fetchPriority !== undefined)
+    props.fetchpriority = fetchPriority;
+  return {
+    props,
+    meta: {
+      preload: preload || priority,
+      fill,
+      unoptimized,
+      placeholder: isBlur ? "blur" : String(placeholder),
+      imgAttributes: {
+        src: resolvedSrc ?? "",
+        ...imgAttrs.srcSet ? { srcSet: imgAttrs.srcSet } : {},
+        ...imgAttrs.sizes ? { sizes: imgAttrs.sizes } : {}
+      },
+      ...backgroundImage ? { loadedStyle: serializeStyle(imgStyle) } : {}
+    }
+  };
+}
+function normalizeStyle(style) {
+  if (!style)
+    return {};
+  if (typeof style !== "string")
+    return { ...style };
+  const out = {};
+  for (const decl of style.split(";")) {
+    const [k, v] = decl.split(":");
+    if (k && v)
+      out[camel(k.trim())] = v.trim();
+  }
+  return out;
+}
+function fillStyle() {
+  return {
+    position: "absolute",
+    height: "100%",
+    width: "100%",
+    left: "0",
+    top: "0",
+    right: "0",
+    bottom: "0"
+  };
+}
+function validateLocalSrc(config, src) {
+  if (!src.startsWith("/") || src.startsWith("//") || config.localPatterns !== undefined)
+    return;
+  const search = new URL(src, "http://n").search;
+  if (!search)
+    return;
+  throw new Error(`Image with src "${src}" is using a query string which is not configured in images.localPatterns.
+Read more: https://nextjs.org/docs/messages/next-image-unconfigured-localpatterns`);
+}
+function camel(prop) {
+  return prop.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+var UNITLESS_STYLE_PROPS = new Set([
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "gridArea",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "fontWeight",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "floodOpacity",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth"
+]);
+function serializeStyle(style) {
+  return Object.entries(style).filter(([, v]) => v !== undefined && v !== "").map(([k, v]) => `${kebab(k)}:${cssValue(k, v)}`).join(";");
+}
+function cssValue(prop, value) {
+  if (typeof value === "number" && value !== 0 && !UNITLESS_STYLE_PROPS.has(prop))
+    return `${value}px`;
+  return String(value);
+}
+function kebab(prop) {
+  return prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+
+export { getImagesConfig, findClosestQuality, getImageProps, unstable_getImgProps, resolveImageProps };

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

@@ -0,0 +1,185 @@
+// @bun
+import {
+  assertDraftModeToggleAllowedInAfter,
+  assertRequestApiAllowedInAfter,
+  lifecycleError
+} from "./index-2vz0wzdn.js";
+import {
+  withSyncAccess
+} from "./index-0374j2b9.js";
+import {
+  assertNoDynamicApiInsideCache,
+  currentRenderCacheMeta
+} from "./index-9n2914ww.js";
+import {
+  currentRequest,
+  currentResponseHeaders,
+  getWorkUnit,
+  legacyRequestAPIs,
+  requestApiPromise,
+  requireRequest
+} from "./index-grta8ap3.js";
+
+// src/compat/next/headers.ts
+var COOKIE_MUTATION_ERROR = "Cookies can only be modified in a Server Action or Route Handler. " + "Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options";
+function assertCookieMutationAllowed() {
+  const unit = getWorkUnit();
+  if (!unit)
+    return;
+  if (unit.phase === "action")
+    return;
+  if (unit.phase !== "after" && unit.routeKind === "route-handler")
+    return;
+  throw new Error(COOKIE_MUTATION_ERROR);
+}
+var HEADERS_MUTATION_ERROR = "Headers cannot be modified. Read more: https://nextjs.org/docs/app/api-reference/functions/headers";
+function readonlyHeaders(source) {
+  return new Proxy(source, {
+    get(target, prop) {
+      if (prop === "append" || prop === "set" || prop === "delete") {
+        return () => {
+          throw new Error(HEADERS_MUTATION_ERROR);
+        };
+      }
+      if (prop === "getSetCookie")
+        return () => [];
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function headers() {
+  assertRequestApiAllowedInAfter("headers()");
+  assertDynamicErrorRequestApi("headers()");
+  assertNoDynamicApiInsideCache("headers()");
+  const produce = () => readonlyHeaders(new Headers(requireRequest("headers()").headers));
+  const promise = requestApiPromise("headers()", produce);
+  return legacyRequestAPIs() ? withSyncAccess(promise, "headers", produce) : promise;
+}
+function cookies() {
+  assertRequestApiAllowedInAfter("cookies()");
+  assertDynamicErrorRequestApi("cookies()");
+  assertNoDynamicApiInsideCache("cookies()");
+  const produce = () => wrapCookieJar(requireRequest("cookies()").cookies);
+  const promise = requestApiPromise("cookies()", produce);
+  return legacyRequestAPIs() ? withSyncAccess(promise, "cookies", produce) : promise;
+}
+function assertDynamicErrorRequestApi(api) {
+  const meta = currentRenderCacheMeta();
+  if (!meta?.dynamicError)
+    return;
+  throw lifecycleError(`Route ${meta.route ?? ""} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${api}\`.`);
+}
+function wrapCookieJar(jar) {
+  return {
+    get: (name) => jar.get(cookieName(name)),
+    getAll: (name) => name === undefined ? jar.getAll() : jar.getAll(cookieName(name)),
+    has: (name) => jar.has(cookieName(name)),
+    get size() {
+      return jar.getAll().length;
+    },
+    [Symbol.iterator]() {
+      return jar.getAll().map((cookie) => [cookie.name, cookie])[Symbol.iterator]();
+    },
+    set(nameOrOptions, value, options) {
+      assertCookieMutationAllowed();
+      const parsed = normalizeSetArgs(nameOrOptions, value, options);
+      jar.set(parsed.name, parsed.value);
+      currentResponseHeaders()?.append("set-cookie", serializeSetCookie(parsed));
+      return this;
+    },
+    delete(name) {
+      assertCookieMutationAllowed();
+      const resolved = cookieName(name);
+      const existed = jar.delete(resolved);
+      currentResponseHeaders()?.append("set-cookie", serializeSetCookie({ name: resolved, value: "", path: "/", maxAge: 0 }));
+      return existed;
+    },
+    clear() {
+      for (const cookie of jar.getAll())
+        this.delete(cookie.name);
+      return this;
+    },
+    toString() {
+      return jar.getAll().map((cookie) => `${cookie.name}=${encodeURIComponent(cookie.value)}`).join("; ");
+    }
+  };
+}
+function cookieName(arg) {
+  if (typeof arg === "string")
+    return arg;
+  return typeof arg?.name === "string" ? arg.name : "";
+}
+function normalizeSetArgs(nameOrOptions, value, options) {
+  if (typeof nameOrOptions === "string") {
+    return { ...options ?? {}, name: nameOrOptions, value: stringifyCookieValue(value) };
+  }
+  return {
+    ...nameOrOptions,
+    name: String(nameOrOptions.name ?? ""),
+    value: String(nameOrOptions.value ?? "")
+  };
+}
+function stringifyCookieValue(raw) {
+  if (raw === undefined || raw === null)
+    return "";
+  if (typeof raw === "string")
+    return raw;
+  if (typeof raw === "number" || typeof raw === "boolean" || typeof raw === "bigint") {
+    return String(raw);
+  }
+  return JSON.stringify(raw) ?? "";
+}
+function serializeSetCookie(cookie) {
+  const parts = [`${cookie.name}=${encodeURIComponent(cookie.value)}`];
+  parts.push(`Path=${cookie.path ?? "/"}`);
+  if (cookie.maxAge !== undefined)
+    parts.push(`Max-Age=${cookie.maxAge}`);
+  if (cookie.expires !== undefined) {
+    const date = cookie.expires instanceof Date ? cookie.expires : new Date(cookie.expires);
+    parts.push(`Expires=${date.toUTCString()}`);
+  }
+  if (cookie.domain)
+    parts.push(`Domain=${cookie.domain}`);
+  if (cookie.httpOnly)
+    parts.push("HttpOnly");
+  if (cookie.secure)
+    parts.push("Secure");
+  if (cookie.sameSite) {
+    const value = cookie.sameSite === true ? "Strict" : capitalize(cookie.sameSite);
+    parts.push(`SameSite=${value}`);
+  }
+  return parts.join("; ");
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+var draftCookieName = "__prerender_bypass";
+function draftMode() {
+  const request = currentRequest();
+  const requestCookies = request?.cookies;
+  const draft = {
+    get isEnabled() {
+      return requestCookies?.has(draftCookieName) ?? false;
+    },
+    enable() {
+      assertDraftModeToggleAllowedInAfter("enable");
+      const cookies2 = requireRequest("draftMode().enable()").cookies;
+      const value = cookies2.get(draftCookieName)?.value || bypassToken();
+      cookies2.set(draftCookieName, value);
+      currentResponseHeaders()?.append("set-cookie", `${draftCookieName}=${value}; Path=/; HttpOnly; SameSite=None; Secure`);
+    },
+    disable() {
+      assertDraftModeToggleAllowedInAfter("disable");
+      requireRequest("draftMode().disable()").cookies.delete(draftCookieName);
+      currentResponseHeaders()?.append("set-cookie", `${draftCookieName}=; Path=/; Max-Age=0; HttpOnly; SameSite=None; Secure`);
+    }
+  };
+  const promise = Promise.resolve(draft);
+  return legacyRequestAPIs() ? withSyncAccess(promise, "draftMode", () => draft) : promise;
+}
+function bypassToken() {
+  return globalThis.crypto?.randomUUID?.().replace(/-/g, "") ?? Math.random().toString(36).slice(2);
+}
+
+export { headers, cookies, assertDynamicErrorRequestApi, draftMode };